bzoj 2115 路径xor和最大值

首先我们可以将这张图转化为一棵树，其中可能有好多环，肯定是从1走到N，其中可能经过好多环，

因为我们不走N在的一支，最后还是会走回来，因为a xor b xor b=a，所以相当于没走，就是走了个环，

那么我们这个题可以转化成有若干个环的值，还有1-n的值，在环中全任意个，xor起来再xor 1-n的，

使最后最大。

求环的时候我们可以记下每个点的一个值，代表从1到这个点的路径值xor，用size表示（我英语不好。。。）

那么我们做一遍dfs，如果X访问到已经走过的点P了，那么就出现了环，环中的值就是SIZE[p] xor size[x] xor len[q]

这样我们就得到了环的值。

这里的环不一定是所有的环，可能有些环得不到，但是通过已知的值可以xor出来

那么问题就被成功的转化了，这时我们需要了解一些性质

假设集合A，其中我们将ai替换成ai xor a[j] i<>j，那么得到的新集合，这个集合中元素能xor出的值于集合A相同

那么我们就用类似于高斯消元的方法，将每个数（环的值）弄成二进制来看（只是来看），从高位找起，如果所有二进制

最高位是i，那么找到一个最高位是I的元素，用a[i] xor a[j] 替换所有最高位是I的元素j，那么这个集合可以看成是不变的

（能得出的值不变），并且将I元素移出A集合，直到集合中没有数为止

那么我们可以得到一些移出集合的值（也叫做第I位的基），我们从最高位开始贪心，设1-n的xor是ans,那么我们看ans的I位

是不是1，如果不是那么就xor上第I位的基，最后输出ans就行了

/**************************************************************

    Problem: 2115

    User: BLADEVIL

    Language: Pascal

    Result: Accepted

    Time:1520 ms

    Memory:8256 kb

****************************************************************/

 

//By BLADEVIL

var

    n, m                            :int64; 

    pre, other                      :array[0..200010] of int64; 

    len                             :array[0..200010] of int64; 

    last                            :array[0..50010] of int64; 

    l                               :int64; 

    a                               :array[0..200010] of int64; 

    flag                            :array[0..200010] of boolean; 

    size                            :array[0..50010] of int64; 

    tot                             :int64; 

    ans                             :int64;

     

procedure swap(var a,b:int64);

var

    c                               :int64;

begin

    c:=a; a:=b; b:=c;

end;    

 

procedure connect(x,y:int64;z:int64); 

begin

    inc(l); 

    pre[l]:=last[x]; 

    last[x]:=l; 

    other[l]:=y; 

    len[l]:=z; 

end; 

 

procedure dfs(x:int64); 

var

    q, p                            :int64; 

begin 

    flag[x]:=true;

    q:=last[x]; 

    while q<>0 do

    begin

        p:=other[q]; 

        if not flag[p] then

        begin

            size[p]:=size[x] xor len[q]; 

            dfs(p); 

        end else

        begin

            inc(tot); 

            a[tot]:=size[x] xor len[q] xor size[p]; 

            if a[tot]=0 then dec(tot); 

        end; 

        q:=pre[q]; 

    end; 

end; 

 

procedure init; 

var

    i                               :longint; 

    x, y                            :int64; 

    z                               :int64;

begin

    read(n,m); 

    for i:=1 to m do

    begin

        read(x,y,z); 

        connect(x,y,z); 

        connect(y,x,z); 

    end; 

    dfs(1); 

end; 

    

procedure qs(low,high:int64);

var

    i, j                            :longint;

    xx                              :int64;

begin

    i:=low; j:=high; xx:=a[(i+j) div 2];

    while i<j do

    begin

        while a[i]>xx do inc(i);

        while a[j]<xx do dec(j);

        if i<=j then

        begin

            swap(a[i],a[j]);

            inc(i); dec(j);

        end;

    end;

    if i<high then qs(i,high);

    if j>low then qs(low,j);

end;

    

procedure main;

var

    i, j, k                         :longint;

    cur                             :int64;

     

begin

    fillchar(flag,sizeof(flag),false);

    cur:=1<<62;

    for i:=0 to 62 do

    begin

        for j:=1 to tot do

        if not flag[j] then

            if a[j] and cur=cur then

            begin

                flag[j]:=true;

                for k:=1 to tot do

                    if (not flag[k]) and (a[k] and cur=cur) then

                        a[k]:=a[k] xor a[j];

                break;

            end;

        cur:=cur>>1;

    end;

    qs(1,tot);

    ans:=size[n];

    for i:=1 to tot do

    begin

        if a[i]=0 then break;

        if ans xor a[i]>ans then ans:=ans xor a[i];

    end;

    writeln(ans);

end;

    

begin

    init; 

    main;

end.