POJ 2425 A Chess Game(联合组合博弈+树 无向无环图 )

首先介绍下联合组合博弈，联合组合就是多个组合博弈，以 POJ 2599 为例 此题目就是它的联合组合的题目，需要用到SG定理

Description


Let's design a new chess game. There are N positions to hold M chesses in this game. Multiple chesses can be located in the same position. The positions are constituted as a topological graph, i.e. there are directed edges connecting some positions, and no cycle exists. Two players you and I move chesses alternately. In each turn the player should move only one chess from the current position to one of its out-positions along an edge. The game does not end, until one of the players cannot move chess any more. If you cannot move any chess in your turn, you lose. Otherwise, if the misfortune falls on me... I will disturb the chesses and play it again. 


Do you want to challenge me? Just write your program to show your qualification!
Input


Input contains multiple test cases. Each test case starts with a number N (1 <= N <= 1000) in one line. Then the following N lines describe the out-positions of each position. Each line starts with an integer Xi that is the number of out-positions for the position i. Then Xi integers following specify the out-positions. Positions are indexed from 0 to N-1. Then multiple queries follow. Each query occupies only one line. The line starts with a number M (1 <= M <= 10), and then come M integers, which are the initial positions of chesses. A line with number 0 ends the test case.
Output


There is one line for each query, which contains a string "WIN" or "LOSE". "WIN" means that the player taking the first turn can win the game according to a clever strategy; otherwise "LOSE" should be printed.
Sample Input


4
2 1 2
0
1 3
0
1 0
2 0 2
0


4
1 1
1 2
0
0
2 0 1
2 1 1
3 0 1 3
0
Sample Output


WIN
WIN
WIN
LOSE
WIN

题意：一个无向无环图，给出所连接的边（定义为棋盘），然后给出M个结点及其位置（M=0结束本次棋盘游戏），说明单个游戏中点开始的位置，然后双方开始轮流走，直到一方无法移动，不同的点的位置可以重复，但是单个点是不允许走回头路的。

思路：联合组合博弈，记录每个点的SG值然后取异或，为0则输，其他则赢。

注意：由于此题目的数据较大，在每个棋盘中进行了多次游戏不可以采用像2599那样直接进行查找的方法，应该采用打表。

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
#define MAXN 1005
int map[MAXN][MAXN];
int n,m;
int g[MAXN];
int dfs(int k)
{
    if(g[k]!=-1)
        return g[k];
    bool vis[1005]={0};
    for(int i=0;i<n;i++){  //记忆化搜索得到SG值
        if(map[k][i]){
            g[i]=dfs(i);
            vis[g[i]]=1;
        }
    }
    for(int i=0;i<n;i++){
        if(!vis[i])
           return i;
    }

}
int main()
{
    int x,k;
    while(scanf("%d",&n)==1){
        memset(g,-1,sizeof(g));
        memset(map,0,sizeof(map));
        for(int i=0;i<n;i++){  //记录路径
            scanf("%d",&k);
            if(k==0)
              g[i]=0;
            else
            {
                while(k--)
                {
                    scanf("%d",&x);
                    map[i][x]=1;
                }
            }

        }
        for(int i=0;i<n;i++){
            if(g[i]==-1)  //进行寻找SG值
                g[i]=dfs(i);
        }
        while(scanf("%d",&m)==1&&m){
            int res=0;
            while(m--){
                scanf("%d",&k);
                res^=g[k];   //SG定理
            }
            if(res)
                printf("WIN\n");
            else
                printf("LOSE\n");
        }
    }
    return 0;
}