Xor-MST Codeforces - 888G

https://codeforces.com/contest/888/problem/G

这题可以用Boruvka算法：

一开始每个点是一个连通块。每次迭代对于每个连通块找到其最近邻居（与其有边相连且与其间最短边最短的连通块），然后将每个连通块和其最近邻居合并（选择的边自然是两连通块间最短边）。直到只剩一个连通块。考虑每一次迭代，连通块个数至少减半，因此只会进行O(log n)次迭代。边权有相等时可能需要一些特判

摘自wikipedia：

Cut property

For any cut C of the graph, if the weight of an edge e in the cut-set of C is strictly smaller than the weights of all other edges of the cut-set of C, then this edge belongs to all MSTs of the graph.

Proof: Assume that there is an MST T that does not contain e. Adding e to T will produce a cycle, that crosses the cut once at e and crosses back at another edge e' . Deleting e' we get a spanning tree T∖{e'}∪{e} of strictly smaller weight than T. This contradicts the assumption that T was a MST.

By a similar argument, if more than one edge is of minimum weight across a cut, then each such edge is contained in some minimum spanning tree.

This figure shows the cut property of MSTs. T is the only MST of the given graph. If S = {A,B,D,E}, thus V-S = {C,F}, then there are 3 possibilities of the edge across the cut(S,V-S), they are edges BC, EC, EF of the original graph. Then, e is one of the minimum-weight-edge for the cut, therefore S ∪ {e} is part of the MST T.

对于此题，只要把这个算法的每一次迭代用01trie优化即可（不展开写了）；对于边权相等，用并查集维护连通性，在已经连通时不合并即可

然而此题卡常（理论复杂度O(200000*log2(200000)*30啊，怎么只开2s）。。。按官方题解里面一模一样的算法A不掉。。

对于此题某一版本的代码（默认随机种子跑200000）：结构体+数组(5500ms) 快于 直接数组(5800ms)  快于  结构体+指针(7000ms)；不知道原因

卡常：

1.(d?(1<<i):0),(d<<i),d*(1<<i)中，最后一个最快？

2.结构体里面删掉一些东西会快？

卡了几个小时卡过去了。。。

 #pragma GCC optimize("Ofast")
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<cassert>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 struct pii
 {
     int fi,se;
     pii():fi(),se(){}
     pii(int a,int b):fi(a),se(b){}
 };
 struct P
 {
     int a,b,c;
 };
 namespace S
 {

 const int N=;
 struct N
 {
     int ch[],fi,se;//,sz
 }dd[N];
 int mem;
 int rt;
 int gnode()
 {
     int t=++mem;dd[t].ch[]=dd[t].ch[]=;//dd[t].sz=0;
     dd[t].fi=dd[t].se=;
     return t;
 }
 const int dep=;
 #define num rt
 void insert(int x,int y)
 {
     //if(!num)    num=gnode();
     //++dd[num].sz;
     int d;int i,p=num;
     /*
     if(!(dd[p].fi==y||dd[p].se==y))
     {
         if(!dd[p].fi)    dd[p].fi=y;
         else if(!dd[p].se)    dd[p].se=y;
     }
     */
     for(i=dep;i>=;--i)
     {
         d=(x>>i)&;
         if(!dd[p].ch[d])   dd[p].ch[d]=gnode();
         p=dd[p].ch[d];//++dd[p].sz;
         if(!(dd[p].fi==y||dd[p].se==y))
         {
             (dd[p].fi?dd[p].se:dd[p].fi)=y;
             /*
             if(!dd[p].fi)    dd[p].fi=y;
             else if(!dd[p].se)    dd[p].se=y;
             */
         }
     }
 }
 /*
 void erase(int x)
 {
     --dd[num].sz;
     bool d;int i,p=num;
     for(i=dep;i>=0;--i)
     {
         d=x&(1<<i);
         p=dd[p].ch[d];
         assert(p);
         --dd[p].sz;
     }
 }
 */
 //inline bool jud(int p,int y)
 //{
 //    return
 #define jud(p,y)    (!dd[p].fi||(dd[p].fi==y&&!dd[p].se))
 //}
 pii que(int x,int y)
 {
     int p=num;
     int d,d2;int i,an=;
     for(i=dep;i>=;--i)
     {
         d=(x>>i)&;
         //d=(x&(1<<i));
         d2=jud(dd[p].ch[d],y);
         p=dd[p].ch[d^d2];
         (an|=(d2*(<<i)));
     }
     if(dd[p].fi!=y)    return pii(an,dd[p].fi);
     else    return pii(an,dd[p].se);
 }
 #undef num

 }
 int n,a[],fa[];
 //vector<int> d[200010];
 P tmp[];int tlen;
 ll ans;
 int n1;
 int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
 inline void merge(int x,int y,int z)
 {
     //printf("1t%d %d %d\n",x,y,z);
     x=find(x);y=find(y);
     //scanf("%d",new int);
     if(x==y)    return;
     fa[x]=y;ans+=z;--n1;
 }
 struct E
 {
     int to,nxt;
 }e[];
 int f1[],ne;
 int main()
 {
     int i,k,fx;pii an,t;
     //n=200000;
     scanf("%d",&n);
     for(i=;i<=n;++i)
     {
         //a[i]=rand()%(1<<30);
         scanf("%d",&a[i]);
     }
     for(i=;i<=n;++i)
         fa[i]=i;
     n1=n;
     //for(int ttt=1;ttt<=15;++ttt)//
     while(n1>)
     {
         //printf("1t%d\n",n1);
         S::mem=;S::rt=S::gnode();
         tlen=;
         memset(f1+,,sizeof(f1[])*n);
         ne=;
         for(i=;i<=n;++i)
         {
             fx=find(i);
             S::insert(a[i],fx);
             e[++ne].to=i;e[ne].nxt=f1[fx];f1[fx]=ne;
             //d[find(i)].pb(i);
         }
         for(i=;i<=n;++i)
             if(find(i)==i)
             {
                 //for(k=f1[i];k;k=e[k].nxt)
                 //    S::erase(a[e[k].to]);
                 an=pii(0x3f3f3f3f,0x3f3f3f3f);
                 for(k=f1[i];k;k=e[k].nxt)
                 {
                     t=S::que(a[e[k].to],i);
                     if(t.fi<an.fi)    an=t;
                 }
                 //printf("at%d %d %d\n",i,an.fi,an.se);
                 tmp[++tlen].a=i;tmp[tlen].b=an.se;tmp[tlen].c=an.fi;
                 //merge(i,an.se,an.fi);
                 //for(k=f1[i];k;k=e[k].nxt)
                 //    S::insert(a[e[k].to],i);
             }
         for(i=;i<=tlen;++i)
             merge(tmp[i].a,tmp[i].b,tmp[i].c);
         //puts("end");
     }
     printf("%lld",ans);
     return ;
 }

另外，官方题解下面有评论讲了一种其他做法，常数更小的