Xor-MST Codeforces

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(0),se(0){}
    pii(int a,int b):fi(a),se(b){}
};
struct P
{
    int a,b,c;
};
namespace S
{

const int N=7000000;
struct N
{
    int ch[2],fi,se;//,sz
}dd[N];
int mem;
int rt;
int gnode()
{
    int t=++mem;dd[t].ch[0]=dd[t].ch[1]=0;//dd[t].sz=0;
    dd[t].fi=dd[t].se=0;
    return t;
}
const int dep=30;
#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>=0;--i)
    {
        d=(x>>i)&1;
        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=0;
    for(i=dep;i>=0;--i)
    {
        d=(x>>i)&1;
        //d=(x&(1<<i));
        d2=jud(dd[p].ch[d],y);
        p=dd[p].ch[d^d2];
        (an|=(d2*(1<<i)));
    }
    if(dd[p].fi!=y)    return pii(an,dd[p].fi);
    else    return pii(an,dd[p].se);
}
#undef num

}
int n,a[200010],fa[200010];
//vector<int> d[200010];
P tmp[200010];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
",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[200010];
int f1[200010],ne;
int main()
{
    int i,k,fx;pii an,t;
    //n=200000;
    scanf("%d",&n);
    for(i=1;i<=n;++i)
    {
        //a[i]=rand()%(1<<30);
        scanf("%d",&a[i]);
    }
    for(i=1;i<=n;++i)
        fa[i]=i;
    n1=n;
    //for(int ttt=1;ttt<=15;++ttt)//
    while(n1>1)
    {
        //printf("1t%d
",n1);
        S::mem=0;S::rt=S::gnode();
        tlen=0;
        memset(f1+1,0,sizeof(f1[0])*n);
        ne=0;
        for(i=1;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=1;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
",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=1;i<=tlen;++i)
            merge(tmp[i].a,tmp[i].b,tmp[i].c);
        //puts("end");
    }
    printf("%lld",ans);
    return 0;
}

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