HDU 5536（01字典树）

John is a manager of a CPU chip factory, the factory produces lots of chips everyday. To manage large amounts of products, every processor has a serial number. More specifically, the factory produces nn chips today, the ii-th chip produced this day has a serial number sisi.

At the end of the day, he packages all the chips produced this day, and send it to wholesalers. More specially, he writes a checksum number on the package, this checksum is defined as below:
maxi,j,k(si+sj)⊕sk
maxi,j,k(si+sj)⊕sk

which i,j,ki,j,k are three different integers between 11 and nn. And ⊕⊕ is symbol of bitwise XOR.

Can you help John calculate the checksum number of today?
Input
The first line of input contains an integer TT indicating the total number of test cases.

The first line of each test case is an integer nn, indicating the number of chips produced today. The next line has nn integers s1,s2,..,sns1,s2,..,sn, separated with single space, indicating serial number of each chip.

1≤T≤10001≤T≤1000
3≤n≤10003≤n≤1000
0≤si≤1090≤si≤109
There are at most 1010 testcases with n>100n>100
Output
For each test case, please output an integer indicating the checksum number in a line.
Sample Input
2
3
1 2 3
3
100 200 300
Sample Output
6
400

题意：求异或的最大值即maxi,j,k(si+sj)⊕sk

做法：先把整个序列建成一棵字典树，再枚举两个数的和，注意要删除这两个节点，再查询，删除操作为把这条路上的节点记录的子树节点数都减去一就可以了。然后查询完再添加上这两个节点就可以了。
关于怎么查询：把要查询的数字a取反，转换为二进制，再查询字典树里有没有对应位置的节点，有就把这个位置设为1，没有或者子树节点数为0就设置为0，并走该节点的另一个节点
注意我们这里是由高位向低位开始建树的

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
int num[1010];
int dig[40];
void get_dig(int a)
{
    for(int i=0;i<32;i++)
    {
        dig[31-i]=a&1;
        a>>=1;
    }
}
struct node
{
    node *next[3];
    int v=0;
    node()
    {
        v=1;
        next[0]=NULL;
        next[1]=NULL;
    }
};
node* root=new node;
node* cur;
node* x;
void add(int *a)
{
    cur=root;
    for(int i=0;i<32;i++)
    {
        int m=a[i];
        if(cur->next[m]==NULL)
        {
            x=new node;
            cur->next[m]=x;
            cur=cur->next[m];
        }
        else
        {
            cur=cur->next[m];
            cur->v++;
        }
    }
}

unsigned int query(int * a)
{
    cur=root;
    int ans[40];
    for(int i=0;i<32;i++)
    {
        int m=a[i];
        if(cur->next[m]==NULL||cur->next[m]->v==0)
        {
            ans[31-i]=0;
            cur=cur->next[m^1];

        }
        else
        {
            ans[31-i]=1;
            cur=cur->next[m];
        }
    }
    unsigned int t=0;
    for(int i=0;i<32;i++)
    {
        t+=(ans[i]<<i);
    }
    return t;
}
void delete_node(int* a)
{
    cur=root;
    for(int i=0;i<32;i++)
    {
        int m=a[i];
        cur=cur->next[m];
        cur->v--;
    }
}
int main()
{
    int t;
    int m,n;
    int a;

    scanf("%d",&t);
    while(t--)
    {
        root=new node;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a);
            num[i]=a;
            get_dig(a);
            add(dig);
        }
        int ans=0;
        for(int i=0;i<n;i++)
        {
            for(int k=i+1;k<n;k++)
            {
                get_dig(num[i]);
                delete_node(dig);
                get_dig(num[k]);
                delete_node(dig);
                a=num[i]+num[k];
                a=~a;
                get_dig(a);
                int tmp=query(dig);
                get_dig(num[i]);
                add(dig);
                get_dig(num[k]);
                add(dig);
                ans=max(ans,tmp);
            }

        }
        printf("%d\n",ans);
    }
    return 0;
}