POJ1085: Triangle War

Triangle War

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 1489		Accepted: 595

Description

Triangle War is a two-player game played on the following triangular grid:

Two players, A and B, take turns filling in any dotted line connecting two dots, with A starting first. Once a line is filled, it cannot be filled again. If the line filled by a player completes one or more triangles, she owns the completed triangles and she is awarded another turn (i.e. the opponent skips a turn). The game ends after all dotted lines are filled in, and the player with the most triangles wins the game. The difference in the number of triangles owned by the two players is not important.

For example, if A fills in the line between 2 and 5 in the partial game on the left below:

Then, she owns the triangle labelled A and takes another turn to fill in the line between 3 and 5. B can now own 3 triangles (if he wishes) by filling in the line between 2 and 3, then the one between 5 and 6, and finally the one between 6 and 9. B would then make one more move before it is A's turn again.
In this problem, you are given a number of moves that have already been made. From the partial game, you should determine which player will win assuming that each player plays a perfect game from that point on. That is, assume that each player always chooses the play that leads to the best possible outcome for himself/herself.

Input

You will be given a number of games in the input. The first line of input is a positive integer indicating the number of games to follow. Each game starts with an integer 6 <= m <= 18 indicating the number of moves that have been made in the game. The next m lines indicate the moves made by the two players in order, each of the form i j (with i < j) indicating that the line between i and j is filled in that move. You may assume that all given moves are legal.

Output

For each game, print the game number and the result on one line as shown below. If A wins, print the sentence "A wins." If B wins, print "B wins."

Sample Input

4 
6 
2 4 
4 5 
5 9 
3 6 
2 5 
3 5 
7 
2 4 
4 5 
5 9 
3 6 
2 5 
3 5 
7 8 
6 
1 2 
2 3 
1 3 
2 4 
2 5 
4 5 
10 
1 2 
2 5 
3 6 
5 8 
4 7 
6 10 
2 4 
4 5 
4 8 
7 8 

Sample Output

Game 1: B wins. 
Game 2: A wins. 
Game 3: A wins. 
Game 4: B wins.

Source

East Central North America 1999

                         

                         

                         

                         

                         

                         

                         

                         

解题思路：

总共有18条边，每条边只有两种状态：已填充或未填充，又，已知至少6个步骤，所以需要搜索的状态最多为2^12种；

为了表示状态，我们设计每条边占据一个bit位，这样2^18种状态都可以表示出来；

DP的重点在于递推式，我们假设state[i]表示某玩家在i状态下，填充某一条边得到的最大的三角形差值（自己获得的 - 对方玩家获得的），我们试遍每一条可以添加的边，假设可以添加边id，如果id添加后获得三角形（gTri(i, id) > 0），这时可以连续添加，获得三角形数nt = gTri(i, id) + state[i]；否则nt = gTir(i, id) - state[i]；试遍所有可以添加的边后，最大的nt作为state[i]的值记录下来。

//#include <windows.h> //#include <iostream> //#include <fstream> #include <cstdio> //#include <cmath> //#include <cstdlib> //#include <cstring> //#include <algorithm> //using namespace std; //LARGE_INTEGER _lTemp; //LONGLONG _dFreq, _bTime, _eTime; //double _uTime; //定义最小 const int min = -10; //2的幂，0~17次 const int bin[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072}; //三角形的三边 const int trgl[][3] = {​{bin[0], bin[1], bin[2]}, {bin[3], bin[4], bin[7]}, {bin[2], bin[4], bin[5]}, {bin[5], bin[6], bin[8]}, {bin[9], bin[10], bin[15]}, {bin[7], bin[10], bin[11]}, {bin[11], bin[12], bin[16]}, {bin[8], bin[12], bin[13]}, {bin[13], bin[14], bin[17]}}; //记录顶点对应的边，编号0~17 int edge[11][11]; void init(){ for (int i = 1; i <= 10; i ++) for (int j = i; j <= 10; j ++) edge[i][j] = -1; edge[1][2] = 0; edge[1][3] = 1; edge[2][3] = 2; edge[2][4] = 3; edge[2][5] = 4; edge[3][5] = 5; edge[3][6] = 6; edge[4][5] = 7; edge[5][6] = 8; edge[4][7] = 9; edge[4][8] = 10; edge[5][8] = 11; edge[5][9] = 12; edge[6][9] = 13; edge[6][10] = 14; edge[7][8] = 15; edge[8][9] = 16; edge[9][10] = 17; for (int i = 1; i <= 10; i ++) for (int j = i + 1; j <= 10; j ++) edge[j][i] = edge[i][j]; } //在状态st下，加入编号为id的边，可以得到的三角形数 int gTri(int st, int id){ int result = 0, occured; bool put; for (int i = 0; i < 9; i ++){ occured = 0; put = false; for (int j = 0; j < 3; j ++){ if (trgl[i][j] & st) occured ++; else if (trgl[i][j] & bin[id]) put = true; } if (put && occured == 2) result ++; } return result; } //state[i]记录状态i的能得到的最大的三角形数的差 int state[262144]; void sets(){ for (int i = 0; i < 262144; i ++) state[i] = min; state[262143] = 0; //末尾状态：0 } //动规 void DP(int st){ if (state[st] > min) return; //检查是否已做过 int max = min, newt; //初始化 for (int i = 0; i < 18; i ++){ if (!(st & bin[i])){ //如果边未填充 DP(st | bin[i]); //DP填充后 newt = gTri(st, i); //填充能得到三角形数 if (newt == 0) newt -= state[st | bin[i]]; //如果没有得到三角形，那么填充后状态的差是对方的 else newt += state[st | bin[i]]; //如果填充后得到三角形，那些下一个状态还是自己的 if (max < newt) max = newt; //选择最优情况 } } state[st] = max; //设置最优情况 } int main(){ // freopen("in.txt", "r", stdin); //重定向输入 // freopen("out.txt", "w", stdout);//重定向输出 // QueryPerformanceFrequency(&_lTemp); //获取运算频率 // _dFreq = _lTemp.QuadPart; //获取运算频率大整数 // QueryPerformanceCounter(&_lTemp); //获取开始时间 // _bTime = _lTemp.QuadPart; //获取开始时间大整数 init(); sets(); int n, m, x, y, nt, result; int stat, curr; bool isA; //stat当前状态，curr记录A与B的三角形数之差，isA记录当前玩家 scanf("%d", &n); for (int cnt = 1; cnt <= n; cnt ++){ stat = 0; curr = 0; isA = true; scanf("%d", &m); while (m --){ scanf("%d%d", &x, &y); nt = gTri(stat, edge[x][y]); //获取三角形数 curr += (nt * (isA ? 1 : -1)); //更新数据 if (nt == 0) isA ^= 1; //玩家轮换 stat |= bin[edge[x][y]]; //状态量更新 } DP(stat); //DP result = curr + (state[stat] * (isA ? 1 : -1)); //计算结果 printf("Game %d: %c wins./n", cnt, (result > 0 ? 'A' : 'B')); } // QueryPerformanceCounter(&_lTemp); //获取终止时间 // _eTime = _lTemp.QuadPart; //获取终止时间大整数 // _uTime = 1000 * double(_eTime - _bTime) / double(_dFreq); //计算总耗时，转化成ms // printf("Time used: %012.3f ms/n", _uTime); //输出总耗时，单位是ms // fclose(stdin); //关闭文件 // fclose(stdout); //关闭文件 return 0; }