暴力遍历：看起来像是回溯,实际上就是递归

class Solution {
private:
    long long _res = 0;
public:
    long long countAlternatingSubarrays(vector<int>& nums) {
        
        backtrack(nums, 0);
        return _res;
    }
    void backtrack(vector<int>& nums, long long start)
    {
        if(start>nums.size())
            return ;
        for(long long i=start; i<nums.size(); ++i)
        {
            // 单个元素必然是交替子数组
            if(i==start)
            {
                ++_res;
            }else if(nums[i]!=nums[i-1]){
                ++_res;
            }else{
                break;
            }
        }
        backtrack(nums, ++start);
    }
};

这种方法其实也是可以做的但是会超时哈哈哈。

注意题目给的条件，元素值只有0和1。把握这个点其实就非常好解题了。

假设现在有一个队列0101.....1，队列以元素1结尾说明那么当我们新加入一个元素队列元素总和变了，说明是元素值是1，鉴定重复，元素总和没变说明是0，就是不重复的。队列元素以0结尾情况就恰好相反了。

遍历数组，记录上一个数的数值和当前最长交替子数组的长度。如果当前数和之前的数不一样，则交替子数组的长度加一，否则交替子数组长度为一。
当前最长交替子数组的长度，即是以当前元素为结尾的交替子数组的个数，累加到答案当中。

class Solution {
public:
    long long countAlternatingSubarrays(vector<int>& nums) {
        long long res = 0, cur = 0;
        int pre = -1;
        for (int a : nums) {
            cur = (pre != a) ? cur + 1 : 1;
            pre = a;
            res += cur;
        }
        return res;
    }
};

=========================================================================

上面是神智不清随便copy的官方题解，下面来说一下这个题目的本质规律。

举个实际的例子，[0, 1, 0, 1, 0]。

设总个数count=0，左边界left从0开始， 右边界right从0开始，那么则有：

left=0， right=0； [0], 满足条件， count+=1, count = 1

left=0， right=1； [0,1], 满足条件， count+=2, count = 3

left=0， right=2； [0,1, 0], 满足条件， count+=3, count = 6

left=0， right=3； [0,1, 0, 1], 满足条件， count+=4, count = 10

left=0， right=4； [0,1, 0, 1, 0], 满足条件， count+=5, count = 10

发现规律了没？ count+=(left-right+1)。把握这个规律就可以进行高效的遍历，发现当前位置的元素不符合要求，直接把左边界left挪到当前位置再进行遍历即可。

看到这里如果只追求AC就可以结束了。

再深入的想一下，上述规律为什么是这样子的呢？能不能用数学语言描述一下呢？当然是可以的，聪明的GPT已经给出了答案。

这个题目的本质是在考察，一个长度为n的序列，不重复的子序列有多少？为了节省大家的时间直接截图！

GPT3.5做的，感觉比官方题解好点。

#include <vector>
using namespace std;

class Solution {
public:
    long long countAlternatingSubarrays(vector<int>& nums) {
        long long count = 0;
        int left = 0;
        
        for (int right = 0; right < nums.size(); ++right) {
            if (right > 0 && nums[right] == nums[right - 1]) {
                left = right; // 出现相邻相同元素，更新左边界
            }
            count += (right - left + 1); // 加上以 right 为结尾的所有交替子数组数量
        }
        
        return count;
    }
};

这是一条吃饭博客，由挨踢零声赞助。学C/C++就找挨踢零声，加入挨踢零声，面试不挨踢！