hdu3683 Gomoku 暴力+模拟

http://acm.hdu.edu.cn/showproblem.php?pid=3683

Gomoku

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1335    Accepted Submission(s): 335

Problem Description

You are probably not familiar with the title, “Gomoku”, but you must have played it a lot. Gomoku is an abstract strategy board game and is also called Five in a Row, or GoBang. It is traditionally played with go pieces (black and white stones) on a go board (19x19 intersections). Nowadays, standard chessboard of Gomoku has 15x15 intersections. Black plays first, and players alternate in placing a stone of their color on an empty intersection. The winner is the first player to get an unbroken row of five or more stones horizontally, vertically, or diagonally. 

For convenience, we coordinate the chessboard as illustrated above. The left-bottom intersection is (0,0). And the bottom horizontal edge is x-axis, while the left vertical line is y-axis. 

I am a fan of this game, actually. However, I have to admit that I don’t have a sharp mind. So I need a computer program to help me. What I want is quite simple. Given a chess layout, I want to know whether someone can win within 3 moves, assuming both players are clever enough. Take the picture above for example. There are 31 stones on it already, 16 black ones and 15 white ones. Then we know it is white turn. The white player must place a white stone at (5,8). Otherwise, the black player will win next turn. After that, however, the white player also gets a perfect situation that no matter how his opponent moves, he will win at the 3rd move. 

So I want a program to do similar things for me. Given the number of stones and positions of them, the program should tell me whose turn it is, and what will happen within 3 moves.

 

Input

The input contains no more than 20 cases.
Each case contains n+1 lines which are formatted as follows.
n
x ₁ y ₁ c ₁
x ₂ y ₂ c ₂
......
x _n y _n c _n
The first integer n indicates the number of all stones. n<=222 which means players have enough space to place stones. Then n lines follow. Each line contains three integers: x _i and y _i and c _i. x _i and y _i are coordinates of the stone, and c _i means the color of the stone. If c _i=0 the stone is white. If c _i=1 the stone is black. It is guaranteed that 0<=x _i,y _i<=14, and c _i=0 or 1. No two stones are placed at the same position. It is also guaranteed that there is no five in a row already, in the given cases.
The input is ended by n=0.

 

Output

For each test case:

First of all, the program should check whose turn next. Let’s call the player who will move next “Mr. Lucky”. Obviously, if the number of the black stone equals to the number of white, Mr. Lucky is the black player. If the number of the black stone equals to one plus the numbers of white, Mr. Lucky is the white player. If it is not the first situation or the second, print “Invalid.” 

A valid chess layout leads to four situations below:

1)Mr. Lucky wins at the 1 ^st move. In this situation, print :

Place TURN at (x,y) to win in 1 move.

“TURN” must be replaced by “black” or “white” according to the situation and (x,y) is the position of the move. If there are different moves to win, choose the one where x is the smallest. If there are still different moves, choose the one where y is the smallest.

2)Mr. Lucky’s opponent wins at the 2 ^nd move. In this situation, print:

Lose in 2 moves.

3)Mr. Lucky wins at the 3 ^rd move. If so, print:

Place TURN at (x,y) to win in 3 moves.

“TURN” should replaced by “black” or “white”, (x,y) is the position where the Mr. Lucky should place a stone at the 1 ^st move. After he place a stone at (x,y), no matter what his opponent does, Mr. Lucky will win at the 3[sup]rd[sup] step. If there are multiple choices, do the same thing as described in situation 1. 

4)Nobody wins within 3 moves. If so, print:

Cannot win in 3 moves.

 

Sample Input

  
  

   
   31
3 3 1
3 4 0
3 5 0
3 6 0
4 4 1
4 5 1
4 7 0
5 3 0
5 4 0
5 5 1
5 6 1
5 7 1
5 9 1
6 4 1
6 5 1
6 6 0
6 7 1
6 8 0
6 9 0
7 5 1
7 6 0
7 7 1
7 8 1
7 9 0
8 5 0
8 6 1
8 7 0
8 8 1
8 9 0
9 7 1
10 8 0
1
7 7 1
1
7 7 0
0
  
  

 

