【LeetCode】No.1234 替换字串得到平衡字符串（C++实现）

1，题目描述：

有一个只含有 'Q', 'W', 'E', 'R' 四种字符，且长度为 n 的字符串。

假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。

 

给你一个这样的字符串 s，请通过「替换一个子串」的方式，使原字符串 s 变成一个「平衡字符串」。

你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

 

示例 1：

输入：s = "QWER"
输出：0
解释：s 已经是平衡的了。

示例 2：

输入：s = "QQWE"
输出：1
解释：我们需要把一个 'Q' 替换成 'R'，这样得到的 "RQWE" (或 "QRWE") 是平衡的。
示例 3：

输入：s = "QQQW"
输出：2
解释：我们可以把前面的 "QQ" 替换成 "ER"。 
示例 4：

输入：s = "QQQQ"
输出：3
解释：我们可以替换后 3 个 'Q'，使 s = "QWER"。
 

提示：

1 <= s.length <= 10^5
s.length 是 4 的倍数
s 中只含有 'Q', 'W', 'E', 'R' 四种字符

2，解题方法：

（1）双指针法

解题思路：

1，一串字符串s，先用一个map或者undered_map或者数组 将字符串中的每一个字符出现的个数记录下来，如下面程序中的第一步操作。

2，计算每个字符分别多出来几个或少了几个，比如“QQWWEWRR”,QWER出现的次数分别为2312，但是n/4=2,也就是说每个字符出现两次才是正常的，我们把那些不正常的数据出现的次数找出来，正如程序中第二部分那样。以“QQWWEWRR”为例：其中，Q正常，W多出现1次，E少出现1次，R正常。如果我们设置一个滑窗从左到右滑过整个字符串，并取滑窗右边的一个新字符A，将其字符个数减一，然后判断这个滑窗里的每个字符出现的字符还正不正常（只要没有大于零的字符便正常），如果正常，则说明这个滑窗的字符串可以替换，替换后的整个字符串是个平衡字符串，但是这个子串不一定是最优的，所以要不停的尝试缩小这个滑窗，直到滑窗不能再小时，此时的子串便是我们要找的子串。

         /*---------1-----------*/
        unordered_map<char,int> cnt;
        bool balance=true;
        for(auto ch : s)
            ++cnt[ch];
        /*--------------------*/
        
        /*---------2-----------*/
        int len = s.size();
        int n = len/4;
        for(auto ch:chars)
        {
            cnt[ch]-=n;
            if(cnt[ch]>0)
                balance = false;
        }
        if(balance==true)
            return 0;

3，采用一个滑窗依次滑过字符串，先设置两个指针left和right，分别都指向字符串的第一个字符的位置。

进入大while循环（对每个字符操作），先将right指向的字符出现的次数减一。进入小while循环，然后判断滑窗内的子串是否满足条件（每个字符出现的字数均不大于零）。如果满足，记下子串长度，然后left++（缩小滑窗）后再进入小while循环判断。如果不满足，退出小while循环，right++（扩大滑窗）进入大while循环并重复上面操作。

4，返回之前记录的最短子串长度。

3，程序与分析

下面是程序，整个方法中最重要的一点是对滑窗的操作，从左往右滑，最开始滑窗长度为1，如果没有合适的子串便向右扩大滑窗（right++），如果有合适的滑窗，再将left--（将滑窗左边界向右缩小）判断是不是最短的合适子串。

class Solution {
public:
    int balancedString(string s)
    {
        vector<char> chars{'Q','W','E','R'};
        unordered_map<char,int> cnt;
        bool balance=true;
        for(auto ch : s)
            ++cnt[ch];
        int len = s.size();
        int n = len/4;
        for(auto ch:chars)
        {
            cnt[ch]-=n;
            if(cnt[ch]>0)
                balance = false;
        }
        if(balance==true)
            return 0;
        int left =0,right =0,num=len;
        while(left<=right&&right<len)
        {
            bool find = true;
            --cnt[s[right]];
            while(find)
            {
                for(auto ch:chars)
                {
                    if(cnt[ch]>0)
                    {
                        find =false;
                        break;
                    }
                }
                if(find ==true)
                {
                    num = min(num,right-left+1);
                    ++cnt[s[left++]];
                }
            }
            ++right;
        }
        return num;
    }
};

下面这种方法是在leetcode上抄的，还没来得及理解，整体比上面的方法好，大家可以研究一下。

class Solution {
public:
    int getAns(vector<int> &arr, int size)
    {
        return (size - arr['Q' - 'A'] - arr['W' - 'A'] - arr['E' - 'A'] - arr['R' - 'A']);
    }
    
    int balancedString(string s) {
        vector<int> arr(26, 0);
        int ans = s.size();
        int j;
        int i = 0;

        for (j = s.size() - 1; j >= 0; j--) {
            arr[s[j] - 'A']++;
            if (arr[s[j] - 'A'] > s.size()/4) {
                arr[s[j] - 'A']--;
                j++;
                break;
            }
        }
        ans = std::min(ans, getAns(arr, s.size()));
        
        for (; j <= s.size() - 1; j++) {
            arr[s[j] - 'A']--;
            for (; i <= j; i++) {
                arr[s[i] - 'A']++;
                if (arr[s[i] - 'A'] > s.size()/4) {
                    arr[s[i] - 'A']--;
                    break;
                }
            }
            ans = std::min(ans, getAns(arr, s.size()));
        }
        
        return ans;
    }
};