CF888G Xor-MST，B算法或者一个更美妙的解法

最新推荐文章于 2023-06-01 23:13:10 发布

原创最新推荐文章于 2023-06-01 23:13:10 发布 · 348 阅读

0 ·

CC 4.0 BY-SA版权

博主尝试编写B算法时遇到超时问题，原算法每次从集合伸最小边，用01Tire找边并合并集合，时间复杂度虽理论正确但仍超时，使用离散化处理也未解决。后提出更优解法，利用01Tire节点特性，时间复杂度低且常数小，还可左右递归进一步优化。

正题

尝试写了一个B算法，T飞了，而且代码调了很久。
就是每次从每个集合里面伸出来一条最小的边，可以用 $01 T i r e$ 去找，然后每次将有连边合并为一个。
最多合并 $log_2 n$ 次，每次时间复杂度 $O(n \log_2 S)$ ，时间复杂度正确？
找那条最小的边很麻烦，还要维护每个点对应的集合，还要支持每次删除，所以我使用了离散化来处理，省去每次重新插入的时间复杂度，不过还是T飞了。附上代码
仔细想想就可以得到一个更美妙的解法，在 $01 T i r e$ 上，如果一个节点有两个非空儿子，那么这两个非空儿子直接只可能有一条边，显然这样的点有 $n - 1$ 个，我们每次将左边的点放到右边找就可以。因为每一个点最多只可能找深度次 $log_2 S$ ，每次时间复杂度为 $log_2 S$ ，但显然常数比上面要小得多，可行。
当然也可以像我一样写一种常数更小的写法，左右两边同时向下递归即可。

#include<bits/stdc++.h>
using namespace std;

const int N=200010,M=15000000;
int a[N],n,b[N];
pair<int,int> c[N];
int son[M][2],op[N][2],T=1,fa[N],tot[M],num[M];
pair<int,int> mmin[N];
vector<int> V[N];

void ins(int x,int a,int b){
	if(a==-1){
		if(op[x][0]==b) op[x][0]=0;
		if(op[x][1]==b) op[x][1]=0;
	}
	else{
		if(op[x][0]==b || op[x][1]==b) return ;
		if(op[x][0]==0) op[x][0]=b;
		else if(op[x][1]==0) op[x][1]=b;
	}
}

void insert(int x,int a,int b){
	int now=1;tot[now]+=a;
	for(int i=29;i>=0;i--){
		int tmp=((x&(1<<i))!=0);
		if(!son[now][tmp]) son[now][tmp]=++T;
		now=son[now][tmp];tot[now]+=a;
	}
	num[now]=b;
}

pair<int,int> gs(int x){
	int now=1,ans=0;
	for(int i=29;i>=0;i--){
		int tmp=((x&(1<<i))!=0);
		if(tot[son[now][tmp]]) now=son[now][tmp];
		else now=son[now][tmp^1],ans+=(1<<i);
	}
	if(op[num[now]][0]) return make_pair(ans,op[num[now]][0]);
	else return make_pair(ans,op[num[now]][1]);
}

int findpa(int x){return fa[x]!=x?fa[x]=findpa(fa[x]):x;}

void solve(){
	long long ans=0;
	while(1){
		for(int i=1;i<=n;i++)
			op[b[i]][0]=op[b[i]][1]=0;
		for(int i=1;i<=n;i++){
			for(int j=0;j<V[i].size();j++)
				ins(b[V[i][j]],1,i);
		}
		for(int i=1;i<=n;i++){
			for(int j=0;j<V[i].size();j++)
				insert(a[V[i][j]],-1,b[V[i][j]]),ins(b[V[i][j]],-1,i);
			mmin[i].first=2e9,mmin[i].second=0;
			for(int j=0;j<V[i].size();j++) mmin[i]=min(mmin[i],gs(a[V[i][j]]));
			for(int j=0;j<V[i].size();j++)
				insert(a[V[i][j]],1,b[V[i][j]]),ins(b[V[i][j]],1,i);
		}
		for(int i=1;i<=n;i++) if(mmin[i].first!=2e9){
			int x=findpa(i),y=findpa(mmin[i].second);
			if(x==y) continue;
			ans+=mmin[i].first;
			if(V[x].size()<V[y].size()){
				fa[x]=y;
				for(int j=0;j<V[x].size();j++)
					V[y].push_back(V[x][j]);
				V[x].resize(0);
			}
			else{
				fa[y]=x;
				for(int j=0;j<V[y].size();j++)
					V[x].push_back(V[y][j]);
				V[y].resize(0);
			}
		}
		bool tf=false;
		for(int i=1;i<=n;i++) if(V[i].size()==n) {tf=true;break;}
		if(tf) break;
	}
	printf("%lld",ans);
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) 
		scanf("%d",&a[i]),V[i].push_back(i),fa[i]=i,c[i].first=a[i],c[i].second=i;
	sort(c+1,c+1+n);c[0].first=-1;
	int t=0;
	for(int i=1;i<=n;i++) if(c[i].first==c[i-1].first) b[c[i].second]=t;
	else b[c[i].second]=++t;
	for(int i=1;i<=n;i++) insert(a[i],1,b[i]);
	solve();
}

#include<bits/stdc++.h>
using namespace std;

const int N=200010;
int son[10000010][2],tot[10000010];
int n,T=1;
long long ans=0;

void insert(int x){
	int now=1;tot[now]++;
	for(int i=29;i>=0;i--){
		int tmp=((x&(1<<i))!=0);
		if(!son[now][tmp]) son[now][tmp]=++T;
		now=son[now][tmp];tot[now]++;
	}
}

int gs(int x,int y,int dep){
	if(dep==-1) return 0;
	int ans=2e9;
	if(son[x][0]){
		if(son[y][0]) ans=min(ans,gs(son[x][0],son[y][0],dep-1));
		else if(son[y][1]) ans=min(ans,gs(son[x][0],son[y][1],dep-1)+(1<<dep));
	}
	if(son[x][1]){
		if(son[y][1]) ans=min(ans,gs(son[x][1],son[y][1],dep-1));
		else if(son[y][0]) ans=min(ans,gs(son[x][1],son[y][0],dep-1)+(1<<dep));
	}
	return ans;
}

void dfs(int x,int dep){
	if(son[x][0] && son[x][1]) ans+=gs(son[x][0],son[x][1],dep-1)+(1<<dep);
	if(son[x][0]) dfs(son[x][0],dep-1);
	if(son[x][1]) dfs(son[x][1],dep-1);
}

int main(){
	scanf("%d",&n);
	int x;
	for(int i=1;i<=n;i++) scanf("%d",&x),insert(x);
	dfs(1,29);
	printf("%lld\n",ans);
}