Merge pull request ByteByteGoHq#19 from ongshunping/cpp-solutions-sliding-windows

Add C++ solutions for Chapter 5 (Sliding Windows)

Author: Destiny-02

cpp/Sliding Windows/longest_substring_with_unique_chars.cpp

@@ -0,0 +1,25 @@
+#include <string>
+#include <unordered_set>
+#include <algorithm>
+
+int longestSubstringWithUniqueChars(std::string s) {
+    int maxLen = 0;
+    std::unordered_set<char> hashSet;
+    int left = 0;
+    int right = 0;
+    while (right < s.length()) {
+        // If we encounter a duplicate character in the window, shrink
+        // the window until it's no longer a duplicate.
+        while (hashSet.find(s[right]) != hashSet.end()) {
+            hashSet.erase(s[left]);
+            left++;
+        }
+        // Once there are no more duplicates in the window, update
+        // 'maxLen' if the current window is larger.
+        maxLen = std::max(maxLen, right - left + 1);
+        hashSet.insert(s[right]);
+        // Expand the window.
+        right++;
+    }
+    return maxLen;
+}

cpp/Sliding Windows/longest_substring_with_unique_chars_optimized.cpp

@@ -0,0 +1,26 @@
+#include <string>
+#include <unordered_map>
+#include <algorithm>
+
+int longestSubstringWithUniqueCharsOptimized(std::string s) {
+    int maxLen = 0;
+    std::unordered_map<char, int> prevIndexes;
+    int left = 0;
+    int right = 0;
+    while (right < s.length()) {
+        // If a previous index of the current character is present
+        // in the current window, it's a duplicate character in the 
+        // window.
+        if (prevIndexes.find(s[right]) != prevIndexes.end() && prevIndexes[s[right]] >= left) {
+            // Shrink the window to exclude the previous occurrence 
+            // of this character.
+            left = prevIndexes[s[right]] + 1;
+        }
+        // Update 'maxLen' if the current window is larger.
+        maxLen = std::max(maxLen, right - left + 1);
+        prevIndexes[s[right]] = right;
+        // Expand the window.
+        right++;
+    }
+    return maxLen;
+}

cpp/Sliding Windows/longest_uniform_substring_after_replacements.cpp

@@ -0,0 +1,34 @@
+#include <string>
+#include <unordered_map>
+#include <algorithm>
+
+int longestUniformSubstringAfterReplacements(std::string s, int k) {
+    std::unordered_map<char, int> freqs;
+    int highestFreq = 0;
+    int maxLen = 0;
+    int left = 0;
+    int right = 0;
+    while (right < s.length()) {
+        // Update the frequency of the character at the right pointer
+        // and the highest frequency for the current window.
+        freqs[s[right]] = freqs[s[right]] + 1;  
+        highestFreq = std::max(highestFreq, freqs[s[right]]);
+        // Calculate replacements needed for the current window.
+        int numCharsToReplace = (right - left + 1) - highestFreq;
+        // Slide the window if the number of replacements needed exceeds 
+        // 'k'. The right pointer always gets advanced, so we just need 
+        // to advance 'left'.
+        if (numCharsToReplace > k) {
+            // Remove the character at the left pointer from the hash map
+            // before advancing the left pointer.
+            freqs[s[left]] = freqs[s[left]] - 1;
+            left++;
+        }
+        // Since the length of the current window increases or stays the 
+        // same, assign the length of the current window to 'maxLen'.
+        maxLen = right - left + 1;
+        // Expand the window.
+        right++;
+    }
+    return maxLen;
+}

cpp/Sliding Windows/substring_anagrams.cpp

@@ -0,0 +1,38 @@
+#include <string>
+#include <vector>
+
+int substringAnagrams(std::string s, std::string t) {
+    int lenS = s.length();
+    int lenT = t.length();
+    if (lenT > lenS) {
+        return 0;
+    }
+    int count = 0;
+    std::vector<int> expectedFreqs(26, 0);
+    std::vector<int> windowFreqs(26, 0);
+    // Populate 'expectedFreqs' with the characters in string 't'.
+    for (char c : t) {
+        expectedFreqs[c - 'a'] += 1;
+    }
+    int left = 0;
+    int right = 0;
+    while (right < lenS) {
+        // Add the character at the right pointer to 'windowFreqs'
+        // before sliding the window.
+        windowFreqs[s[right] - 'a'] += 1;
+        // If the window has reached the expected fixed length, we
+        // advance the left pointer as well as the right pointer to
+        // slide the window.
+        if (right - left + 1 == lenT) {
+            if (windowFreqs == expectedFreqs) {
+                count += 1;
+            }
+            // Remove the character at the left pointer from
+            // 'windowFreqs' before advancing the left pointer.
+            windowFreqs[s[left] - 'a'] -= 1;
+            left += 1;
+        }
+        right += 1;
+    }
+    return count;
+}