暴力遍历：看起来像是回溯,实际上就是递归
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++就找挨踢零声，加入挨踢零声，面试不挨踢！
