hdu 5088（高斯消元）

Revenge of Nim II

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

Nim is a mathematical game of strategy in which two players take turns removing objects from distinct heaps. On each turn, a player must remove at least one object, and may remove any number of objects provided they all come from the same heap.
---Wikipedia

Today, Nim takes revenge on you, again. As you know, the rule of Nim game is rather unfair, only the nim-sum (⊕) of the sizes of the heaps is zero will the first player lose. To ensure the fairness of the game, the second player has a chance to move some (can be zero) heaps before the game starts, but he has to move one heap entirely, i.e. not partially. Of course, he can’t move all heaps out, at least one heap should be left for playing. Will the second player have the chance to win this time?

 

Input

The first line contains a single integer T, indicating the number of test cases.

Each test case begins with an integer N, indicating the number of heaps. Then N integer Ai follows, indicating the number of each heap.

[Technical Specification]
1. 1 <= T <= 100
2. 1 <= N <= 1 000
3. 1 <= Ai <= 1 000 000 000 000

 

Output

For each test case, output “Yes” if the second player can win by moving some (can be zero) heaps out, otherwise “No”.

 

Sample Input

  
  

   
   3
1
2
3
2 2 2
5
1 2 3 4 5
  
  

 

Sample Output

  
  

   
   No
Yes
Yes

   
   

    
    

     
     Hint
    
    
For the third test case, the second player can move heaps with 4 and 5 objects out, so the nim-sum of the sizes of the left heaps is 1⊕2⊕3 = 0.
   
   
   
   


   
   
  
  
  
  

   
   解题思路：这道题目可以看成是在一堆数中，任取k个，是否异或为0，那么这个时候就好利用高斯消元的思想了，把这些数变成二进制数，每一位的0或1就为系数，这样就建立了一个n个方程组的异或方程。利用高斯消元，判断是否存在全为0行向量，即不为满秩矩阵。由于Ai<1000000000000,所以取42bit，建立n*42的矩阵
  
  
  
  

   
   AC:
  
  
  
  

   
   
   
   
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 1000;
const int bit = 42;
typedef long long LL;
LL a[maxn][maxn],g[maxn];
int n;

void build_matrix()		//构造系数矩阵
{
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < bit; j++)
			a[i][bit-1-j] = (g[i]>>j) & 1;
	}
}

void Gauss(int n)
{
	int row = 0,col = 0,j,k,r;
	while(row < n && col < bit)
	{
		r = row;
		for(k = row+1; k < n; k++)
			if(a[k][col])
			{
				r = k;
				break;
			}
		if(a[r][col])
		{
			if(r != row)
			{
				for(k = col; k < bit; k++)
					swap(a[r][k],a[row][k]);
			}
			//异或消元
			for(k = row+1; k < n; k++)
			{
				if(a[k][col] == 0) continue;
				for(j = col; j < bit; j++)
					a[k][j] ^= a[row][j];
			}
			row++;
		}
		col++;
	}
	if(row < n) printf("Yes\n");
	else printf("No\n");
}

int main()
{	
	int t;
	cin>>t;
	while(t--)
	{
		cin>>n;
		for(int i = 0; i < n; i++)
			scanf("%I64d",&g[i]);
		build_matrix();
		if(n > bit)
		{
			printf("Yes\n");
			continue;
		}
		Gauss(n);
	}
	return 0;
}