uva 1601（单向bfs 双向bus 矩阵转图）

最新推荐文章于 2021-03-22 20:56:43 发布
最新推荐文章于 2021-03-22 20:56:43 发布
阅读量139 收藏
点赞数
分类专栏： 紫书 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43763889/article/details/103683998
版权

题意

在这里插入图片描述
在这里插入图片描述
不能走到一起，或者穿着走，

将矩阵转化成图，双向比单向优化300+ms

单向bfs

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

char l[20][20];
int num[20][20],g[200][6],vis[200][200][200],s[26],t[26];

struct node
{
    int a,b,c;
    int cnt;
    node(){};
    node(int a,int b,int c,int cnt): a(a),b(b),c(c),cnt(cnt){}
};

void bfs()
{
    int a1,b1,c1;
    memset(vis,0,sizeof vis);
    vis[s[0]][s[1]][s[2]] = 1;
    queue<node> q;
    node e;
    e.a = s[0],e.b = s[1],e.c = s[2],e.cnt = 0;
    q.push(e);
    while(!q.empty()){
        e = q.front();q.pop();
        if(e.a == t[0] && e.b == t[1] && e.c == t[2]){
            cout << e.cnt << endl;
            return ;
        }
        for(int i = 0 ; i <= g[e.a][0];i++){
            a1 = (i == 0 ? e.a:g[e.a][i]); //0的时候原地不动
            for(int j = 0 ; j <= g[e.b][0];j++){
                b1 = (j == 0 ? e.b:g[e.b][j]);
                for(int k = 0 ; k <= g[e.c][0];k++){
                    c1 = (k == 0 ? e.c:g[e.c][k]);
                    if(vis[a1][b1][c1]) continue;
                    //不能在同一个点上
                    if((a1 && b1 && a1 == b1) || (a1 && c1 && a1 == c1) || (b1 && c1 && b1 == c1)) continue;
                    //不能穿过字母走
                    if(a1 && b1 && a1 == e.b && b1 == e.a) continue;
                    if(a1 && c1 && a1 == e.c && c1 == e.a) continue;
                    if(b1 && c1 && b1 == e.c && c1 == e.b) continue;

                    vis[a1][b1][c1] = 1;
                    q.push(node(a1,b1,c1,e.cnt+1));
                }
            }
        }
    }
}

int main()
{
    int w,h,n;
    while(cin >> w >> h >> n && w + h + n){
        getchar();
        for(int i = 0 ; i < h ; i++){
            fgets(l[i],20,stdin);
        }

        //建图
        //给图中的空白处编号
        memset(num,0,sizeof num);
        int cnt = 0;
        for(int i = 0 ; i < h ; i++)
            for(int j = 0 ; j < w ; j++)
                if(l[i][j] != '#')
                    num[i][j] = ++cnt;
        //邻接表存图
        memset(g,0,sizeof g);
        for(int i = 0 ; i < h ; i++){
            for(int j = 0 ; j < w ; j++){
                if(num[i][j]){
                    int pos = num[i][j];
                    if(num[i+1][j]) g[pos][++g[pos][0]] = num[i+1][j];
                    if(num[i-1][j]) g[pos][++g[pos][0]] = num[i-1][j];
                    if(num[i][j+1]) g[pos][++g[pos][0]] = num[i][j+1];
                    if(num[i][j-1]) g[pos][++g[pos][0]] = num[i][j-1];
                }
            }
        }

        //找到初始状态和最终状态
        memset(s,0,sizeof s);
        memset(t,0,sizeof t);
        for(int i = 0 ; i < h ; i++){
            for(int j = 0 ; j < w ; j++){
                if(islower(l[i][j])) s[l[i][j] - 'a'] = num[i][j];
                else if(isupper(l[i][j])) t[l[i][j] - 'A'] = num[i][j];
            }
        }
        int m = 0;
        for(int i = 0 ; i < 26 ; i++){
            if(s[i]) s[m] = s[i],t[m++]=t[i];
        }
        if(n < 3) s[2] = 0,t[2] = 0;
        if(n < 2) s[1] = 0,t[1] = 0;

        bfs();

    }

    return 0;
}

双向bfs

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

char l[20][20];
int num[20][20],g[200][6],s[26],t[26];
int vis[200][200][200],vis1[200][200][200];

struct node
{
    int a,b,c;
    int cnt;
    node(){};
    node(int a,int b,int c,int cnt): a(a),b(b),c(c),cnt(cnt){}
};

