[Tkey] 与非

合集 - 题解(24)

1.[TK] 矩阵取数游戏<简单版> hzoi-tg-906-22024-02-152.[TK] 一心净士 hzoj-tg-937-22024-02-143.[TK] 盖房子 hzoi-tg#2622024-02-164.[TK] 三角蛋糕 hzoi-tg#2612024-02-165.[TK] 选课 hzoj-tg#2792024-02-166.[TK] 三色二叉树 hzoi-tg#282 存图方法2024-02-167.[TK] HH的项链 离线树状数组解法2024-02-188.[TK] 理想的正方形2024-02-229.[TK] Blocks 单调栈2024-02-2210.[TK] 送礼物2024-02-2311.[TK] Terrible Prime2024-03-0512.[TK] BLO2024-03-1113.[TK] Rudolf and Subway ( CodeForces #933 div.3 - G )2024-03-1814.[TK] Bulls And Cows S2024-04-1315.[TK] 颜色2024-04-22

16.[Tkey] 与非2024-06-23

17.[TK] CF1526B I Hate 11112024-08-0618.[TK] 寻宝游戏2024-08-0919.[CL-22] 异或和之和2024-09-2720.联训题单 / 集训杂题纪要2024-11-1121.[At_dp_w] Intervals & [At_dp_x] Tower2024-11-0822.CF2023D - Many Games2024-11-1023.[NOI2021] 轻重边2024-11-1324.[CSP-S 2024] 染色2024-11-20

收起

解法原理1

首先我们需要明白 $\mathrm{nand}$ 的运算：

$$\begin{array}{}\text{(1)}& \mathrm{not}(a\mathrm{nand}b)=a\mathrm{and}b\end{array}$$

这个很好理解，因为 $\mathrm{nand}$ 就是这么定义的（从中文名字可以看出来）。

$$\begin{array}{}\text{(2)}& (\mathrm{not}a)\mathrm{nand}(\mathrm{not}b)=a\mathrm{or}b\end{array}$$

这个是因为下述式子：

$$\mathrm{not}((\mathrm{not}a)\mathrm{and}(\mathrm{not}b))=a\mathrm{or}b$$

最后：

$$\begin{array}{}\text{(3)}& a\mathrm{xor}b=(a\mathrm{and}(\mathrm{not}b))\mathrm{or}((\mathrm{not}a)\mathrm{and}b)\end{array}$$

因为 $\mathrm{and},\mathrm{or}$ 我们都表示出来了，因此我们还可以用 $\mathrm{nand}$ 来表示 $\mathrm{xor}$。

所以可以发现 $\mathrm{nand}$ 实际上包含了全部我们需要的位运算。

解法原理2

拥有了全部的位运算，那么现在我们是不是就能得到所有数字了呢？显然不是，考虑一下的例子：

10101
00000

可以发现我们无论如何操作，都不能使第 $2$ 位和第 $4$ 位变成不同的数字，这就是我们这道题唯一的限制：假如在每个数 $n$ 中都有数位 $i,j$ 是相同的，那么无论如何选择，在结果中一定有 $i=j$。

回到刚才的例子，可以发现第 $1,3,5$ 位也无法在结果中变成不同的数字，发现其实不一定要全部相等，而是每个数中的各位相等即可，因此归纳出本题的限制条件：

若在全部的 $n$ 个数中都有第 $i$ 位与第 $j$ 位相等，那么在结果中也会如此。

因此，本题首先需要我们求解出具有限制条件的数位，我们可以使用并查集来维护。

代码步骤1

因为本题 $n,k$ 较小，可以考虑暴力枚举进行合并。

我们每次枚举两个位置 $i,j$ 判断这两个位置是否对全部的 $n$ 个数都满足上述条件，如果是，那么我们就合并这两个数。最后合并到一起的几个数就是符合条件，并且范围最大的结果。

请注意此处并查集合并操作的合并顺序，具体用处请见解法原理3的流程第一条。

//主函数部分
for(int i=1;i<=k;++i){
	fa[i]=i;//初始化
}
for(int i=1;i<=k;++i){
	for(int j=i-1;j>0;--j){
        //枚举全部可能的 i,j
		if(check(i,j)) connect(i,j);
	}
}

//并查集板子与 check()
// ---DSU Part---
int fa[61];
int find(int id){
	if(fa[id]==id) return id;
	fa[id]=find(fa[id]);
	return fa[id];
}
void connect(int x,int y){
	if(find(x)!=find(y)){
		fa[fa[y]]=fa[x];
	}
}
// --------------
// Check
bool check(int x,int y){
    //检查 x,y 是否符合条件
	for(int i=1;i<=n;++i){
		if(((a[i]>>x-1)^(a[i]>>y-1))&1)
        //上面这句的意思是：判断 a[i] 的第 x,y 位是否相等 
        return false;
	}
	return true;
}

解法原理3

求出全部“相互独立的数”之后，我们现在需要求解答案了。

首先考虑统计出当前并查集中的集合个数 $a$，这 $a$ 个集合相互独立，互不影响，并且每个集合都可以独立地拼凑出 $1$ 或 $0$（刚才的解法原理1证明了，这样的拼凑总是可能的）。因此方案数应该为 $2^a$。

