HDU4101-很好的BFS题目（虽然结果是判断输赢）

题目：题目链接

 

 

题意：题目的意思就是说两个人轮流玩游戏，给你一张地图，这个地图中间有一点-1代表宝藏，Ali and Baba轮流走

路，如果某一个人能够直接走到宝藏的话，那么他就赢了。地图上其它的点0代表空地，数字代表当前地点的石子当

某一人拿石子的时候，他只能拿走一颗。问你谁最后能拿到宝藏；

 

分析：宝藏位于-1的位置，那么如果Ali一开始的时候就可以通过外围的某一点的空地直接经过空地到达宝藏，那么

Ali就赢了，所以我们应该以-1为起点，广搜一次，这样，我们就可以找到可以链接到宝藏的直接路径了（记作区域

A），如果广搜过程中碰见了空地边缘，那么Ali必赢（Ali直接从这里进去就可以了）。如果没有的话，那么到达宝

藏的路线肯定被石子包围住了，那么路径周围的石子当都被移动到只剩1棵时，此时当前选手只能选择打开围墙，那

么他就输了。所以就从外围开始由外向内搜索，如果遇到非A区域的石头，总计和ans加上当前位置的石子数目，如果

遇到的是A区域的石头，总计和ans加上当前位置石子数目-1（必须要留下一个石子，否则对方就赢了），最后求得的

ans也就是Ali能够实施的合法步骤数，根据ans的奇偶性便能得出答案。

 

略麻烦的BFS，狂躁ing.....

 

 

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <functional>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cassert>
#include <bitset>
#include <stack>
#include <ctime>
#include <list>
#define INF 0x7fffffff
#define max3(a,b,c) (max(a,b)>c?max(a,b):c)
#define min3(a,b,c) (min(a,b)<c?min(a,b):c)
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;

int gcd(int  n,int  m)
{
    if(n<m) swap(n,m);
    return n%m==0?m:gcd(m,n%m);
}
int lcm(int n,int m)
{
    if(n<m) swap(n,m);
    return n/gcd(n,m)*m;
}
int prime[100];

void getPrime();
void bash();
void wzf();
void SG();
int QuickMod(int a, int b, int n);

const int maxn = 305;
int mp[maxn][maxn];
bool vis1[maxn][maxn];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool vis[maxn][maxn];

int N, M;
int dx, dy;

struct node
{
    int x, y;
};

bool bfs1()
{
    memset(vis1, false, sizeof vis1);
    queue<node> Q;
    node t;
    t.x = dx, t.y = dy;
    vis1[dy][dx] = true;
    Q.push(t);
    while(!Q.empty())
    {
        node cur = Q.front();
        Q.pop();
        int cx = cur.x;
        int cy = cur.y;
        for(int i = 0; i < 4; i++)
        {
            int nx = cx + dir[i][0];
            int ny = cy + dir[i][1];
            if(nx > 0 && nx <= M && ny > 0 && ny <= N)
            {
                if(!vis1[ny][nx])
                {
                    vis1[ny][nx] = true;
                    if(mp[ny][nx] == 0)
                    {
                        t.x = nx, t.y = ny;
                        Q.push(t);
                    }
                }
            }
            else
                return true;
        }
    }
    return false;
}

int bfs2()
{
    memset(vis, false, sizeof vis);
    int ans = 0;
    queue<node> Q;
    node s, t;
    s.x = 0, s.y = 0;
    vis[0][0] = true;
    Q.push(s);
    while(!Q.empty())
    {
        node cur = Q.front();
        Q.pop();
        int cx = cur.x;
        int cy = cur.y;
        for(int i = 0; i < 4; i++)
        {
            int nx = cx + dir[i][0];
            int ny = cy + dir[i][1];
            if(nx >= 0 && nx <= M + 1 && ny >= 0 && ny <= N + 1)
            {
                if(!vis[ny][nx])
                {
                    vis[ny][nx] = true;
                    if(!vis1[ny][nx])
                    {
                        ans += mp[ny][nx];
                        t.x = nx, t.y = ny;
                        Q.push(t);
                    }
                    else if(vis1[ny][nx] && mp[ny][nx] > 0)
                    {
                        ans += mp[ny][nx] - 1;
                    }
                }
            }
        }
    }
    return ans;
}

int main()
{
    while(scanf("%d %d", &N, &M) != EOF)
    {
        memset(mp, 0, sizeof mp);
        for(int i = 1; i <= N; i++)
        {
            for(int j = 1; j <= M; j++)
            {
                scanf("%d", &mp[i][j]);
                if(mp[i][j] == -1)
                    dx = j, dy = i;
            }
        }
        if(bfs1())
        {
            puts("Ali Win");
            continue;
        }
        int ans = bfs2();
        if(ans & 1)
            puts("Ali Win");
        else
            puts("Baba Win");
    }
    return 0;
}
int QuickMod(int  a,int b,int n)
{
    int r = 1;
    while(b)
    {
        if(b&1)
            r = (r*a)%n;
        a = (a*a)%n;
        b >>= 1;
    }
    return r;
}

void getPrime()
{
    memset(prime, 0, sizeof(prime));
    prime[0] = 1;
    prime[1] = 1;
    for(int i = 2; i < N; ++i)
    {
        if(prime[i] == 0)
        {
            for(int j = i+i; j < N; j+=i)
                prime[j] = 1;
        }
    }
}

void bash(int n, int m)
{
    if(n%(m+1) != 0)
        printf("1\n");
    else
        printf("0\n");
}

void wzf(int n, int m)
{
    if(n > m)
        swap(n, m);
    int k = m-n;
    int a = (k * (1.0 + sqrt(5.0))/2.0);
    if(a == n)
        printf("0\n");
    else
        printf("1\n");
}

int numsg[100];
void SG(int n)
{
    int sum = 0;
    for(int i=0; i < n; i++)
    {
        scanf("%d",&numsg[i]);
        sum ^= numsg[i];
    }
    if(sum == 0)
        printf("No\n");
    else
    {
        printf("Yes\n");
        for(int i = 0; i < n; i++)
        {
            int s = sum ^ numsg[i];
            if(s < numsg[i])
                printf("%d %d\n", numsg[i], s);//从有num[i]个石子的堆后剩余s个石子
        }

    }
}