Codeforces Round #945 (Div. 2) B.Cat, Fox and the Lonely Array 二分查找

本菜鸡终于把B题搞懂了。。。记录一下思路

题目：

大致意思就是每次给定一个数组，然后你要寻找一个最小的k，使得数组中每一个长度为k的连续子序列的所有数的或运算的结果m都相同。

举例：

设数组为3 0 1 4 2，如果k为4的话，则长度为4的连续子序列有3 0 1 4和0 1 4 2两个，可以算出3|0|1|4 = 0|1|4|2（“|”代表或运算），并且没有更小的k满足题目条件，因此对3 0 1 4 2这一序列来说，能找到的最小的k就是4。

思路：

可以理解为用一个“框”把数组中的子序列框起来，并且这个“框”要向后移动，直到最后一个子序列。不难发现，框每向后移动一位，就会把框中第一个数字p舍弃掉，并在框的最后新加进一个数字q。由于或运算的特殊性质，二进制中，0与任何x的或都为x，1与任何x的或都为1，因此我们可以从“1”的个数入手，框每移动一位判断一次。用一个数组arr记录下第一个长度为k的连续子序列中所有数的二进制中“1”的位置并积累，例如3 0 1 4，二进制分别为011，000，001，100，那么arr中就因该为1 1 2（低三位）。

然后重点来了，这里我们定义一个数字的某一位对arr的组成是“必要的”，代表这个数组贡献了arr中这一位上唯一的“1”，例如011就对112中的第二位贡献了唯一的“1”。然后查看舍弃掉第一个数p之后，也即arr减去p所贡献的所有“1”后，arr中原本非零位的情况。如果原本非零位上还剩余有“1”，那么无所谓，m的值不会发生改变（因为根据或运算的性质，arr的这一位一旦有多个“1”，m的这一位就永远会是“1”）；而如果arr中原本非零位变成零了，那么m的这一位就没有“1”了，它的值就会改变，这时候就必须要求新加入的q的来弥补这一位。假如q能弥补这一位，就说明无伤大雅，下一个长度为k的连续子序列或运算的结果仍然可以为m；假如q不能弥补，那么说明下一个长度为k的连续子序列或运算的结果永远不可能为m，当前长度k就不满足题意。当然，如果arr的某一位本身就为0，也即原本这一位一个“1”都没有被贡献，而q中的这一位为“1”，则说明多余了，结果也不可能为m，那么长度k就可以舍弃掉了。

然后这里有一个理论，就是如果子序列长度为k是满足题目要求的，那么子序列长度为k+1也是满足题目要求的，Codeforces官解上有证明，这里我就偷懒不证了。根据这一理论，我们可以想到用二分来枚举k的长度。

官解：Editorial for Codeforces Round #945 (Div. 2) - Codeforces

测试用例：

输入：

第一行一个t，代表测试数据组数；

每组数据第一行一个n，代表数组长度，接下来n个数字代表数组中的数ai（0≤ai<2^20）。

输出：

每组输出最小的k

Input

7
1
0
3
2 2 2
3
1 0 2
5
3 0 1 4 2
5
2 0 4 0 2
7
0 0 0 0 1 2 4
8
0 1 3 2 2 1 0 3

Output

1
1
3
4
4
7
3

代码：

#include <iostream>
#include <vector>
#define vi vector<int>
#define endl '\n';
using namespace std;
const int MAXN = 1e5 + 6;
int t, n;
int a[MAXN];
bool check(int mid);
int main()
{
	cin >> t;
	while (t--) {
		cin >> n;
		for (int i = 1; i <= n; i++) {
			cin >> a[i];
		}
		int l = 1, r = n, ans = 0;
		while (l <= r) {
			int mid = (l + r) >> 1;
			if (check(mid)) {
				r = mid - 1;
				ans = mid;
			}
			else{
				l = mid + 1; 
			}
		}
		cout << ans << endl;
	}

	return 0;
}
bool check(int mid)
{
	int gtg = 0;
	vi arr(22, 0);       //最多20位
	for (int i = 1; i <= mid; i++) {
		for (int j = 0; j <= 20; j++) {
			if ((a[i] >> j) & 1) {
				arr[j + 1]++;     //记录第一段mid长的所有数字的或的二进制中1的位置并积累起来
			}
		}
	}
	for (int i = 1; i + mid <= n; i++) {
		for (int j = 0; j <= 20; j++) {
			if ((a[i] >> j) & 1) {
				arr[j + 1]--;
				if (arr[j + 1] == 0) {
					arr[j + 1] = -1;     //用-1标记一下，代表a[i]对目前的这一位是必要的
				}
			}
		}
		for (int j = 0; j <= 20; j++) {
			if ((a[i + mid] >> j) & 1) {   //这一位为1的话
				if (arr[j + 1] > 0) {    //如果这一位本身就有多个1，则意味着a[i]对这一位不是必要的
					arr[j + 1]++;       //继续积累即可
				} 
				else if (arr[j + 1] == -1) {
					arr[j + 1] = 1;     //代表新加的数字能顶替舍去数字的必要性，完成交接
				}
				else if (arr[j + 1] == 0) {   //如果原本这一位为0，则代表多余了
					return false;
				}
			}
			else {     //这一位为0的话
				if (arr[j + 1] == -1) {       //代表不能胜任
					return false;
				}
			}
		}
	}

	return true;
}