洛谷题单搜索 [USACO11OPEN] Corn Maze S

最新推荐文章于 2025-03-31 21:30:01 发布

原创最新推荐文章于 2025-03-31 21:30:01 发布 · 278 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #图论

文章讲述了如何在包含传送门的二维网格环境中使用BFS算法求解路径，强调了穿越传送门的规则和代码中处理传送门逻辑的改进。作者分享了原始思路和优化后的代码片段，以确保路径不被堵塞并正确处理跨过传送门的情况。

该题若是去掉传送门这个设定就是普通的bfs版题，但加上了传送门，要考虑的地方就变多了，坑也变多了，总结了该题的几个坑

1，经过传送门门时，必须要传送，想要跨过传送门的话，需要先传送再随便走一步在回到原来的传送门，这样才能达到跨过传送门的目的。

2，传送门被墙围着，该情况无解

最初的思路时预处理传送门的位置，通过start数组和over数组记录该传送门的位置，但该题数据量不大，所以可以使用两个for循环暴力搜索另一个传送门的位置，如下：

void change(int &nx,int &ny,int t)//传入地址，以便在函数中直接修改x，y的值
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(ch[i][j]==ch[nx][ny]&&(i!=nx||j!=ny))
            {
                nx=i;
                ny=j;
                return;
            }
        }
    }
}

第一版代码：

#include<iostream>
#include<cstring>
#include<queue>
#define f first
#define s second
using namespace std;
typedef pair<int,int> pll;
const int N = 1010;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int n,m;
char g[N][N];
bool st[N];
int dis[N][N];
pll start[N],over[N];
int aa,bb;//起点坐标
int aaa,bbb;//终点坐标
queue<pll> q;


void bfs()
{
    q.push({aa,bb});
    dis[aa][bb]=0;
    while(!q.empty())
    {
        auto r=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int x=r.f+dx[i],y=r.s+dy[i];
            if(x>0&&x<=n&&y>0&&y<=m&&dis[x][y]==-1&&g[x][y]!='#')
            {
                if(g[x][y]=='.')
                {
                    q.push({x,y});
                    dis[x][y]=dis[r.f][r.s]+1;
                }
                else if(g[x][y]=='=')
                {
                    aaa=x;
                    bbb=y;
                    q.push({x,y});
                    dis[x][y]=dis[r.f][r.s]+1;
                }
                else
                {
                    //cout<<"!!!";
                    int z=g[x][y]-'A';
                    if(start[z].f==x&&start[z].s==y)
                    {
                        dis[x][y]=dis[r.f][r.s]+1;
                        x=over[z].f,y=over[z].s;
                        q.push({x,y});
                        dis[x][y]=dis[r.f][r.s]+1;
                    }
                    else
                    {
                        dis[x][y]=dis[r.f][r.s]+1;
                        x=start[z].f,y=start[z].s;
                        q.push({x,y});
                        dis[x][y]=dis[r.f][r.s]+1;
                    }
                }
            }
        }
    }
}


int main()
{
    memset(dis,-1,sizeof dis);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>g[i][j];
            if(g[i][j]=='@') aa=i,bb=j;
            else if(g[i][j]=='=') aaa=i,bbb=j;
            else if(g[i][j]>='A'&&g[i][j]<='Z')
            {
                int x=g[i][j]-'A';
                if(st[x]==false)
                {
                    start[x].f=i;
                    start[x].s=j;
                    st[x]=true;
                }
                else
                {
                    over[x].f=i;
                    over[x].s=j;
                    st[x]=true;
                }
            }
        }
    }
    /*int ans=0;
    for(int i=0;i<26;i++)
    {
        cout<<start[i].f<<" "<<start[i].s<<endl;
        cout<<over[i].f<<" "<<over[i].s<<endl;
        ans++;
    }
    cout<<"!!!"<<ans;*/
    bfs();
    /*for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cout<<dis[i][j]<<' ';
        }
        cout<<endl;
    }*/
    
    cout<<dis[aaa][bbb];
    return 0;
}

该代码未考虑到跨过传送门的情况，看了洛谷的题解，学会了一位大佬的方法，如下：

#include<iostream>
#include<queue>
using namespace std;
const int N = 1010;

struct point
{
    int x,y,t;
};//t表示该点距离起点的最短距离

queue<point> q;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int n,m;
char ch[N][N];
bool st[N][N];//检查该点是否走过
int aa,bb;//起点坐标

void change(int &nx,int &ny,int t)//传入地址，以便在函数中直接修改x，y的值
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(ch[i][j]==ch[nx][ny]&&(i!=nx||j!=ny))
            {
                nx=i;
                ny=j;
                return;
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    string s;
    for(int i=1;i<=n;i++)
    {
        cin>>s;
        for(int j=1;j<=m;j++)
        {
            ch[i][j]=s[j-1];
            if(ch[i][j]=='@')//找到起点
            {
                aa=i;
                bb=j;
            }
        }
    }
    st[aa][bb]=true;
    //cout<<aa<<' '<<bb;
    q.push((point){aa,bb,0});//从起点开始查找
    while(!q.empty())
    {
        point r=q.front();
        q.pop();
        if(ch[r.x][r.y]=='=')//找到终点时直接结束
        {
            cout<<r.t;
            return 0;
        }
        if(ch[r.x][r.y]>='A'&&ch[r.x][r.y]<='Z')//
        {
            change(r.x,r.y,r.t);
        }
        for(int i=0;i<=3;i++)
        {
            int nx=r.x+dx[i];
            int ny=r.y+dy[i];
            if(nx>=1&&nx<=n&&ny>=1&&ny<=m&&ch[nx][ny]!='#'&&!st[nx][ny])
            {
                st[nx][ny]=true;
                q.push((point){nx,ny,r.t+1});
            }
        }
    }
    return 0;
}

该代码每次都碰到传送门时，不会将传送门标记，而是将周围的放入队列，再将周围的点打上标记，这样出力就不会让回去的路给堵死，这样若回去的时候传送门周围还有路走，就会继续走下去，该代码真的开阔了我这个小白的思路，tql