hdu 4101

最新推荐文章于 2018-06-21 15:59:29 发布
最新推荐文章于 2018-06-21 15:59:29 发布
阅读量745 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 搜索 HDU 文章标签： hdu bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xlc2845321/article/details/11989845

比赛的时候先是受以前一个圣神海的题目 用了两遍DFS 第一遍标记出围墙  第二遍求围墙外和每块围墙降为1所需的攻击次数  结果爆栈  改为BFS后AC 

DFS的加了一句这个 #pragma comment(linker, "/STACK:1024000000,1024000000")  就解决了爆栈问题

然后就是比赛的时候写了一个bug  竟然过了  

//dfs
#include <iostream>
#include <fstream>
#include <cstring>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int dx[5] = {1, -1, 0, 0}, dy[5] = {0, 0, 1, -1};
int g[310][310],sum,n,m;
bool vis[310][310],ok,dd[310][310];
void init()
{
    memset(g, 0, sizeof(g));
    sum = 0;
    ok = false;
    memset(vis, 0, sizeof(vis));
    memset(dd, 0, sizeof(dd));
}
bool cc(int x, int y)
{
    if(x >= 1 && x <= n && y >= 1 && y <= m)
        return true;
    return false;
}
void dfs(int x, int y)
{
    vis[x][y] = 1;
    if(x == 1 || x == n || y == 1 || y == m)
        ok = true;
    for(int i = 0; i < 4; i++)
    {
        int nx = x+dx[i], ny = y+dy[i];
        if(cc(nx, ny) && !vis[nx][ny])
        {
            if(g[nx][ny] == 0)
            {
                dfs(nx, ny);
            }
            else
            {
                dd[nx][ny] = 1;
            }
        }
    }
}
void dfs2(int x, int y)
{
    for(int i = 0; i < 4; i++)
    {
        int nx = x+dx[i], ny = y+dy[i];
        if(cc(nx, ny) && !vis[nx][ny])
        {
            if(!dd[nx][ny])
            {
                sum += g[nx][ny];
                vis[nx][ny] = 1;
                dfs2(nx, ny);
            }
            else
            {
                vis[nx][ny] = 1;
                sum += g[nx][ny] -1;
            }
        }
    }
}
int main(void)
{
    int _x,_y;
    while(scanf("%d%d",&n,&m) == 2)
    {
        init();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
            {
                scanf("%d",&g[i][j]);
                if(g[i][j] == -1)
                    _x = i, _y = j;
            }
        dfs(_x, _y);
        if(ok)
        {
            printf("Ali Win\n");
        }
        else
        {
            memset(vis, 0, sizeof(vis));
            for(int i = 1; i <= n; i++)
            {
                if(!dd[i][1] && !vis[i][1])
                {
                    vis[i][1] = 1;
                    sum += g[i][1];
                    dfs2(i, 1);
                }
                else if(dd[i][1] && !vis[i][1])
                {
                    vis[i][1] = 1;
                    sum += g[i][1]-1;
                }
                if(!dd[i][m] && !vis[i][m])
                {
                    vis[i][m] = 1;
                    sum += g[i][m];
                    dfs2(i, m);
                }
                else if(dd[i][m] && !vis[i][m])
                {
                    vis[i][m] = 1;
                    sum += g[i][m]-1;
                }
            }
            for(int i = 1; i <= m; i++)
            {
                if(!dd[1][i] && !vis[1][i])
                {
                    vis[1][i] = 1;
                    sum += g[1][i];
                    dfs2(1, i);
                }
                else if(dd[1][i] && !vis[1][i])
                {
                    vis[1][i] = 1;
                    sum += g[1][i]-1;
                }
                if(!dd[n][i] && !vis[n][i])
                {
                    vis[n][i] = 1;
                    sum += g[n][i];
                    dfs2(n, i);
                }
                else if(dd[n][i] && !vis[n][i])
                {
                    vis[n][i] = 1;
                    sum += g[n][i]-1;
                }
            }
           // printf("%d\n",sum);
            if(sum%2)
                printf("Ali Win\n");
            else
                printf("Baba Win\n");
        }
    }
    return 0;
}


