牛牛的独特子序列

解法1：前缀和 + 二分

思路：

包含三个字母的子序列问题不好考虑，我们来想一下如果简单化为 $a,b$ 两个字母的情况。也即如何在给定字符串中找到最长的形如 $a^n{b}^n$ 的子序列。

这个问题的 $O(n)$ 复杂度方法是，遍历字符串每一个位置 $index$，以该位置为 $a,b$ 字母的分界线，取该位置以前字母 $a$ 出现的次数，以及该位置以后字母 $b$ 出现的次数（提前维护前缀和，获取出现次数复杂度为 $O(1)$），二者取较小值，即可得到满足题意的、以当前位置为分界线的子序列。

回到三个字母的问题，我们也可以利用类似的思想，遍历字符串每一个位置 $index1$，以该位置为 $a,b$ 字母的分界线，然后遍历其后的每一个位置 $index2$，以该位置为 $b,c$ 字母的分界线，按照上面的方法即可求解。但是由于要遍历两个位置，所以时间复杂度为 $O(n^2)$，对于本题数据会超时。

本题给定的数量级为 $10^6$，我们考虑 $O(nlgn)$ 的算法，如果用上面的思路，遍历 $a,b$ 分界线就需要 $O(n)$ 的复杂度，那么我们考虑用 $O(lgn)$ 的复杂度去找 $b,c$ 的分界线。

划重点，我最喜欢的二分算法就是 $O(lgn)$

每次以左右边界求出的 $mid$ 位置作为 $b,c$ 字符的分界线，然后根据前缀和分别计算出当前的 $a,b,c$ 字母出现的次数（在代码中用 $cura,curb,curc$ 表示），取三者里面的最小值，乘以 $3$ 得到的就是满足题意的子序列。

由于找 $b,c$ 分界线时，该分界线越向右，$b$ 的出现次数越多， $c$ 的出现次数越少；向左时刚好相反。所以二分找分界线时，若当前 $b$ 出现的次数大于 $c$ 出现的次数，那我们将分界线左移（对应着二分右边界左移），若小于则右移。

代码：

class Solution {
public:
    int Maximumlength(string s) {
        int n = s.size();
        vector<int> a(n + 1, 0), b(n + 1, 0), c(n + 1, 0);
        for(int i = 1; i <= n; i++) {
            a[i] = a[i - 1] + (s[i - 1] == 'a');
            b[i] = b[i - 1] + (s[i - 1] == 'b');
            c[i] = c[i - 1] + (s[i - 1] == 'c');
        }
        int ans = 0;
        for(int i = 1; i < n; i++) {
            int res = 0;
            int cura = a[i];
            int l = i + 1, r = n - 1;
            while(l <= r) {
                int mid = l + r >> 1;
                int curb = b[mid] - b[i];
                int curc = c[n] - c[mid];
                res = max(res, min(curb, curc));
                if(curb == curc) {
                    break;
                } else if(curb > curc) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            }
            ans = max(ans, min(res, cura));
        }
        return ans * 3;
    }
};

复杂度分析：

时间复杂度 $O(nlgn)$，遍历 $a,b$ 分界点复杂度 $O(n)$，每次在剩余部分二分找 $b,c$ 分界点复杂度 $O(lgn)$

空间复杂度为$O(n)$，维护了三个前缀和序列

另一个二分的思路：

我们也可以利用二分答案，二分找子序列中 $a$ 出现的次数（与 $b,c$ 出现次数相同），每次遍历字符串，贪心检查是否满足条件，若满足则增大次数继续检查，若不满足则减少次数继续检查，每次更新当前最大值即可。

二分找次数时间复杂度为 $O(lgn)$，每次检查的时间复杂度为 $O(n)$，故总复杂度仍为 $O(nlgn)$

代码如下：

class Solution {
public:
    bool check(int mid, string s) {
        int n = s.size();
        int a = 0, b = 0, c = 0;
        for(int i = 0; i < n; i++) {
            if(a < mid) a += (s[i] == 'a');
            else if(b < mid) b += (s[i] == 'b');
            else c += (s[i] == 'c');
        }
        return c >= mid;
    }
    
    int Maximumlength(string s) {
        int n = s.size();
        int l = 0, r = n, ans = 0;
        while(l <= r) {
            int mid = l + r >> 1;
            if(check(mid, s)) {
                ans = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return ans * 3;
    }
};

解法2：前缀和 + 双指针

思路：

利用两个双指针分别作为 $a,b$ 和 $b,c$ 的分界线，初始时，让左指针左边的 $a$ 出现次数和右指针右边的 $c$ 出现次数相等，假设为 $k$（可以直接初始化为 $n/3$），然后通过前缀和 $O(1)$ 检查双指针中间的 $b$ 出现次数是否大于等于 $k$，若是，则得到了最长满足条件的子序列；若不是，则左指针左移，右指针右移，使得 $a、c$ 出现次数为 $k-1$，继续检查中间的 $b$，以此类推。

双指针法的时间复杂度可以降低到 $O(n)$ ，但是如果字母数量增大到 $4、5...$ 个，二分答案法就可以更加方便的得到结果：设共有 $N$ 个字母，那么先二分搜索各个字母出现的次数 $k$，然后利用 $check()$ 函数检查是否存在满足条件的子序列，再根据检查结果更新搜索区间。时间复杂度为 $O(nlgn)$