HDU 3683 Gomoku (枚举+BFS)

题目大意:给一个五子棋,判断能否在三步内赢棋。

分析:

一步赢棋,枚举下棋位置看是否有5子出现

两步对手赢棋,对手有至少两个位置下棋后可以出现5子

三步赢棋,枚举当前己方下棋点,然后判断会不会出现至少两个位置下棋后可以出现5子,这里还得注意枚举的己方下棋后,对手不能出现(1)的情况。

#include <iostream>
#include <cstring>

using namespace std;

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(cin>>n&&n)
    {
        memset(a, -1, sizeof(a));
        int sum1=0, sum2=0, x, y, op, c;

        for(int i=0; i<n; i++)
        {
            cin>>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
        {
            cout<<"Invalid."<<endl;
            continue;
        }

        if(gao1(op,x,y))
        {
            if(op==1)
                cout<<"Place black at ("<<x<<","<<y<<") to win in 1 move."<<endl;
            else
                cout<<"Place white at ("<<x<<","<<y<<") to win in 1 move."<<endl;
        }
        else if(gao2(1-op))
            cout<<"Lose in 2 moves."<<endl;
        else if(gao3(op,x,y))
            {
                if(op==1)
                    cout<<"Place black at ("<<x<<","<<y<<") to win in 3 moves."<<endl;
                else
                    cout<<"Place white at ("<<x<<","<<y<<") to win in 3 moves."<<endl;
            }
        else
            cout<<"Cannot win in 3 moves."<<endl;

    }
    return 0;
}
时间: 2024-09-30 13:21:08

HDU 3683 Gomoku (枚举+BFS)的相关文章

hdu 3683 Gomoku (模拟、搜索)

Gomoku Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1319    Accepted Submission(s): 328 Problem Description You are probably not familiar with the title, "Gomoku", but you must have pla

[博弈] hdu 3683 Gomoku

题意: 两个人下五子棋.给你现有棋盘,推断在三步之内的胜负情况. 输出分为几种. 1.棋盘不合法 2.黑或白在第一步赢下在(x,y)点,多个输出x最小的.y最小的. 3.输在第二步 4.黑或白在第三步赢在(x,y)点,多个输出x最小的.y最小的. 5.三步内不分胜负 思路: 首先先推断棋盘是否合法 然后就是须要一个寻找当前我要下黑棋或者白棋在棋盘中我有几个必胜点. 所谓的必胜点就是我下这个位置我能连五子或者以上. 然后就是 1.一步直接赢(我有一个或以上的必胜点) 2.二步直接输(对方有两个以上

HDU 4771 Stealing Harry Potter&#39;s Precious (生成排列+枚举 + BFS)

Stealing Harry Potter's Precious Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1982    Accepted Submission(s): 931 Problem Description Harry Potter has some precious. For example, his invisib

hdu 1429 状压bfs

#include <iostream> #include <cstring> #include <string> #include <cstdio> #include <cmath> #include <algorithm> #include <vector> #include <queue> #include <map> #define inf 0x3f3f3f3f #define ll __in

HDU 1242 Rescue(优先队列+bfs)

题目地址:HDU 1242 这个题相比于普通的bfs有个特殊的地方,经过士兵时会额外消耗时间,也就是说此时最先搜到的时候不一定是用时最短的了.需要全部搜一遍才可以.这时候优先队列的好处就显现出来了.利用优先队列,可以让队列中的元素按时间排序,让先出来的总是时间短的,这样的话,最先搜到的一定是时间短的,就不用全部搜一遍了.PS:我是为了学优先队列做的这题..不是为了这题而现学的优先队列.. 代码如下: #include <iostream> #include <stdio.h> #i

POJ 2243 || HDU 1372:Knight Moves(BFS)

Knight Moves Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 11223 Accepted: 6331 Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that visit

hdu 4400 离散化+二分+BFS(暴搜剪枝还超时的时候可以借鉴一下)

Mines Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 1110    Accepted Submission(s): 280 Problem Description Terrorists put some mines in a crowded square recently. The police evacuate all peo

HDU 4856 Tunnels(BFS+状压DP)

HDU 4856 Tunnels 题目链接 题意:给定一些管道,然后管道之间走是不用时间的,陆地上有障碍,陆地上走一步花费时间1,求遍历所有管道需要的最短时间,每个管道只能走一次 思路:先BFS预处理出两两管道的距离,然后状态压缩DP求解,dp[s][i]表示状态s,停在管道i时候的最小花费 代码: #include <cstdio> #include <cstring> #include <queue> #include <algorithm> using

HDU 1072 Nightmare (BFS)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1072 题目大意: 走迷宫,初始剩余时间为6min,每步1min:到reset区是若剩余时间大于0,则可以重置.到终点3区,若时间大于0,则成功逃脱.(可以走回路) 0:wall 1:可以走 2:起点 3:终点 4:剩余时间重置为6 源代码: #include<iostream> #include<cstring> #include<cstdio> #include<q