Merge pull request akgmage#1782 from akgmage/dev

add longest repeated character replacement in c++

Author: akgmage

Sliding Window/longest_repeated_character_replacement.cpp

@@ -0,0 +1,64 @@
+/*
+     You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.
+
+    Return the length of the longest substring containing the same letter you can get after performing the above operations.
+
+    Example 1:
+
+    Input: s = "ABAB", k = 2
+    Output: 4
+    Explanation: Replace the two 'A's with two 'B's or vice versa.
+
+    Summary:
+    The provided code defines a Java class `Solution` with a method `characterReplacement` that aims to find the 
+    longest substring within the input string `s` such that it can be created by replacing at most `k` characters 
+    with any other character. It uses a sliding window approach to efficiently compute the maximum length of such a 
+    substring.
+
+    Time Complexity:
+    - The code iterates through the input string `s` using a sliding window with two pointers 
+    (startWindow and endWindow). During each iteration, it updates character counts and evaluates the 
+    maximum length of a valid substring. Since each character is processed exactly once, the time complexity 
+    is O(N), where N is the length of the input string `s`.
+
+    Space Complexity:
+    - The code uses additional space to store integer variables (`count`, `startWindow`, `maxCount`, and `max`). 
+    The `count` array has a fixed size of 26 (for 26 English alphabet letters). Therefore, the space complexity is
+     O(1), as the space used is constant and does not depend on the input size.
+
+    In summary, the algorithm has a time complexity of O(N) and a space complexity of O(1), making it efficient 
+    for finding the longest substring with at most 'k' replacements in a given string.
+ */
+#include <vector>
+#include <string>
+#include <algorithm>
+
+class Solution {
+public:
+    int characterReplacement(std::string s, int k) {
+        std::vector<int> count(26, 0); // Initialize an array to count the occurrences of characters (26 letters in the English alphabet)
+        int startWindow = 0;            // The left end of the sliding window
+        int maxCount = 0;               // The maximum count of any character within the window
+        int max = 0;                    // The maximum length of a substring that can be formed
+
+        // Iterate through the string using a sliding window approach
+        for (int endWindow = 0; endWindow < s.length(); endWindow++) {
+            int val = s[endWindow] - 'A'; // Convert the character to an index (0-25)
+            count[val]++;                 // Increment the count for the current character
+            maxCount = std::max(maxCount, count[val]); // Update the maximum character count
+
+            // While the length of the current window minus the maximum character count exceeds 'k', shrink the window
+            while (endWindow - startWindow + 1 - maxCount > k) {
+                val = s[startWindow] - 'A'; // Get the character at the start of the window
+                count[val]--;               // Decrement the count for the character at the start of the window
+                startWindow++;             // Move the start of the window to the right
+            }
+
+            // Update the maximum length of a substring that can be formed
+            max = std::max(max, endWindow - startWindow + 1);
+        }
+
+        // Return the maximum length, which represents the longest substring with at most 'k' replacements
+        return max;
+    }
+};