现在我们来考虑边界问题。我们可以很容易地将边界 $[l,r]$ 转化成求 $[1,r]-[1,l-1]$，这样我们就只需要处理右边界了。下面我们可以把问题转化成一个数位 DP。

假如右边界 $x$ 的第 $i$ 位数为 $0$，说明这一位可能受到了限制（相当于数位 DP 里的 $limit$），例如 x=010010 ，其右数第 $3$ 位为 $0$，这说明在前几位填 010 的时候，这一位实际上只能填 $0$ 了，因为如果填 $1$ 就超出右边界范围了。

同时，因为同一个集合内的元素一定会相等，因此假如集合内任何一个元素受到了限制，那么整个集合都会因此受到限制。基于这个想法，我们不妨来维护一个数组 $limi{t}_i$，来判断 $i$ 是否受到了这样的限制。

我们需要寻找出 $x$ 从右往左第一个不受到限制的集合，并从它的末尾开始统计答案（因为实际上去除最右方的首个受限集合后，剩余的集合就不会再受到限制了，读者不妨自己试举几例）。将限制全部都转移到代表元素上，可以基本总结出下面的流程：

1. 假设每个集合的代表元素都在集合的最左边（这很好实现，你只需要在实现并查集的时候将靠右的元素合并到靠左的位置即可）。
2. 从右至左依次遍历右边界 $x$ 的每一位 $x_i$。
3. 假如 $x_i=1$，并且此时代表元素未受到限制，且该集合尚未访问过，则统计答案。统计后将该集合标记为已访问。
4. 假如 $x_i=0$，将该集合标记为受限，若该集合已经访问过，则退出循环，表示找到了此位置。
5. 假如遇到代表元素受限的元素，说明这个受限的集合已经结束，也退出循环，表示找到了此位置。

现在我们通过此流程找到了第一个不受限制的数位 $p$，并且 $p$ 以前的集合有 $s_p$ 个，那么总方案数就为 $2^{s_p}$。

根据上式可以看出，为了计算这个答案，实际上我们还需维护一个集合数量的前缀数组。

代码步骤2

首先我们考虑到，假如右边界 $x\ge 2^k-1$，那么它一定能够包含全部的 $2^a$ 种情况，这是最简单的。

剩下的步骤即为解法原理3所述。

int ask(int x){
    if(++x>=(1ll<<k)){//特殊情况
		return (1ll<<s[k]);
	}
    int ans=0;
    memset(limit,-1,sizeof(limit));
    //注意清空数组
    for(int i=k;i>0;i--){
        if(x&(1ll<<i-1)){
            if(limit[fa[i]]!=1){
	            ans+=1ll<<s[i-1];
                //统计答案
	        }
            if(fa[i]==i){
				limit[i]=1;
                //标记访问
			}
            if(limit[fa[i]]==0){
                //步骤5
				break;
			}
        }
        else{
            //步骤4
            if(fa[i]==i){
				limit[i]=0;
			}
            if(limit[fa[i]]==1){
				break;
			}
        }
    }
    return ans;
}

//主函数的预处理与统计答案部分
for(int i=1;i<=k;i++){
    s[i]=s[i-1];
    if(find(i)==i){
        //预处理集合数量前缀和
		s[i]++;
	}
}
cout<<ask(r)-ask(l-1);

代码实现

AC Record

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,k,l,r;
int a[1001],s[61],limit[61];
int fa[61];
int find(int id){
	if(fa[id]==id) return id;
	fa[id]=find(fa[id]);
	return fa[id];
}
void connect(int x,int y){
	if(find(x)!=find(y)){
		fa[fa[y]]=fa[x];
	}
}
bool check(int x,int y){
	for(int i=1;i<=n;++i){
		if(((a[i]>>x-1)^(a[i]>>y-1))&1) return false;
	}
	return true;
}
int ask(int x){
    if(++x>=(1ll<<k)){
		return (1ll<<s[k]);
	}
    int ans=0;
    memset(limit,-1,sizeof(limit));
    for(int i=k;i>0;i--){
        if(x&(1ll<<i-1)){
            if(limit[fa[i]]!=1){
	            ans+=1ll<<s[i-1];
	        }
            if(fa[i]==i){
				limit[i]=1;
			}
            if(limit[fa[i]]==0){
				break;
			}
        }
        else{
            if(fa[i]==i){
				limit[i]=0;
			}
            if(limit[fa[i]]==1){
				break;
			}
        }
    }
    return ans;
}
signed main(){
	cin>>n>>k>>l>>r;
	for(int i=1;i<=n;++i){
		cin>>a[i];
	}
	for(int i=1;i<=k;++i){
		fa[i]=i;
	}
	for(int i=1;i<=k;++i){
		for(int j=i-1;j>0;--j){
			if(check(i,j)) connect(i,j);
		}
	}
	for(int i=1;i<=k;i++){
        s[i]=s[i-1];
        if(find(i)==i){
			s[i]++;
		}
    }
    cout<<ask(r)-ask(l-1);
}