[POJ1143]Number Game

[POJ1143]Number Game

试题描述

Christine and Matt are playing an exciting game they just invented: the Number Game. The rules of this game are as follows. 
The players take turns choosing integers greater than 1. First, Christine chooses a number, then Matt chooses a number, then Christine again, and so on. The following rules restrict how new numbers may be chosen by the two players: 

• A number which has already been selected by Christine or Matt, or a multiple of such a number,cannot be chosen. 
• A sum of such multiples cannot be chosen, either.

If a player cannot choose any new number according to these rules, then that player loses the game. 
Here is an example: Christine starts by choosing 4. This prevents Matt from choosing 4, 8, 12, etc.Let's assume that his move is 3. Now the numbers 3, 6, 9, etc. are excluded, too; furthermore, numbers like: 7 = 3+4;10 = 2*3+4;11 = 3+2*4;13 = 3*3+4;... are also not available. So, in fact, the only numbers left are 2 and 5. Christine now selects 2. Since 5=2+3 is now forbidden, she wins because there is no number left for Matt to choose. 
Your task is to write a program which will help play (and win!) the Number Game. Of course, there might be an infinite number of choices for a player, so it may not be easy to find the best move among these possibilities. But after playing for some time, the number of remaining choices becomes finite, and that is the point where your program can help. Given a game position (a list of numbers which are not yet forbidden), your program should output all winning moves. 
A winning move is a move by which the player who is about to move can force a win, no matter what the other player will do afterwards. More formally, a winning move can be defined as follows. 

• A winning move is a move after which the game position is a losing position. 
• A winning position is a position in which a winning move exists. A losing position is a position in which no winning move exists. 
• In particular, the position in which all numbers are forbidden is a losing position. (This makes sense since the player who would have to move in that case loses the game.)

输入

The input consists of several test cases. Each test case is given by exactly one line describing one position. 
Each line will start with a number n (1 <= n <= 20), the number of integers which are still available. The remainder of this line contains the list of these numbers a1;...;an(2 <= ai <= 20). 
The positions described in this way will always be positions which can really occur in the actual Number Game. For example, if 3 is not in the list of allowed numbers, 6 is not in the list, either. 
At the end of the input, there will be a line containing only a zero (instead of n); this line should not be processed.

输出

For each test case, your program should output "Test case #m", where m is the number of the test case (starting with 1). Follow this by either "There's no winning move." if this is true for the position described in the input file, or "The winning moves are: w1 w2 ... wk" where the wi are all winning moves in this position, satisfying wi < wi+1 for 1 <= i < k. After this line, output a blank line.

输入示例

2 2 5
2 2 3
5 2 3 4 5 6
0

输出示例

Test Case #1
The winning moves are: 2

Test Case #2
There's no winning move.

Test Case #3
The winning moves are: 4 5 6

数据规模及约定

见“输入”

题解

这是一道博弈题，那么肯定是 dp 了。

一看数字这么少，自然想到状压 dp。根据博弈题的惯例，我们要枚举当前状态选举那个数字然后进行转移。

设 f(S) 表示当前剩余数字集合为 S，先手必胜还是必输。那么转移是枚举每个可以取的数字，假设我选择了数字 x，那么对于每一个数字 y，如果 y 没有在集合 S 中出现，则 x + y 这个数字也不能取了；同时注意，如果新产生了一个不能取的数，那么这个数 + x 也是不能取的（类似于对于这个集合 S 又做了一次无限背包）；把所有不能取的数从状态 S 中去掉得到新的状态 tS 就可以转移了。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
	return x * f;
}

#define maxn 25
#define maxs 1048576

char str[maxn];
char* bin_(int x) {
	int l = 0;
	while(x) str[l++] = (x & 1) + '0', x >>= 1;
	while(l < 19) str[l++] = '0';
	str[l] = 0;
	return str;
}

int f[maxs];
int dp(int S) {
	if(!S) return f[S] = 0;
	if(f[S] >= 0) return f[S];
	for(int i = 0; i < 19; i++) if(S >> i & 1) {
		int x = i + 2, tS = S ^ (1 << i);
		for(int j = 0; j < 19; j++)
			if(j + x < 19 && !(tS >> j & 1) && (tS >> j + x & 1)) tS ^= (1 << j + x);
		if(!dp(tS)) return f[S] = 1;
	}
	return f[S] = 0;
}

int cnt, Ans[maxn];

int main() {
	int kase = 0;
	while(1) {
		int n = read();
		if(!n) break;
		int S = 0;
		for(int i = 1; i <= n; i++) S |= (1 << read() - 2);
		memset(f, -1, sizeof(f));
		printf("Test Case #%d\n", ++kase);
		if(dp(S)) {
			printf("The winning moves are: ");
			cnt = 0;
			for(int i = 0; i < 19; i++) if(S >> i & 1) {
				int x = i + 2, tS = S ^ (1 << i);
				for(int j = 0; j < 19; j++)
					if(j + x < 19 && !(tS >> j & 1) && (tS >> j + x & 1)) tS ^= (1 << j + x);
				if(!dp(tS)) Ans[++cnt] = x;
			}
			for(int i = 1; i <= cnt; i++) printf("%d%c", Ans[i], i < cnt ? ' ' : '\n');
			putchar('\n');
		}
		else puts("There\'s no winning move.\n");
	}
	
	return 0;
}