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:
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time: ms
    Memory: kb
****************************************************************/
 
//By BLADEVIL
var
    n, m                            :int64;
    pre, other                      :array[..] of int64;
    len                             :array[..] of int64;
    last                            :array[..] of int64;
    l                               :int64;
    a                               :array[..] of int64;
    flag                            :array[..] of boolean;
    size                            :array[..] 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<> 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]= 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:= to m do
    begin
        read(x,y,z);
        connect(x,y,z);
        connect(y,x,z);
    end;
    dfs();
end;
    
procedure qs(low,high:int64);
var
    i, j                            :longint;
    xx                              :int64;
begin
    i:=low; j:=high; xx:=a[(i+j) div ];
    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:=<<;
    for i:= to  do
    begin
        for j:= to tot do
        if not flag[j] then
            if a[j] and cur=cur then
            begin
                flag[j]:=true;
                for k:= 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>>;
    end;
    qs(,tot);
    ans:=size[n];
    for i:= to tot do
    begin
        if a[i]= then break;
        if ans xor a[i]>ans then ans:=ans xor a[i];
    end;
    writeln(ans);
end;
    
begin
    init;
    main;
end.