424. Longest Repeating Character Replacement

Problem statement:

Given a string that consists of only uppercase English letters, you can replace any letter in the string with another letter at most k times. Find the length of a longest substring containing all repeating letters you can get after performing the above operations.

Note:
Both the string's length and k will not exceed 104.

Example 1:

Input:
s = "ABAB", k = 2

Output:
4

Explanation:
Replace the two 'A's with two 'B's or vice versa.

Example 2:

Input:
s = "AABABBA", k = 1

Output:
4

Explanation:
Replace the one 'A' in the middle with 'B' and form "AABBBBA".
The substring "BBBB" has the longest repeating letters, which is 4.

Solution:

Like 594. Longest Harmonious Subsequence, it is another typical problem of sliding window, two pointers: start and end, indicate a span in the string which qualify the descriptions.

In this problem, normally we will use a array whose size is 26, representing the appearances of each letters. The appearances of each letter will increase or decrease with the changing of sliding window.

I use a variable max_cnt to record the max appearances of a letter so far. There is an argument in leetcode discussion, some people believe that we should update the max_cnt after moving the start pointer forward.

It depends on what you want the max_cnt to represent.

• If it represents the max appearances in the sliding window, it should change. 
• If it represents the max appearances by the ending pointers regardless the size of sliding window, it should not change.

In this problem, both solutions can pass OJ. The second get better efficiency, but I prefer to do not change. Since If we want to find a better solution, the max appearances should be greater, otherwise, just current one is optimal.

Time complexity is O(n).

This is the version of changing the max_cnt. It reports 29 ms in leetcode OJ system.

class Solution {
public:
    int characterReplacement(string s, int k) {
        // count the frequency of each letter
        int count[26] = {};
        int max_cnt = 0, max_len = 0;
        for (int start = 0, end = 0; end < s.size(); end++) {
            max_cnt = max(max_cnt, ++count[s[end] - 'A']);
            while (end - start + 1 - max_cnt > k) {
                count[s[start] - 'A']--;
                start++;
            }
            for(int i = 0 ; i < 26; i++){
                max_cnt = max(max_cnt, count[i]);
            }
            max_len = max(max_len, end - start + 1);
        }
        return max_len;        
    }
};

This is the version of no changing. It reports the 9 ms in leetcode OJ system.

class Solution {
public:
    int characterReplacement(string s, int k) {
        int count[26] = {};
        int max_cnt = 0, max_len = 0;
        for (int start = 0, end = 0; end < s.size(); end++) {
            max_cnt = max(max_cnt, ++count[s[end] - 'A']);
            while (end - start + 1 - max_cnt > k) {
                count[s[start] - 'A']--;
                start++;
            }
            max_len = max(max_len, end - start + 1);
        }
        return max_len;        
    }
};