CF888G Xor-MST[最小生成树+01trie]

前注：关于这题，本人的解法暂时没有成功通过此题，原因是被卡常了。可能需要等待某种机缘来请人调试。

---

类似uoj的一道题（新年的繁荣），不过是一个有些简单的版本。

因为是完全图，有没有办法明显优化建边，所以考虑用这个Boruvka算法。MST学习笔记里应当记下来了，可以自行前往。然后在这里，就发现使用Boruvka的话明显就有了可以优化的地方——每个点向外找一条最小的边。这里，因为异或的特殊性，所以可以想到用01trie来查找xor最小值。于是boruvka就与数据结构结合起来了。然后照着流程做即可。

不过注意一个问题：每轮连通块内的点找trie上最小异或值，可能会找到块内的点（甚至自己），所以要避免，这里可以对于每个子树，维护一个min,max，代表子树内叶子代表的点所在的块编号的最大最小值，于是查找的时候就可以提前判断，避免走入不合法的地方。

但是被卡常了。。2s时限，跑了2.6左右。。难受。。等待救援。咕咕。

#pragma comment(linker,"/STACK:102400000,102400000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#define dbg(x) cerr << #x << " = " << x <<endl
#define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=2e5+5,INF=0x3f3f3f3f;
int len,n,thxorz;
int A[N];
int anc[N];
inline int get_anc(int x){return anc[x]==x?x:anc[x]=get_anc(anc[x]);}
struct _01trie{
    int tr[N*30][2],maxv[N*30],minv[N*30],id[N*30],tot;
    _01trie(){maxv[0]=0,minv[0]=INF;}
    inline void Insert(int x,int j){//dbg2(x,j);
        int u=0;
        for(register int i=len,d;~i;--i){
            if(!tr[u][d=(x>>i)&1])tr[u][d]=++tot;
            u=tr[u][d];
        }
        id[u]=j;
    }
    void Maintain(int i){//++thxorz;
        if(!tr[i][0]&&!tr[i][1]){maxv[i]=minv[i]=get_anc(id[i]);return;}
        if(tr[i][0])Maintain(tr[i][0]);
        if(tr[i][1])Maintain(tr[i][1]);
        maxv[i]=_max(maxv[tr[i][0]],maxv[tr[i][1]]);
        minv[i]=_min(minv[tr[i][0]],minv[tr[i][1]]);//dbg2(i,tr[i][0]),dbg2(minv[i],maxv[i]);
    }
    inline void Build(){for(register int i=1;i<=n;++i)Insert(A[i],i);}
    inline int Query(int x,int j){
        int u=0,rt=get_anc(j);//dbg2(rt,x);
        for(register int i=len,d;~i;--i){//++thxorz;
            d=(x>>i)&1;//dbg2(d,tr[u][d]),dbg2(maxv[tr[u][d]],minv[tr[u][d]]);
            if(tr[u][d]&&(maxv[tr[u][d]]^rt||minv[tr[u][d]]^rt))u=tr[u][d];
            else u=tr[u][d^1];
        }//dbg(id[u]);
        return id[u];
    }
}T;
int minw[N],minp[N];
inline void Boruvka(){
    int k=0;ll ans=0;
    T.Build();
    for(register int i=1;i<=n;++i)anc[i]=i;
    while(k<n-1){//dbg("new round");
        T.maxv[0]=0,T.minv[0]=INF,T.Maintain(0);memset(minw,0x7f,sizeof minw);
        for(register int i=1,tmp;i<=n;++i)tmp=T.Query(A[i],i),MIN(minw[get_anc(i)],A[tmp]^A[i])&&(minp[anc[i]]=tmp);
        for(register int i=1;i<=n;++i)if(get_anc(i)^get_anc(minp[get_anc(i)]))
            ans+=minw[anc[i]],++k,anc[anc[i]]=anc[minp[anc[i]]];//attention the order.
    }
    printf("%I64d
",ans);
}

int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
    read(n);for(register int i=1;i<=n;++i)MAX(len,read(A[i]));
    len=__lg(len);
    Boruvka();//dbg(thxorz);
    return 0;
}