2015 多校第四场 Walk Out

最新推荐文章于 2025-08-05 19:50:13 发布

yusiningxin

最新推荐文章于 2025-08-05 19:50:13 发布

阅读量361

点赞数

CC 4.0 BY-SA版权

分类专栏：搜索文章标签： bfs dfs 算法

本文链接：https://blog.youkuaiyun.com/yusiningxin/article/details/47160031

搜索专栏收录该内容

2 篇文章

订阅专栏

本文深入探讨了使用深度优先搜索（DFS）和广度优先搜索（BFS）解决编程问题的方法，特别关注了如何在特定场景中避免栈溢出，并通过实例展示了在二维数组中寻找最远可达点的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

场上一直WA，场下清题又不停T，最后终于调好了，dfs过程中会爆栈，最后向右向下扫点的时候注意要标记，每个点只用加入一次不然会T。

总体思路就是：从（1，1）点开始dfs，只走0的位置，注意方向是上下左右，看能到达的最远点，将最远点做为新的起点，这时最小的二进制长度已经找到了。然后bfs，每次向右或者向下走，有0走0，各种情况都为1的时候才走1.

#pragma comment(linker, "/STACK:10240000000000,10240000000000")
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int MAXN=1100;
char mp[MAXN][MAXN];
int mark[MAXN][MAXN];
int n,m;

struct node
{
    int x,y;
    node(int a,int b)
    {
        x=a;
        y=b;
    }
};
vector <int> ans;
vector <node> zero;
vector <node> one;
queue <node> q;
int cnt;
bool ok (int x,int y)
{
    if(x>=1&&x<=n&&y>=1&&y<=m) return true;
    return false;
}
void dfs  (int x,int y)
{
    if(!ok(x,y)||mark[x][y]||mp[x][y]=='1') return ;
    mark[x][y]=1;
    if(x+y>cnt) cnt=x+y;
    dfs(x+1,y);
    dfs(x,y+1);
    dfs(x-1,y);
    dfs(x,y-1);
}
int main ()
{
    int t,x,y,flag;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1; i<=n; i++)
        {
            scanf("%s",mp[i]+1);
        }
        ans.clear();
        flag=0;
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=m; j++)
            {
                if(mp[i][j]=='1')
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag==0) printf("0\n");
        else
        {

            memset(mark,0,sizeof(mark));
            cnt=0;
            if(mp[1][1]=='1')
            {
                ans.push_back(1);
                q.push(node(1,1));
            }
            else
            {
                dfs(1,1);
                for(int i=1; i<=n; i++)
                {
                    for(int j=1; j<=m; j++)
                    {
                        if(mark[i][j]&&(i+j)==cnt)
                        {
                            q.push(node(i,j));
                        }
                    }
                }
            }

            while(true)
            {
                flag=0;
                zero.clear();
                one.clear();
                while(!q.empty())
                {
                    node index=q.front();
                    q.pop();
                    x=index.x;
                    y=index.y;
                    if(x==n&&y==m)
                    {
                        flag=1;
                        break;
                    }
                    if(ok(x+1,y)&&!mark[x+1][y]&&mp[x+1][y]=='0')
                    {
                        zero.push_back(node(x+1,y));
                        mark[x+1][y]=1;
                    }
                    if(ok(x,y+1)&&!mark[x][y+1]&&mp[x][y+1]=='0')
                    {
                        zero.push_back(node(x,y+1));
                        mark[x][y+1]=1;
                    }
                    if(ok(x+1,y)&&!mark[x+1][y]&&mp[x+1][y]=='1')
                    {
                        one.push_back(node(x+1,y));
                        mark[x+1][y]=1;
                    }
                    if(ok(x,y+1)&&!mark[x][y+1]&&mp[x][y+1]=='1')
                    {
                        one.push_back(node(x,y+1));
                        mark[x][y+1]=1;
                    }
                }
                if(flag==1) break;
                if(!zero.empty())
                {
                    ans.push_back(0);
                    for(int i=0; i<zero.size(); i++)
                    {
                        q.push(zero[i]);
                    }
                }
                else
                {
                    ans.push_back(1);
                    for(int i=0; i<one.size(); i++)
                    {
                        q.push(one[i]);
                    }
                }

            }
            if(ans.size()==0) printf("0\n");
            else
            {
                for(int i=0; i<ans.size(); i++)
                {
                    printf("%d",ans[i]);
                }
                printf("\n");
            }


        }

    }
    return 0;
}