void bfs()
{
    int a1,b1,c1;
    memset(vis,0,sizeof vis);
    memset(vis1,0,sizeof vis1);
    vis[s[0]][s[1]][s[2]] = 1;
    vis1[t[0]][t[1]][t[2]] = 1;
    queue<node> q;
    queue<node> w;
    node e,r;
    q.push(node(s[0],s[1],s[2],1));
    w.push(node(t[0],t[1],t[2],1));
    while(!q.empty() && !w.empty()){
        e = q.front();q.pop();
        r = w.front();w.pop();
        if(vis[r.a][r.b][r.c]){
            cout << vis1[r.a][r.b][r.c] + vis[r.a][r.b][r.c] - 2 << endl;
            return ;
        }
        else if(vis1[e.a][e.b][e.c]){
            cout << vis1[e.a][e.b][e.c] + vis[e.a][e.b][e.c] - 2<< endl;
            return;
        }

        for(int i = 0 ; i <= g[e.a][0];i++){
            a1 = (i == 0 ? e.a:g[e.a][i]); //0的时候原地不动
            for(int j = 0 ; j <= g[e.b][0];j++){
                b1 = (j == 0 ? e.b:g[e.b][j]);
                for(int k = 0 ; k <= g[e.c][0];k++){
                    c1 = (k == 0 ? e.c:g[e.c][k]);
                    if(vis[a1][b1][c1]) continue;
                    //不能在同一个点上
                    if((a1 && b1 && a1 == b1) || (a1 && c1 && a1 == c1) || (b1 && c1 && b1 == c1)) continue;
                    //不能穿过字母走
                    if(a1 && b1 && a1 == e.b && b1 == e.a) continue;
                    if(a1 && c1 && a1 == e.c && c1 == e.a) continue;
                    if(b1 && c1 && b1 == e.c && c1 == e.b) continue;

                    vis[a1][b1][c1] = e.cnt+1;
                    q.push(node(a1,b1,c1,e.cnt+1));
                }
            }
        }

        for(int i = 0 ; i <= g[r.a][0];i++){
            a1 = (i == 0 ? r.a:g[r.a][i]); //0的时候原地不动
            for(int j = 0 ; j <= g[r.b][0];j++){
                b1 = (j == 0 ? r.b:g[r.b][j]);
                for(int k = 0 ; k <= g[r.c][0];k++){
                    c1 = (k == 0 ? r.c:g[r.c][k]);
                    if(vis1[a1][b1][c1]) continue;
                    //不能在同一个点上
                    if((a1 && b1 && a1 == b1) || (a1 && c1 && a1 == c1) || (b1 && c1 && b1 == c1)) continue;
                    //不能穿过字母走
                    if(a1 && b1 && a1 == r.b && b1 == r.a) continue;
                    if(a1 && c1 && a1 == r.c && c1 == r.a) continue;
                    if(b1 && c1 && b1 == r.c && c1 == r.b) continue;

                    vis1[a1][b1][c1] = r.cnt+1;
                    w.push(node(a1,b1,c1,r.cnt+1));
                }
            }
        }
    }
}

