UESTC 491 Tricks in Bits

Tricks in Bits

Time Limit: 1000MS

Memory Limit: 65535KB

64bit IO Format: %lld & %llu

Submit Status

Description

Given N unsigned 64-bit
integers, you can

bitwise NOT

each or not. Then you need to add operations selected from

bitwise XOR

,

bitwise OR

and

bitwise AND

, between any two successive integers and calculate the result. Your job is to
make the result as small as possible.

Input

The first line of the input is T (no
more than 1000),
which stands for the number of test cases you need to solve.

Then T blocks
follow. The first line of each block contains a single number N (1≤N≤100)
indicating the number of unsigned 64-bit
integers. Then n integers
follow in the next line.

Output

For every test case, you should output

Case #k:

first, where k indicates
the case number and counts from 1.
Then output the answer.

Sample Input

2

3

1 2 3

2

3 6

Sample Output

Case #1: 0

Case #2: 1

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>

using namespace std;
typedef unsigned long long int LL;
int n;
LL ans;
LL MAX;
LL a[105];
LL min(LL a,LL b){return (a<b?a:b);}
void dfs(LL num,int cnt)
{
if(ans==0)
return;
if(num==0)
{
ans=0;
return;
}
if(cnt==n+1)
{
ans=min(ans,num);
return;
}
dfs(num|(~a[cnt]),cnt+1);
dfs(num&(~a[cnt]),cnt+1);
dfs(num^(~a[cnt]),cnt+1);
dfs(num|a[cnt],cnt+1);
dfs(num&a[cnt],cnt+1);
dfs(num^a[cnt],cnt+1);
}
int main()
{
int t;
scanf("%d",&t);
int cas=0;
while(t--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%llu",&a[i]);
MAX=1;
MAX<<=63;
ans=MAX;
dfs(a[1],2);
dfs(~a[1],2);
printf("Case #%d: %llu\n",++cas,ans);
}
return 0;
}