#include <iostream>
#include <fstream>
#include <cstring>
#include <queue>
using namespace std;
int dx[5] = {1, -1, 0, 0}, dy[5] = {0, 0, 1, -1};
int g[310][310],sum,n,m;
bool vis[310][310],ok,dd[310][310];
void init()
{
    memset(g, 0, sizeof(g));
    sum = 0;
    ok = false;
    memset(vis, 0, sizeof(vis));
    memset(dd, 0, sizeof(dd));
}
bool cc(int x, int y)
{
    if(x >= 1 && x <= n && y >= 1 && y <= m)
        return true;
    return false;
}
bool cc2(int x, int y)
{
    if(x >= 0 && x <= n+1 && y >= 0 && y <= m+1)
        return true;
    return false;
}
void dfs(int x, int y)
{
    queue<int> Q;
    int u = m*x+y;
    Q.push(u);
    while(!Q.empty())
    {
        u = Q.front();
        Q.pop();
        x = (u-1)/m, y = u%m == 0 ? m:u%m;
        if(x == 1 || x == n || y ==1 || y == m)
            ok = true;
        vis[x][y] = 1;
        for(int i = 0; i < 4; i++)
        {
            int nx = x+dx[i], ny = y+dy[i];
            if(cc(nx, ny) && !vis[nx][ny])
            {
                if(g[nx][ny] == 0)
                {
                    int v = nx*m+ny;
                    Q.push(v);
                }
                else
                {
                    vis[nx][ny] = 1;
                    dd[nx][ny] = 1;
                }
            }
        }
    }
}

void dfs2(int x, int y)
{
    vis[x][y] = 1;
    queue<int> Q;
    int u = (m+2)*x+y;
    Q.push(u);
    while(!Q.empty())
    {
        u = Q.front();
        Q.pop();
        x = u/(m+2), y = u%(m+2);
        for(int i = 0; i < 4; i++)
        {
            int nx = x+dx[i], ny = y+dy[i];
            if(cc2(nx, ny) && !vis[nx][ny])
            {
                if(!dd[nx][ny])
                {
                    sum += g[nx][ny];
                    vis[nx][ny] = 1;
                    int v = nx*(m+2)+ny;
                    Q.push(v);
                }
                else
                {
                    vis[nx][ny] = 1;
                    sum += g[nx][ny] -1;
                }
            }
        }
    }
}
int main(void)
{
    int _x,_y;
    while(scanf("%d%d",&n,&m) == 2)
    {
        init();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
            {
                scanf("%d",&g[i][j]);
                if(g[i][j] == -1)
                    _x = i, _y = j;
            }
        dfs(_x, _y);
        if(ok)
        {
            printf("Ali Win\n");
        }
        else
        {
            memset(vis, 0, sizeof(vis));
            dfs2(0, 0);
           // printf("%d\n",sum);
            if(sum%2)
                printf("Ali Win\n");
            else
                printf("Baba Win\n");
        }
    }
    return 0;
}

#include <iostream>
#include <fstream>
#include <cstring>
#include <queue>
using namespace std;
int dx[5] = {1, -1, 0, 0}, dy[5] = {0, 0, 1, -1};
int g[310][310],sum,n,m;
bool vis[310][310],ok,dd[310][310];
void init()
{
    memset(g, 0, sizeof(g));
    sum = 0;
    ok = false;
    memset(vis, 0, sizeof(vis));
    memset(dd, 0, sizeof(dd));
}
bool cc(int x, int y)
{
    if(x >= 1 && x <= n && y >= 1 && y <= m)
        return true;
    return false;
}
void dfs(int x, int y)
{
    queue<int> Q;
    int u = m*x+y;
    Q.push(u);
    while(!Q.empty())
    {
        u = Q.front();
        Q.pop();
        x = (u-1)/m, y = u%m == 0 ? m:u%m;
        if(x == 1 || x == n || y ==1 || y == m)
            ok = true;
        vis[x][y] = 1;
        for(int i = 0; i < 4; i++)
        {
            int nx = x+dx[i], ny = y+dy[i];
            if(cc(nx, ny) && !vis[nx][ny])
            {
                if(g[nx][ny] == 0)
                {
                    int v = nx*m+ny;
                    Q.push(v);
                }
                else
                {
                    vis[nx][ny] = 1;
                    dd[nx][ny] = 1;
                }
            }
        }
    }
}

