UVa10561

10561 Treblecross
Treblecross is a two player game where the goal is to get three ‘X’ in a row on a one-dimensional board.
At the start of the game all cells in the board is empty. In each turn a player puts a ‘X’ in an empty
cell, and if that results in there being three ‘X’ next to each other, that player wins.
Given the current state of the game, you are to determine if the player to move can win the game
assuming both players play perfectly. If so, you should also print all moves that will eventually lead to
a win.
Consider the game where the board size is 5 cells. If the first player puts a ‘X’ at position three (in
the middle) so the state becomes ‘..X..’, he will win the game as no matter where the other player
puts his ‘X’, the first player can get three ‘X’ in a row. If, on the other hand, the first player puts the
‘X’ in any other position, the second player will win the game by putting the ‘X’ in the opposite corner
(for instance, after the second player moves the state might be ‘.X..X’). This will force the first player
to put an ‘X’ in a position so the second player wins in the next move.
Input
The input begins with an integer N (N < 100), the number of states that will follow. Each state is
represented by a string on a line by itself. The string will only contain the characters ‘.’ and ‘X’. The
length of the string (the size of the board) will be between 3 and 200 characters, inclusive. No state
will contain three ‘X’ in a row.
Output
For each case, first output ‘WINNING’ or ‘LOSING’ depending on if the player to move will win or lose the
game. On the next line, output in increasing order all positions on the board where the player to move
may put an X and win the game. The positions should be separated by a blank, and be in increasing
order. The leftmost position on the board is 1.
Sample Input
4
.....
X.....X..X.............X....X..X
.X.X...X
...............................................
Sample Output
WINNING
3
LOSING
WINNING
3
WINNING
1 12 15 17 20 24 28 31 33 36 47

题意：

       有n个格子排成一行，其中有些格子里面有字符X。两个游戏者轮流操作，每次可以选择一个空格，在里面放上一个字符X。如果此时有3个连续的X出现，则该游戏者赢得比赛。初始情况下不会有3个连续的X字符出现。你的任务是判断先手必胜还是必败。如果必胜，则列举出所有的必胜策略。输入的每个字符要么是X要么是.（表示空格）。

分析：

       如果输入中已经有XX或者X.X出现。聪明的游戏者将不会在X的旁边或者旁边的旁边放置X，这两种位置（最多4个位置）都属于不许放X的禁区。谁无法放置X谁就输了。

       于是整个游戏被X字符以及其旁的禁区分割成若干个独立的棋盘片段，每次都可以选择一个片段进行游戏，谁无法进行游戏了就算谁输。这显然是若干子游戏的和。由于每个棋盘片段都是连续的，想到利用棋盘片段的长度来表示状态。

       设g(x)表示长度为x的棋盘片段对应的游戏的SG函数值。考虑可以在左起第一或者第二或者第三或者第四或者第五或者、…个格子等位置放置一个X字符，使得当前状态发生转移，则计算SG函数的递推式应为：

g(x) = mex{g(x - 3),g(x - 4),g(x - 5),g(1) xor g(x - 6),g(2) xor g(x - 7),…}

边界为g(0) = 0，g(1)、g(2)、g(3)都等于0（1、2、3三种状态都只能转移到状态0）。

       在寻找必胜策略的时候就枚举所有的策略，那些后继状态的SG值为0的策略就是必胜策略。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAX_N = 200;
int t,res[MAX_N + 1],way,len,sg[MAX_N + 1];
char str[MAX_N + 1];
int judge(){
    for(int i = 0; i < len - 2; i++)
        if(str[i] == 'X' && str[i + 1] == 'X' && str[i + 2] == 'X')
            return true;
    return false;
}
// 使用记忆化搜索的方式求SG函数值
int SG(int x){
    int vis[MAX_N + 1];
    int i,t;
    if(sg[x] != -1) return sg[x];
    if(x == 0) return sg[x] = 0; // 终态，先手必败
    memset(vis,false,sizeof(vis));
    // 枚举状态x所能达到的所有后继状态，即考虑在x格中的哪一格放置字符X
    for(int i = 1 ; i <= x ; i++){
        int t = SG(max(0,i - 3)) ^ SG(max(0,x - i - 2)); // 两个子游戏
        vis[t] = true;
    }
    for(int i = 0; i <= MAX_N ; i++) {
        if(vis[i]) continue;
        return sg[x] = i;
    }
}
// 当前状态是否是游戏者可行的目标状态
int GetRes(){
    // 枚举当前的所有策略
    for(int i = 0 ; i < len ; i++){
        if(str[i] == '.'){
            str[i] = 'X';
            if(judge()){ // 当前策略得到的后继状态是已胜的
                str[i] = '.';
                return false; // 那么当前的状态可以得到已胜的后继状态，游戏者就要尽量规避留下这种状态给对手
            }
            str[i] = '.';
        }
    }
    int ans = 0,num = 0;
    for (int i = 0 ; i < len ; i++){
        // 如果遍历到了禁区
        if (str[i] == 'X' || (i >= 1 && str[i - 1] == 'X')
        || (i >= 2 && str[i - 2] == 'X')
        || (i + 1 < len && str[i + 1] == 'X')
        || (i + 2 < len && str[i + 2] == 'X')){
            ans ^= SG(num);
            num = 0;
        }
        else num++;
    }
    ans ^= SG(num);
    return ans == 0; // 当前状态是否是先手必败的
}
// 得到所有的必胜策略，即为对手留下SG函数值所有异或值为零的状态的策略
void solve(){
    way = 0;
    len = strlen(str);
    for(int i = 0 ; i < len ; i++) {
        if(str[i] != '.') continue;
        str[i] = 'X';
        // 如果能够得到后继状态为已败或者必败的状态
        if(judge() || GetRes())
            res[way++] = i + 1;
        str[i] = '.';
    }
}
int main(){
    memset(sg,-1,sizeof(sg));
    scanf("%d",&t);
    while(t--){
        scanf("%s",str);
        solve();
        if(way == 0) printf("LOSING

");
        else{
            printf("WINNING
%d",res[0]);
            for(int i = 1 ; i < way ; i++) printf(" %d",res[i]);
            printf("
");
        }
    }
    return 0;
}