jzoj 5781 秘密通道

最新推荐文章于 2022-10-30 18:00:00 发布

Stupid_Computer

最新推荐文章于 2022-10-30 18:00:00 发布

阅读量376

点赞数

CC 4.0 BY-SA版权

分类专栏：图论搜索文章标签：刷题之路

本文链接：https://blog.youkuaiyun.com/qq_41709770/article/details/81515870

搜索同时被 2 个专栏收录

12 篇文章

订阅专栏

图论

8 篇文章

订阅专栏

本文介绍了一种使用图论解决迷宫寻路问题的方法，通过建立节点和边的模型，利用SPFA算法找到从起点到终点的最短路径。文章详细解释了如何将迷宫转换为图，并介绍了寻找最近墙壁距离的技巧。

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

题目

这里写图片描述

题解

–开始一看，这不是走迷宫吗，那就是bfs呀，当然是快乐gg了
谁能想到这是一道图论题呢（反正不是本蒟蒻）
我们把每个空位和上下左右连一条长为1的边
和上下左右的第一堵墙连一条长为与最近的墙的距离的边
然后从起点开始，跑一遍spfa就行了

细节问题不一定相同
像找最近的墙时
可以bfs
也可以和我一样找菱形

要看代码能力呢

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=505;

int n,m;
char g[MAXN][MAXN];
int G[MAXN][MAXN];
int node;
int begin,end;

struct hehe{
    int u;
    int v;
    int l;
}edge[MAXN*MAXN*8];
int e;

vector<int>a[MAXN*MAXN];

queue<int>q;
bool isv[MAXN*MAXN];
int d[MAXN*MAXN];

int  near(int x,int y){
    int X=x,Y=y,step=0;
    while(g[X][Y]!='#'){
        step++;
        X--;
        while(X!=x){
            if(g[X][Y]=='#')
                return step;
            X++;
            Y--;
        }
        while(Y!=y){
            if(g[X][Y]=='#')
                return step;
            X++;
            Y++;
        }
        while(X!=x){
            if(g[X][Y]=='#')
                return step;
            X--;
            Y++;
        }
        while(Y!=y){
            if(g[X][Y]=='#')
                return step;
            X--;
            Y--;
        }
    }
    return step;
}

void lb(int x,int y){
    int u=G[x][y];
    if(g[x-1][y]!='#'){
        int v=G[x-1][y];
        e++;
        edge[e].u=u;
        edge[e].v=v;
        edge[e].l=1;
        a[u].push_back(e);
    }
    if(g[x+1][y]!='#'){
        int v=G[x+1][y];
        e++;
        edge[e].u=u;
        edge[e].v=v;
        edge[e].l=1;
        a[u].push_back(e);
    }
    if(g[x][y-1]!='#'){
        int v=G[x][y-1];
        e++;
        edge[e].u=u;
        edge[e].v=v;
        edge[e].l=1;
        a[u].push_back(e);
    }
    if(g[x][y+1]!='#'){
        int v=G[x][y+1];
        e++;
        edge[e].u=u;
        edge[e].v=v;
        edge[e].l=1;
        a[u].push_back(e);
    }

    int l=near(x,y);
    int X=x,Y=y;
    while(g[X][Y]!='#')
        X--;
    X++;
    int v=G[X][Y];
    e++;
    edge[e].u=u;
    edge[e].v=v;
    edge[e].l=l;
    a[u].push_back(e);

    X=x,Y=y;
    while(g[X][Y]!='#')
        X++;
    X--;
    v=G[X][Y];
    e++;
    edge[e].u=u;
    edge[e].v=v;
    edge[e].l=l;
    a[u].push_back(e);

    X=x,Y=y;
    while(g[X][Y]!='#')
        Y--;
    Y++;
    v=G[X][Y];
    e++;
    edge[e].u=u;
    edge[e].v=v;
    edge[e].l=l;
    a[u].push_back(e);

    X=x,Y=y;
    while(g[X][Y]!='#')
        Y++;
    Y--;
    v=G[X][Y];
    e++;
    edge[e].u=u;
    edge[e].v=v;
    edge[e].l=l;
    a[u].push_back(e);
}

void spfa(){
    memset(d,0x3f3f3f3f,sizeof(d));
    d[begin]=0;
    isv[begin]=1;
    q.push(begin);
    while(q.size()){
        int u=q.front();
        q.pop();
        isv[u]=0;
        for(int i=0;i<a[u].size();i++){
            int x=a[u][i];
            int v=edge[x].v,l=edge[x].l;
            if(d[v]>d[u]+l){
                d[v]=d[u]+l;
                if(!isv[v]){
                    isv[v]=1;
                    q.push(v);
                }
            }
        }
    }
}

int main(){
    freopen("portal.in","r",stdin);
    freopen("portal.out","w",stdout);
    cin>>n>>m;
    if(!n||!m)
        return 0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            cin>>g[i][j];
            if(g[i][j]!='#')
                G[i][j]=++node;
            if(g[i][j]=='C')
                begin=node;
            if(g[i][j]=='F')
                end=node;
        }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(g[i][j]!='#')
                lb(i,j);
    spfa();
    if(d[end]==0x3f3f3f3f)
        cout<<"nemoguce";
    else
        cout<<d[end];
    return 0;
}