Sample Output

  
  

   
   Place white at (5,8) to win in 3 moves.
Cannot win in 3 moves.
Invalid.
  
  

 

Source

2010 Asia Hangzhou Regional Contest

题意：给一个五子棋，判断能否在三步内赢棋。

分析：(1).一步赢棋，直接暴力枚举下棋位置看是不是有5子出现..

(2)两步对手赢棋，就是对手有至少两个位置下棋后可以出现5子，那么就枚举位置看是不是存在有两个位置下棋后可以出现5子。

(3)三步赢棋，枚举当前己方下棋点，然后判断己方会不会出现(2)的情况。。这里还得注意枚举的己方下棋后，对手不能出现(1)的情况。。

具体实现就是类似于bfs的向四个方向搜搜。。

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <cmath>
#include <set>
#include <map>
using namespace std;
typedef long long LL;
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define clr(a) memset(a,0,sizeof a)
#define clr1(a) memset(a,-1,sizeof a)
#define dbg(a) printf("%d\n",a)
typedef pair<int,int> pp;
const double eps=1e-8;
const double pi=acos(-1.0);
const int INF=0x7fffffff;
const LL inf=(((LL)1)<<61)+5;
int a[20][20];
bool inmap(int x,int y,int op)
{
    return x>=0&&x<15&&y>=0&&y<15&&a[x][y]==op;
}
int dir[4][2]={1,0,0,1,1,1,-1,1};
int bfs(int x,int y,int op)
{
    for(int i=0;i<4;i++)
    {
        int sum=1;
        int xx=x+dir[i][0];
        int yy=y+dir[i][1];
        while(inmap(xx,yy,op))
        {
            xx+=dir[i][0];
            yy+=dir[i][1];
            sum++;
        }
        xx=x-dir[i][0];
        yy=y-dir[i][1];
        while(inmap(xx,yy,op))
        {
            xx-=dir[i][0];
            yy-=dir[i][1];
            sum++;
        }
        if(sum>=5) return sum;
    }
    return -1;
}
bool gao1(int op,int &x,int &y)
{
    for(int i=0;i<15;i++)
    {
        for(int j=0;j<15;j++)
        {
            if(a[i][j]==-1)
            {
                int ans=bfs(i,j,op);
                if(ans>=5)
                {
                    x=i,y=j;
                    return true;
                }
            }
        }
    }
    return false;
}
bool gao2(int op)
{
    int sum=0;
    for(int i=0;i<15;i++)
    {
        for(int j=0;j<15;j++)
        {
            if(a[i][j]==-1)
            {
                int ans=bfs(i,j,op);
                if(ans>=5)
                    sum++;
                if(sum>=2) return true;
            }
        }
    }
    return false;
}
bool gao3(int op,int &x,int &y)
{
    for(int i=0;i<15;i++)
    {
        for(int j=0;j<15;j++)
        {
            if(a[i][j]==-1)
            {
                a[i][j]=op;
                if(!gao1(1-op,x,y)&&gao2(op)) //这里注意
                {
                    x=i,y=j;
                    return true;
                }
                a[i][j]=-1;
            }
        }
    }
    return false;
}
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        clr1(a);
        int sum1=0,sum2=0,x,y,op,c;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d",&x,&y,&c);
            a[x][y]=c;
            if(c==1) sum1++;
            else sum2++;
        }
        if(sum1==sum2) op=1;
        else if(sum1==sum2+1) op=0;
        else
        {
            puts("Invalid.");
            continue;
        }
        if(gao1(op,x,y))
        {
            if(op==1)
                printf("Place black at (%d,%d) to win in 1 move.\n",x,y);
            else
                printf("Place white at (%d,%d) to win in 1 move.\n",x,y);
        }
        else if(gao2(1-op))
            puts("Lose in 2 moves.");
        else
        {
            if(gao3(op,x,y))
            {
                if(op==1)
                    printf("Place black at (%d,%d) to win in 3 moves.\n",x,y);
                else
                    printf("Place white at (%d,%d) to win in 3 moves.\n",x,y);
            }
            else
                puts("Cannot win in 3 moves.");
        }
    }
    return 0;
}