你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

    你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

    • 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
    • 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
    • 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

    给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

    示例 1：

    1. 输入：fruits = [1,2,1]
    2. 输出：3
    3. 解释：可以采摘全部 3 棵树。

    示例 2：

    输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

    示例 3：

    输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

    示例 4：

    输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

    提示：

    • 1 <= fruits.length <= 105
    • 0 <= fruits[i] < fruits.length
    class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        //数组中存储的是水果的类型，计算的结果是能够收集的树的数量
        //这里的树也一定是连续的，所以也是指针型的滑动窗口问题
        int slowIndex = 0;
        int res = 0;
        int bask = 0;
        int len = 0;
        int a1,a2; //记录篮子里有哪两种水果
        for(int fastIndex = 0;fastIndex < fruits.size();fastIndex++){
            //篮子为空
            if(bask == 0){
                a1 = fruits[slowIndex]; //空篮子就标记第一个水果
                bask++;
                len++;
            }
            //篮子装了一个
            else if(bask == 1){
                if(fruits[fastIndex] == a1){ //是已经装过的
                    len++;
                }
                else{                        //没有装过的
                    a2 = fruits[fastIndex];
                    bask++;
                    len++;
                    slowIndex = fastIndex;   //左指针换到右指针
                }
            }
            //篮子装了俩
            else{
                if(fruits[fastIndex] == a1||fruits[fastIndex] == a2){ //其中之一
                    len++;
                    if(fruits[fastIndex] != fruits[fastIndex - 1]) slowIndex = fastIndex; 
                    //不是两个连续一样的水果则需要更换下一次的指针
                }

                //完成一轮之后的重要更新环节
                else{   //篮子已经装不下了
                    if(len > res) res = len; //更新这个循环的len与结果中的最大值
                    len = fastIndex - slowIndex; //更新下一次的len
                    bask = 1;    //拿掉前面一个水果，进入下一次循环
                    a1 = fruits[slowIndex];  //更新首个水果
                    fastIndex--;    //更新完slowindex之后需要重新从这个fastindex开始计算
                }
            } 
        }
        if(len > res) res = len;
        return res;
   }
};

                   //最后的一个b==2中的else的另一个
                else {
                    if(len>ans) ans=len; //可能更新结果
                    len=r-l+1; //更新长度
                    b1=fruits[l]; 
                    //这里的更新很重要，不能更新为fruits[r]上面有顺序的要求
                    b2 = fruits[r];
                    l=r;
                }