[JZOJ6023]【GDOI2019模拟2019.2.16】烤仓鼠【贪心】【Trie】

Description

Solution

考虑如何求出那个最小值

显然我们可以求出全部数中二进制最高的不同位，答案的那一位肯定是1，那一位相同的数相邻可以随便放。
这样可以将全部数分成0的集合和1的集合，把一个集合中的数扔进Trie，再用另外一个集合的数去跑，就可以求出答案了。

接下来我们考虑贪心构造方案
此时我们相当于有两个完全图，然后这两个完全图之间有一些边，我们要找一条字典序最小的哈密尔顿路径

假设我们当前已经抵达了点u，寻找下一个点v
我们有两种选择：

• 如果u与另一个集合还有边，可以跳到另一个集合
• 可以在本集合选一个能走的编号尽量小的边。

考虑一个点怎样才能走

如果是跳到另一个集合，如果本集合还有点，跳过去又跳不回来了，那是不能走的。
如果是在本集合走，走到那个点和另一个集合有边，但是只剩那个点有边了，本集合还有另外的点，这样就导致有些点无法走到。

总结一番，我们可以得到判定能否走的三个命题，只要满足一个就可以走。

• v所在的集合只剩这一个点
• v所在的集合的另一个集合为空
• 删去v与另一个集合的所有边，这两个集合仍然连通。

这样我们用一些set,优先队列之类的东西就可以维护了。

复杂度$O(n\log n)$

Code

#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;++i)
#define fod(i,a,b) for(int i=a;i>=b;--i)
#define N 300005
using namespace std;
int t[N*32][2],n1,n,a[N],d[N],cf[32],l,pt[N],da[N],dw[N],ans[N],ct[2],cnt[N*32][2],m1,pv[32*N];
priority_queue<int,vector<int>,greater<int> > hv[2][N];
set<int> h[2];
typedef set<int>::iterator IT;
bool bz[N],bp[N*32],bs[N];
bool cmp(int x,int y)
{
	return a[x]<a[y];
}
int from(int k)
{
	return (a[k]&cf[l])>0;
}
void put(int k,int c,int w)
{
	fod(i,l-1,0)
	{
		int p=(c&cf[i])>0;
		if(!t[k][p]) t[k][p]=++n1;
		k=t[k][p];
	}
	if(!pv[k]) pv[k]=++pv[0];
	hv[0][pv[k]].push(w);
	pt[w]=k;
}
int query(int k,int c,int w)
{
	int s=0;
	fod(i,l-1,0)
	{
		int p=(c&cf[i])>0;
		if(!t[k][p]) s^=cf[i],k=t[k][p^1];
		else k=t[k][p];
	}
	pt[w]=k;
	if(!pv[k]) pv[k]=++pv[0];
	return s;
}
bool pd(int k)
{
	int tp=from(k);
	return (ct[tp]==1||ct[1-tp]==0||m1>1||(m1==1&&!(bz[k]&&cnt[pt[k]][1-tp]>0&&cnt[pt[k]][tp]==1)));
}
int main()
{
	cin>>n;
	fo(i,1,n) scanf("%d",&a[i]),d[i]=i;
	sort(d+1,d+n+1,cmp);
	int mx=0,mw=0;
	fo(i,2,n) 
		if((a[d[i]]^a[d[i-1]])>=mx) mx=a[d[i]]^a[d[i-1]],mw=i;
	cf[0]=1;fo(i,1,30) cf[i]=cf[i-1]<<1;
	l=30;
	while(l>0&&!(mx&cf[l])) l--;
	n1=1;
	mx=2e9;
	fo(i,1,n) 
	{
		dw[d[i]]=i;
		if(!(a[d[i]]&cf[l])) put(1,a[d[i]],d[i]),ct[0]++,h[0].insert(d[i]);
		else 
		{
			ct[1]++,h[1].insert(d[i]);
			int v=query(1,a[d[i]],d[i]);
			if(v<mx) da[0]=1,da[1]=d[i],mx=v;
			else if(mx==v) da[++da[0]]=d[i];  
		}
	}
	mx^=cf[l];
	if(mx==0) 
	{
		fo(i,1,n) printf("%d ",i);
		return 0;
	}
	fo(i,1,da[0])
	{
		hv[1][pv[pt[da[i]]]].push(da[i]);
		cnt[pt[da[i]]][1]++;
		if(!bp[pt[da[i]]])
		{
			bp[pt[da[i]]]=1;
			cnt[pt[da[i]]][0]=hv[0][pv[pt[da[i]]]].size();
			if(cnt[pt[da[i]]][0]>0) m1++;
		}
		if(cnt[pt[da[i]]][0]>0) bz[da[i]]=1;
	}

	fo(i,1,n) if(dw[i]<mw&&bp[pt[i]]&&min(cnt[pt[i]][0],cnt[pt[i]][1])>0) bz[i]=1;

	int x=n+1,y=n+1,z=n+1;
	if(ct[0]>0) 
	{
		x=*h[0].begin();
		if(!pd(x)) x=*h[0].upper_bound(x);
	}
	if(ct[1]>0)
	{
		y=*h[1].begin();
		if(!pd(y)) y=*h[1].upper_bound(y);
	}
	ans[1]=min(x,y);
	if(bz[ans[1]]) cnt[pt[ans[1]]][from(ans[1])]--;
	fo(i,1,n-1)
	{
		int k=ans[i],tp=from(k),w=n+1;
		bs[k]=1;
		ct[tp]--;
		h[tp].erase(k);
		if(ct[tp]>0) 
		{
			w=*h[tp].begin();
			if(!pd(w)) w=*h[tp].upper_bound(w);
		}
		if(bz[k]&&cnt[pt[k]][1-tp])
		{
			while(bs[hv[1-tp][pv[pt[k]]].top()]) hv[1-tp][pv[pt[k]]].pop();
			int q=hv[1-tp][pv[pt[k]]].top();
			if(pd(q)) w=min(w,q);
		}
		if(bz[k]&&cnt[pt[k]][tp]==0&&cnt[pt[k]][1-tp]>0) m1--; 
		if(bz[w]) cnt[pt[w]][from(w)]--;
		ans[i+1]=w;
	}
	fo(i,1,n) printf("%d ",ans[i]);
}