HDU_5536_Chip Factory

Chip Factory

Time Limit: 18000/9000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 3702    Accepted Submission(s): 1622

Problem Description

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 n chips today, the i-th chip produced this day has a serial number si.

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

which i,j,k are three different integers between 1 and n. 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 T indicating the total number of test cases.

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

1≤T≤1000
3≤n≤1000
0≤si≤109
There are at most 10 testcases with n>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

 

Source

2015ACM/ICPC亚洲区长春站-重现赛（感谢东北师大）

 

• 题中存在XOR运算，往二进制运算考虑
• 好吧，这题时间宽泛，n3复杂度8000ms可以过
• 考虑对于一个正整数的二进制形式的01字串A
• 如果用01字串B和A做XOR运算，考虑最优情况，应该是对应位置Ai!=Bi
• 那么如果我们n2枚举Si+Sj，接下来如果有一个可以反映剩下数的每个位置01状态的数据结构，我们就可以贪心地在每一步挑选最优策略
• 原始的十进制整数下的整数状态是不可能的，但是我们可以以二进制的形式对原始整数做tire就可以达到对剩余整数的一个数据压缩的效果
• 方法出来了，就是做二进制字典树，然后n2枚举和，贪心搜索tire
• 这里对于tire的建立最好是从高位开始建，原因嘛，恩本鶸从低位建树WA了，改成高位建树就AC了

 #include <iostream>
 #include <string>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <climits>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <set>
 #include <map>
 using namespace std;
 typedef long long           LL ;
 typedef unsigned long long ULL ;
 const int    maxn = 1e6 +    ;
 const int    inf  = 0x3f3f3f3f ;
 const int    npos = -         ;
 const int    mod  = 1e9 +     ;
 const int    mxx  =  +     ;
 const double eps  = 1e-       ;
 const double PI   = acos(-1.0) ;

 struct node{
     int cnt;
     int go[];
     LL val;
 };
 node state[maxn<<];
 int tot, root;
 void add(LL w){
     int cur=root;
     state[cur].cnt++;
     for(int i=;i>=;i--){
         int k=(<<i)&w?:;
         if(!state[cur].go[k]){
             tot++;
             state[cur].go[k]=tot;
             memset(&state[tot],,sizeof(state[tot]));
         }
         cur=state[cur].go[k];
         state[cur].cnt++;
     }
     state[cur].val=w;
 }
 void del(LL w){
     int cur=root;
     state[cur].cnt--;
     for(int i=;i>=;i--){
         int k=(<<i)&w?:;
         cur=state[cur].go[k];
         state[cur].cnt--;
     }
 }
 LL search(LL w){
     int cur=root;
     for(int i=;i>=;i--){
         int k=(<<i)&w?:;
         if(state[state[cur].go[k^]].cnt){
             cur=state[cur].go[k^];
         }else{
             cur=state[cur].go[k];
         }
     }
     return w^state[cur].val;
 }
 int T, n;
 LL a[maxn], ans;
 int main(){
     // freopen("in.txt","r",stdin);
     // freopen("out.txt","w",stdout);
     while(~scanf("%d",&T)){
         while(T--){
             root=;
             tot=;
             ans=-1LL;
             memset(&state[],,sizeof(state[]));
             memset(&state[root],,sizeof(state[root]));
             scanf("%d",&n);
             for(int i=;i<=n;i++){
                 scanf("%lld",&a[i]);
                 add(a[i]);
             }
             for(int i=;i<=n;i++)
                 for(int j=i+;j<=n;j++){
                     del(a[i]);
                     del(a[j]);
                     ans=max(ans,search(a[i]+a[j]));
                     add(a[i]);
                     add(a[j]);
                 }
             printf("%lld\n",ans);
         }
     }
     return ;
 }