int main()
{
    int w,h,n;
    while(cin >> w >> h >> n && w + h + n){
        getchar();
        for(int i = 0 ; i < h ; i++){
            fgets(l[i],20,stdin);
        }

        //建图
        //给图中的空白处编号
        memset(num,0,sizeof num);
        int cnt = 0;
        for(int i = 0 ; i < h ; i++)
            for(int j = 0 ; j < w ; j++)
                if(l[i][j] != '#')
                    num[i][j] = ++cnt;
        //邻接表存图
        memset(g,0,sizeof g);
        for(int i = 0 ; i < h ; i++){
            for(int j = 0 ; j < w ; j++){
                if(num[i][j]){
                    int pos = num[i][j];
                    if(num[i+1][j]) g[pos][++g[pos][0]] = num[i+1][j];
                    if(num[i-1][j]) g[pos][++g[pos][0]] = num[i-1][j];
                    if(num[i][j+1]) g[pos][++g[pos][0]] = num[i][j+1];
                    if(num[i][j-1]) g[pos][++g[pos][0]] = num[i][j-1];
                }
            }
        }

        //找到初始状态和最终状态
        memset(s,0,sizeof s);
        memset(t,0,sizeof t);
        for(int i = 0 ; i < h ; i++){
            for(int j = 0 ; j < w ; j++){
                if(islower(l[i][j])) s[l[i][j] - 'a'] = num[i][j];
                else if(isupper(l[i][j])) t[l[i][j] - 'A'] = num[i][j];
            }
        }
        int m = 0;
        for(int i = 0 ; i < 26 ; i++){
            if(s[i]) s[m] = s[i],t[m++]=t[i];
        }
        if(n < 3) s[2] = 0,t[2] = 0;
        if(n < 2) s[1] = 0,t[1] = 0;

        bfs();

    }

    return 0;
}
weixin_43763889
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uva1601（双向BFS经典题）
林伏案的博客
05-15 5377
题目描述：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51163 首先用单向BFS解决，代码如下。最后在单向基础上改进成双向单向：/* solution: 还是隐式图搜索问题，类似dijkstra，用bfs解决，这个是单向搜索，弊端是有时候随着搜索 的深入，可扩展的结点会越来越多，造成效率变慢，用双向bfs
UVA 1601 The Morning after Halloween - Japan 2007
Napoleon2004的博客
04-03 290
#include&lt;bits/stdc++.h&gt; using namespace std; struct node{ int x[4],y[4],index; }f[5000000]; struct node2{ int x,y; }tar[4]; int k,head,tail,n,m,a[17][17],b[17][17],c[17][17][5],mp[17][17][17][...
UVa1601
weixin_30894583的博客
06-13 161
---恢复内容开始--- 这道题的题解很多，所以就不用说明了。 下面便是单dfs与双dfs的代码 900ms // UVa 1601 // bfs（原始） #include <cstdio> #include <cstring> #include <cctype> #include <queue> using nam...
uva 1601（The morning after Halloween ,Japan 2007, UVa 1601）
qq_25974431的博客
07-19 250
文章出处：http://blog.csdn.net/loveyou11111111/article/details/48879167 第一，将有用的空格编码成1-256之间的整数，节省了存储空间 第二，将每个状态用一个int型进行编码，很巧妙#include #include #include #include #include using namespace std;
UVA - 1601(双向BFS)
playwfun的专栏
10-10 2271
使用双向BFS最大的优点在于
图的BFS（邻接矩阵、邻接表版）
01-07
BFS(u){ queue q; 将u入队; inq[u] = true; //设置u已被加入过队列 while(q非空){ 取出q的队首元素u进行访问; for(从u出发可达到的所有顶点v){ if(inq[v] == false ){ 将v入队; inq[v] = true; ...
BFS-邻接矩阵.cpp
最新发布
06-14
BFS-邻接矩阵.cpp
魔方-BFS-输入_魔方bfs_魔方降群法+双向bfs_魔方降群_
09-29
在IT领域，尤其是在算法和计算机科学中，"魔方-BFS-输入_魔方bfs_魔方降群法+双向bfs_魔方降群_"这个标题涉及到的是使用广度优先搜索（Breadth First Search, BFS）解决魔方问题的高级技巧。魔方是一种三维旋转拼图...
DFS_BFS.zip_邻接矩阵_邻接矩阵结构
09-23
在提供的文件"DFS_BFS.c"中，我们可以预见到它包含了C语言实现的DFS和BFS算法，使用邻接矩阵作为图的表示。学习这个代码可以帮助我们更好地理解这两种搜索算法在实际编程中的应用，以及如何优化内存和时间效率。通过...
BFS.zip_Bfs算法_图BFS算法
09-19
**BFS算法详解** 在计算机科学中，图遍历是一种重要的算法，用于探索图的...对于给定的"BFS.zip_Bfs算法_图Bfs算法"文件，其内容可能包含了一个具体的BFS算法实现或相关练习，用于帮助学习者理解和掌握这一重要算法。
搜索好题UVA1601
weixin_30606669的博客
04-26 81
题目 分析:如果以当前3个小写字母的位置为状态，则问题转化为图上的最短路问题。但是如果每次都判断小写字母的下一步是否合法，那就是说每次移动都需要判断5^3,肯定会超时。可以把所有可以移动的格子找出来建立一张图，就是把障碍物给删除，统计每个可以空格或者有鬼的格子可以移动到哪些格子，这样在判断的时候就节省了许多时间。然后bfs找最短路。注意读入的时候要多读入一个换行符，因为scanf的缓冲区用完以后...
uva 1601 The Morning after Halloween
iwi
08-18 509
题目：The Morning after Halloween 题意：有n个用小写字母表示的鬼和一张地图，每个鬼都要移动到对应的大写字母，两个鬼的位置不能在一次移动中交换，问最少步数。 思路： bfs。 1、先将地图用图的方法表示，即在每一个空白（包括大小写字母）和四周的空白连上一条边，用单个整数表示一个空白。 2、在图上进行bfs。注意只有一个鬼的情况，此时鬼b和鬼c所在
UVA1601 The Morning after Halloween
polarday的博客
03-22 103
UVA1601 The Morning after Halloween 题目链接 做这道题的时候看到一个写的很好的代码，在这里保存下来，以便以后学习。 题目分析 这道题和普通的bfs有所不同，解题方法也有些差别，主要是这里有三个移动的“小鬼”，每个小鬼有五种移动状态（上下左右和不动），最主要的是可以看出在地图上大部分的点都是障碍物，所以可以把所有的空格都提出来建立一张图，而不必每次判断五种方法是否合法，以此来优化算法。 代码解析 本题代码中用到的变量较多，为便于理解，先把主要变量的含义解释一下。 x[i]
UVa1601 - The Morning after Halloween(单向+双向BFS)
Dosth_Magic
04-29 941
给出一个最大为16×16的迷宫图和至多3个ghost的起始位置和目标位置，求最少经过几轮移动可以使三个ghost都到达目标位置。每轮移动中，每个ghost可以走一步，也可以原地不动，需要注意的是任意两个ghost不能在相同的位置，因此也不能出现任意两个ghost对穿，也就是原来是ab，移动之后是ba。每个迷宫图'#'表示墙，' '表示空地，小写字母表示ghost的起始位置，大写字母表示对应ghos
UVA1601：单向BFS
FlyingJack
02-17 161
题解：这一题收获很大，参考了刘汝佳的代码。很多细节处理的都很不错。我用的是单向BFS。注释在代码里。花一点时间细心的看，还是能看懂的。 代码： #include <bits/stdc++.h> #define ft first #define sd second using namespace std; typedef pair<int,int>pii; int co...
UVA1601 The Morning after Halloween（双向BFS）
hao_6_6的博客
08-13 137
title: “UVA1601” date: 2020-08-10T17:00:48+08:00 draft: true tags: [“题解”, “BFS”, “状态图”, “双BFS”] description: “description.” 本题vjudge链接 题意：给你一个图，"#“为障碍物，” "为通路，图里面最多有3个小写字母（a, b, c）和于其对应的大写字母（A, B, C），每次移动每个小写字母都有4个方向和不动5种方案，一次移动可以有多个小写字母一起移动，不能一个空格点不能同时有.
Uva1601双向BFS
LjcoderDCC的博客
06-27 379
//双向BFS #include #include #include #include #include using namespace std; const int N = 20; const int maxn = 200; const int dx[] = {1,0,-1,0,0}; const int dy[] = {0,-1,0,1,0}; int n,m,k; char maze
UVA1601-The Morning after Halloween（双向BFS）
weixin_30340353的博客
08-27 83
ProblemUVA1601-The Morning after Halloween Accept: 289 Submit: 3136 Time Limit: 12000 mSec Problem Description Input Output For each dataset in the input, one lin...
UVA 1601 The Morning after Halloween (BFS/双向BFS)
Insist_77的博客
02-18 192
单向BFS 1150ms #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;cmath&gt; #include &lt;algorithm&gt; #include &lt;map&gt; #include &lt;vector&gt; #include &amp
图的BFS使用邻接矩阵使用队列模板实现
05-04
以下是使用邻接矩阵和队列模板实现BFS的代码： ```cpp #include <iostream> #include <queue> using namespace std; const int MAXN = 100; // 最大节点数 int G[MAXN][MAXN]; // 存储邻接矩阵 bool vis[MAXN]; // 记录节点是否被访问过 void bfs(int s, int n) // s为起点，n为节点数 { queue<int> q; // 定义队列 q.push(s); // 起点入队 vis[s] = true; // 标记起点已访问 while (!q.empty()) { int u = q.front(); // 取出队首节点 q.pop(); // 弹出队首节点 cout << u << " "; // 访问节点 for (int v = 0; v < n; v++) // 遍历与u相邻的节点 { if (G[u][v] && !vis[v]) // 如果v与u相邻且未被访问过 { q.push(v); // v入队 vis[v] = true; // 标记v已访问 } } } } int main() { int n, m; // n为节点数，m为边数 cin >> n >> m; // 读入边并建立邻接矩阵 for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; G[u][v] = G[v][u] = 1; // 无向图 } bfs(0, n); // 从节点0开始BFS return 0; } ``` 其中，`vis`数组用于记录节点是否被访问过，初始值为`false`。队列`q`用于存储需要遍历的节点，初始时将起点`s`入队，然后进行循环，每次取出队首节点`u`，访问它，然后遍历与它相邻的节点`v`，如果`v`未被访问过，则将其入队，并标记为已访问。循环结束后，BFS遍历就完成了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值