void dfs2(int x, int y)
{
    vis[x][y] = 1;
    queue<int> Q;
    int u = m*x+y;
    Q.push(u);
    while(!Q.empty())
    {
        u = Q.front();
        Q.pop();
        x = (u-1)/m, y = u%m == 0 ? m:u%m;
        for(int i = 0; i < 4; i++)
        {
            int nx = x+dx[i], ny = y+dy[i];
            if(cc(nx, ny) && !vis[nx][ny])
            {
                if(!dd[nx][ny])
                {
                    sum += g[nx][ny];
                    vis[nx][ny] = 1;
                    int v = nx*m+ny;
                    Q.push(v);
                }
                else
                {
                    vis[nx][ny] = 1;
                    sum += g[nx][ny] -1;
                }
            }
        }
    }
}
int main(void)
{
    int _x,_y;
    while(scanf("%d%d",&n,&m) == 2)
    {
        init();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
            {
                scanf("%d",&g[i][j]);
                if(g[i][j] == -1)
                    _x = i, _y = j;
            }
        dfs(_x, _y);
        if(ok)
        {
            printf("Ali Win\n");
        }
        else
        {
            memset(vis, 0, sizeof(vis));
            for(int i = 1; i <= n; i++)
            {
                if(!dd[i][1] && !vis[i][1])
                {
                    vis[i][1] = 1;
                    sum += g[i][1];
                    dfs2(i, 1);
                }
                else if(dd[i][1] && !vis[i][1])
                {
                    vis[i][1] = 1;
                    sum += g[i][1]-1;
                }
                if(!dd[i][m] && !vis[i][m])
                {
                    vis[i][m] = 1;
                    sum += g[i][m];
                    dfs2(i, m);
                }
                else if(dd[i][m] && !vis[i][m])
                {
                    vis[i][m] = 1;
                    sum += g[i][m]-1;
                }
            }
            for(int i = 1; i <= m; i++)
            {
                if(!dd[1][i] && !vis[1][i])
                {
                    vis[1][i] = 1;
                    sum += g[1][i];
                    dfs2(1, i);
                }
                else if(dd[1][i] && !vis[1][i])
                {
                    vis[1][i] = 1;
                    sum += g[1][i]-1;
                }
                if(!dd[n][i] && !vis[n][i])
                {
                    vis[n][i] = 1;
                    sum += g[n][i];
                    dfs2(n, i);
                }
                else if(dd[n][i] && !vis[n][i])
                {
                    vis[n][i] = 1;
                    sum += g[n][i]-1;
                }
            }
          //  printf("%d\n",sum);
            if(sum%2)
                printf("Ali Win\n");
            else
                printf("Baba Win\n");
        }
    }
    return 0;
}



SD4101规格书
03-09
SD4101规格书,适应于SDIC mcu规格选型.带24位高精度ADC.
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
【标题】"HDU_2010.rar"是一个压缩包文件，其中包含了与"HDU 2010"相关的资源，特别是针对"HDU ACM20"比赛的编程题目。"hdu 2010"和"hdu 20"可能是该比赛的不同简称或分类，而"hdu acm20"可能指的是该赛事的第20届...
！HDU 4101 Ali and Baba-博弈-（bfs&dfs扫描二维点）
关于学习本身
07-24 988
题意：目标是拿到值为-1的宝石，但是前提是要有一条从二维格子外面到宝石的通路，如果没有就要每次选一个石头使它的值减1，直到石头的值为0则变为通路，能选这个石头的前提也是有一条格子外到该石头的通路，A和B开始游戏，两人轮流来，每次选一个石头，A先开始，求由输入的条件，谁能赢。 分析： 博弈问题，两人会把围住宝石的一圈石头外面的石头全部敲碎然后才选这一圈石头，所以就是计算这一圈石头外面的所有石头的
HDU4101:Ali and Baba(BFS)
ACM！荣耀之路！
12-13 1153
Problem Description There is a rectangle area (with N rows and M columns) in front of Ali and Baba, each grid might be one of the following: 1. Empty area, represented by an integer 0. 2. A Stone
HDU4101 Ali and Baba （bfs+dfs+博弈）
qwesde
08-03 794
题意： Ali 和Baba玩游戏，游戏是在给出的一个n*m的图中，有且仅有一个宝藏（-1）表示，图中其他位置可能是空地（0表示），也可能是石头（石头的HP用一个正数表示）。二人轮流，每次游戏开始都是Ali先手，选手可以攻击石头，每次可以让石头HP减少一。问Ali是否可以胜利。 开始时，直接BFS 宝藏能扩展的最大的面积，因为面对都是1包围的-1 ，这个是必败态。但是WA了；然后想了很久，想到，可能
hdu4101
黑历史
08-13 643
题意：给一个数字矩阵，-1代表宝藏，0代表通路，正整数代表格子内石头个数，每人每次可以从矩阵外围走到能到的地方拿走一颗石子，ali先取baba后取，取到宝藏就赢了，问谁能赢。 一开始连博弈都不知道多少就没往那方面想，很直观地分析了题意，就是要找包围着宝藏的一个石子边界，显然谁先破坏那个边界就输了。假如一开始就没有边界那也显然ali赢了，有边界就要算出边界外的石子的个数。 然后也是一开始
HDU 4101 Ali and Baba
苦鬼·。
08-18 355
Ali and Baba Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Problem Description There is a rectangle area (with N rows and M columns) in front of Ali and Baba, e
HDU 4101 bfs 简单博弈
weixin_42246923的博客
06-21 165
#include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &lt;queue&gt; #include &lt;cmath&gt; using namespace std; struct node{ int x,y; }; int dx[] = {0,0,1,-1}; int...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj
09-24
【标题】"hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj" 提供的信息是关于一个压缩文件，其中包含了一个名为 "HDU 1089.cpp" 的源代码文件，这个文件是为了解决杭州电子科技大学（Hangzhou Dianzi ...
HDU-2000-2099.rar_hdu
09-19
HDU（杭州电子科技大学在线评测系统）是一个知名的编程竞赛平台，为编程爱好者提供了大量的算法题目进行练习和比赛。这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
hdu 1272
xlc2845的专栏
10-06 1262
并查集  要判断这个图是连通的 就是只有一个父节点 #include #include #define maxn 100005 int fa[maxn]; bool ff[maxn]; int findd( int x ) { return fa[x] == x ? x : fa[x] = findd(fa[x]); } void init() { memset(ff,
hdu 4662
xlc2845的专栏
08-08 916
将U全部转化为I   因为 I 的个数一定是2的n次方  有可能消除了一定数量的 2U  所以I的个数加上一个6的整数倍是2的n次方 #include #include #include using namespace std; char a[1000010]; int b[40] = {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,1
hdu 1056
xlc2845的专栏
11-05 881
水题 ~~  按题目要求直接判断~。 /************************************************************************* > Author: xlc2845 > Mail: xlc2845@gmail.com > Created Time: 2013年11月05日 星期二 20时05分30秒 **
hdu 3778
xlc2845的专栏
08-12 851
简单的dfs  但繁琐的可以了 0.0 #include #include #include using std::sort; int n,m,cnt=0; struct team { char s[50]; int low,up,d,f; }; team a[30]; struct match { int x,y,re; bool operator < (con
hdu 1754 线段树入门
xlc2845的专栏
03-01 825
线段树点修改  区间最大值查询 #include #include #include #include #include #include #include #include #include #include #include #include #include #define maxn 200010 #define INF 0x7fffffff #define in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值