POJ 3026 Borg Maze (BFS + MST) (陷阱题）

最新推荐文章于 2020-02-10 22:37:45 发布
最新推荐文章于 2020-02-10 22:37:45 发布
阅读量812 收藏
点赞数
分类专栏： ACM_Minimum_Spanning_Tree ACM_BFS POJ 文章标签： poj 3026 Disjoint Set kruskal MST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gatevin/article/details/24416759
版权


题目戳这里


题目大意 ： 给出测试数据组数 t ，接下来每组数据给出列数 n ，行数 m ，然后是一个n * m 的迷宫，#代表墙， S 为起始点，A 为外星人的位置，现在要求从S出发到达所有外星人的位置，而你自己有一个能力是可以再为 S 或 A 的位置分成多个组从不同的方向前进，要求找出最短的行走路线，其中要注意一个组分组前走过的路径只算一次，分组之后二者走过的路径长度分开算。输出最短的路径长度。


大致思路 ： 根据题意对于寻找外星人的小组每次只能在 A 或 S 出分组走不同路线，既然这样可以将 A 和 S 作为定点，将对应的顶点在迷宫中的最短，路径长度最为权值，生成一个图，现在就是你从这个图的一个顶点出发，选出一些边是的这些边形成的图的边权值和最小，且这个图覆盖到所有原来图的顶点，也就是找出这个图的最小生成树。

对于图形的边权值，用 bfs 算法找到对应的最短距离，对于所有的顶点对搜索之后形成一个图，用 Kruskal 算法找出最小生成树的权值和即可。


陷阱 ： POJ 对于此题给出的输入数据，在输入行数和列数之后会有一段空格，所以在读取行数和列数之后，不能用 getchar() 获取换行符后就开始读取#等字符，而应用gets()来终结掉前一行的结尾的干扰空格。

样例输入：

1

6 5        ← 这里有空格

##### 

#A#A##

# # A#

#S  ##

##### 


样例输出：

8


刚好这次复习Prim算法的时候有做了一次这一题，沿着上次的想法，吧之前的bfs处理的部分改进了一下(利用dx和dy数组使得代码简化)，同时在原来的Kruskal之后又重新用Prim算法做了一次，算是熟悉一下平常我用的比较少的Prim

代码如下：

Kruskal算法的方法：

Result  :  Accepted     Memory  :  340 KB     Time  :  32 ms

/*
 * Author: Gatevin
 * Created Time:  2014/7/17 10:08:49
 * File Name: test.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int T,row,col;
char maz[51][51];
char hehe[100];
int V,E;
int r[10000];
int u[10000];
int v[10000];
int w[10000];
int f[110];
int step[51][51];
int number[51][51];
int dx[5] = {0, 1, 0, 0, -1};
int dy[5] = {0, 0, -1, 1, 0};

queue <pair<int, int> > cord;

const int inf = 0x3f3f3f3f;

bool cmp(const int& i, const int& j)
{
    return w[i] < w[j];
}

int find(int i)
{
    if(i != f[i])
    {
        f[i] = find(f[i]);
    }
    return f[i];
}

int Kruskal()
{
    for(int i = 1; i <= E; i++) r[i] = i;
    for(int i = 1; i <= V; i++) f[i] = i;
    int answer = 0;
    sort(r + 1, r + E + 1, cmp);
    for(int i = 1; i <= E; i++)
    {
        int e = r[i];
        int rx = find(u[e]);
        int ry = find(v[e]);
        if(rx != ry)
        {
            answer += w[e];
            f[rx] = ry;
        }
    }
    return answer;
}

bool inMaze(int x, int y)
{
    if(x <= row && x >= 1 && y <= col && y >= 1)
    {
        return true;
    }
    else
    {
        return false;
    }
}


void bfs(int x, int y)
{
    while(!cord.empty())
    {
        cord.pop();
    }
    cord.push(make_pair(x, y));//当前入队的坐标
    for(int i = 1; i <= row; i++)
    {
        for(int j = 1; j <= col; j++)
        {
            step[i][j] = inf;
        }
    }
    step[x][y] = 0;
    while(!cord.empty())
    {
        pair <int, int> now = cord.front();
        cord.pop();
        for(int i = 1; i <= 4; i++)
        {
            if(inMaze(now.first + dx[i], now.second + dy[i]) && maz[now.first + dx[i]][now.second + dy[i]] != '#')
            {
                if(step[now.first + dx[i]][now.second + dy[i]] > step[now.first][now.second] + 1)//这里每个格子最多更新一次
                {
                    step[now.first + dx[i]][now.second + dy[i]] = step[now.first][now.second] + 1;
                    if(maz[now.first + dx[i]][now.second + dy[i]] != 'A' && maz[now.first + dx[i]][now.second + dy[i]] != 'S')//到达A或S就是端点了
                    {
                        cord.push(make_pair(now.first + dx[i], now.second + dy[i]));
                    }
                    else
                    {
                        E++;//建边
                        u[E] = number[x][y];
                        v[E] = number[now.first + dx[i]][now.second + dy[i]];
                        w[E] = step[now.first + dx[i]][now.second + dy[i]];
                    }
                }
            }
        }
    }
    return;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        E = 0;
        scanf("%d %d",&col,&row);
        memset(number, 0, sizeof(number));
        V = 0;
        for(int i = 1; i <= row; i++)
        {
            gets(hehe);
            for(int j = 1; j <= col; j++)
            {
                scanf("%c",&maz[i][j]);
                if(maz[i][j] == 'A' || maz[i][j] == 'S')
                {
                    V++;
                    number[i][j] = V;//给点编号
                }
            }
        }
        for(int i = 1; i <= row; i++)
        {
            for(int j = 1; j <= col; j++)
            {
                if(maz[i][j] == 'A' || maz[i][j] == 'S')
                {
                    bfs(i, j);//对于每个点都去找边
                }
            }
        }
        int answer = Kruskal();
        printf("%d\n",answer);
    }
    return 0;
}

Prim算法的做法：

Result  :  Accepted     Memory  :  268 KB     Time  :  32 ms

/*
 * Author: Gatevin
 * Created Time:  2014/7/17 10:08:49
 * File Name: test.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int T,row,col;
char maz[51][51];
char hehe[100];
int V;
int step[51][51];
int number[51][51];
int dx[5] = {0, 1, 0, 0, -1};
int dy[5] = {0, 0, -1, 1, 0};
queue <pair<int, int> > cord;
vector <pair<int, int> > g[110];
int dis[110];
bool vis[110];

const int inf = 0x3f3f3f3f;

bool inMaze(int x, int y)
{
    if(x <= row && x >= 1 && y <= col && y >= 1)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void bfs(int x, int y)
{
    while(!cord.empty())
    {
        cord.pop();
    }
    cord.push(make_pair(x, y));
    for(int i = 1; i <= row; i++)
    {
        for(int j = 1; j <= col; j++)
        {
            step[i][j] = inf;
        }
    }
    step[x][y] = 0;
    while(!cord.empty())
    {
        pair <int, int> now = cord.front();
        cord.pop();
        for(int i = 1; i <= 4; i++)
        {
            if(inMaze(now.first + dx[i], now.second + dy[i]) && maz[now.first + dx[i]][now.second + dy[i]] != '#')
            {
                if(step[now.first + dx[i]][now.second + dy[i]] > step[now.first][now.second] + 1)//每个格子最多更新一次
                {
                    step[now.first + dx[i]][now.second + dy[i]] = step[now.first][now.second] + 1;
                    if(maz[now.first + dx[i]][now.second + dy[i]] != 'A' && maz[now.first + dx[i]][now.second + dy[i]] != 'S')//到达顶点就不入队了
                    {
                        cord.push(make_pair(now.first + dx[i], now.second + dy[i]));
                    }
                    else
                    {
                        g[number[x][y]].push_back(make_pair(number[now.first + dx[i]][now.second + dy[i]], step[now.first + dx[i]][now.second + dy[i]]));
                    }//邻接表建图
                }
            }
        }
    }
    return;
}

int Prim()
{
    memset(vis, 0, sizeof(vis));
    fill(dis + 1, dis + V + 1, inf);
    dis[1] = 0;
    int ret = 0;
    for(int i = 1; i <= V; i++)
    {
        int mark = -1;
        for(int j = 1; j <= V; j++)
        {
            if(!vis[j])
            {
                if(mark == -1)
                {
                    mark = j;
                }
                else
                {
                    if(dis[mark] > dis[j])
                    {
                        mark = j;
                    }
                }
            }
        }
        if(mark == -1) break;
        vis[mark] = 1;
        ret += dis[mark];
        for(unsigned int j = 0; j < g[mark].size(); j++)
        {
            if(!vis[g[mark][j].first])
            {
                int x = g[mark][j].first;
                dis[x] = min(dis[x], g[mark][j].second);
            }
        }
    }
    return ret;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&col,&row);
        memset(number, 0, sizeof(number));
        V = 0;
        for(int i = 1; i <= row; i++)
        {
            gets(hehe);
            for(int j = 1; j <= col; j++)
            {
                scanf("%c",&maz[i][j]);
                if(maz[i][j] == 'A' || maz[i][j] == 'S')
                {
                    V++;
                    number[i][j] = V;
                }
            }
        }
        for(int i = 1; i <= row; i++)
        {
            for(int j = 1; j <= col; j++)
            {
                if(maz[i][j] == 'A' || maz[i][j] == 'S')
                {
                    bfs(i, j);//找边
                }
            }
        }
        int answer = Prim();
        printf("%d\n",answer);
        for(int i = 1; i <= V; i++)
        {
            if(!g[i].empty())
            {
                g[i].clear();
            }
        }
    }
    return 0;
}


Gatevin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
迷宫---DFS和BFS解法
DoubleCake的专栏
03-14 3786
题目描述 Description 在N*N的迷宫内，“#”为墙，“.”为路，“s”为起点，“e”为终点，一共4个方向可以走。从左上角（(0,0)“s”）位置处走到右下角（(n-1,n-1)“e”）位置处，可以走通则输出YES，不可以走则输出NO。 输入描述 Input Description 输入的第一行为一个整数m，表示迷宫的数量。  其后每个迷宫数据的第一行为一
POJ 3026 Borg Maze
旺崽的博客
09-18 2704
POJ 3026 Borg Maze Description The Borg is an immensely powerful race of enhanced humanoids from the delta quadrant of the galaxy. The Borg collective is the term used to describe the group consciousn...
挑战ACM迷宫（DFS or BFS+优先队列（A*））
Chien d'amis的博客
07-26 207
挑战ACM迷宫（DFS or BFS+优先队列（A*）） 题目描述 如下图所示的是一个由程序设计题目组成的ACM迷宫。迷宫的左上角是入口，右下角是出口。迷宫中每一个格子都有一个程序设计题目，挑战者要AC该题目后才能通过，大于0的数字表示AC该题目所需的最短时间。数字如果是0表示是陷阱，进去了就出不来。现在的问题是：求挑战者从入口到出口所需的最短时间。 输入 有多组测试实例。 对于每组测试实例，先...
坑爹的一个面试题，n多陷阱
zxiaoy的专栏
04-18 829
题目：字符串“324_fdaf_43j32_jfda_dfaklfalk_ww22”，找出其中用“_”线分割的，单个的纯字母的字符串中最长的一个。 亮点： 1.char类型可以直接强转为byte型 2.字母“a~z”在码表中是顺序排列的 3.里面针对每个字符串有两个条件需符合，1.纯字母 2.比现在找出的这个要长，显然2判断速度要快，所有把2判断放前面，不符合直接拍死，显著提高性能。
寻路问题--如何找到一条从起点坐标到终点坐标的路径？
weixin_30885111的博客
07-25 889
一，寻路问题介绍 正如组合问题与动态规划的联系之应用提到的从起点(0,0)到终点(X,Y)一共有多少种走法。与之相似的另一个问题是如何找到从(0,0)到(X,Y)的路径？ 首先对问题建模。使用一个矩阵(二维数组)的下标 表示 各个点的坐标。矩阵元素只取 0 或者 1，0 表示此坐标是一个可达的正常顶点；而 1 则表示这是一个不可达的障碍顶点。比如 如下矩阵： {0,0,1,1,0}{1,0,...
POJ3026-Borg Maze【BFS+Prim】
07-30
《POJ3026-Borg Maze：BFS与Prim算法的应用解析》 在计算机科学领域，图论是解决问题的重要工具之一，而BFS（广度优先搜索）和Prim算法则是其中的两种经典算法。本篇文章将围绕北大POJ3026题目“Borg Maze”来探讨...
POJ 3026 Borg Maze解题报告
11-30
业余爱好。所以，算法不一定好，CODING也不一定佳，效率不一定高，只是能通过online judge而已。
POJ1426-Find The Multiple【BFS+同余模】
07-31
【标题】"POJ1426-Find The Multiple【BFS+同余模】"是一道来源于北京大学在线编程平台POJ的算法题目，主要涉及到了广度优先搜索（BFS）与同余模运算的知识点。这道题目要求解决的是寻找一个整数的倍数问题，可能...
西北工业大学POJ试题C++答案代码+课程设计
05-11
"西北工业大学POJ试题C++答案代码+课程设计"这一标题表明了资源的主要内容，涉及两个核心部分：一是西北工业大学的编程竞赛（POJ，Problem Oriented Judge System）的C++解题代码，二是与这些题目相关的课程设计。...
深入探讨POJ 2312 Battle City 优先队列+BFS
12-31
相信坦克大战大家都玩过吧，本题就是根据这个游戏设计的。坦克要从起点（Y），到...本题可以使用改进过的广搜或优先队列＋bfs 或 记忆化广搜三种方法来解决。第一种方法：改进过的BFS：有些节点需要耗费2个单位时间，要
BFS——迷宫问题（求最短路）
biongbiongdou的博客
04-14 1738
题目：给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。限制条件;N, M ≤ 100Input：Output：22代码：// // main.cpp // BFS（迷宫问题自己写） // // Created by showlo on 2018/4/13. // Co...
猿辅导：迷宫（动态规划）
weixin_30763397的博客
08-05 827
题目描述 　　有一个N*M大小的迷宫矩阵，迷宫中的每个各自都有一个数值（R<10^9）。小猿在迷宫中发现，他只能朝着上下左右四个方向的相邻格子前进，并且只能进入比当前位置数值更大的格子。但是小猿有个紧急呼救按钮，它可以通过按下按钮，强行进入到不满足书纸大小要求的相邻格子，可惜这个按钮只能使用K次，请问小猿从这个迷宫任选一个格子出发，在紧急呼救按钮的帮助下，最多能走多少步？（开始位置计入步数...
POJ - 3026 Borg Maze解题报告（Kruskal+Bfs）
薛崇祥的博客
04-28 418
题目大意：多组测试实例（50），每组测试给你一个图（50*50），然后给你一个Ｓ点和若干个Ａ点（100）。一个小人从点S开始，他在S点或者A点可以分别成多个小人。现在他要访问到每个点，让你求出他要走的最少的距离。 注意： 只有当borg在S点或者找到一个alien之后，它们可以继续以分成若干的小队伍。 思路：只有在S和A可以分裂，这表示了什么？这表示这个图(无向)，每个顶点(A或S)可以有多个边！
题解 深搜 POJ 1321
weixin_30414245的博客
07-14 69
题意：在一张形状不规则的棋盘上（用#表示棋盘位置，. 表示非棋盘位置），要放置N个 棋子，且不同行不同列。问有几种放法？ 做法：首先做出正方形规则棋盘放个数为边长的棋子的算法， 再加上坐标为“#”才能放的限制， 最后在函数中增加一个没有回溯法的递归用于当棋子数量小于边长时。 代码： #include <iostream> #include <cst...
poj 3984 迷宫问题 【bfs + 路径记录】
longge33445的博客
08-10 429
迷宫问题 Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 11362   Accepted: 6796 Description 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0,
poj3026 Borg Maze
rookie_Algo的专栏
07-22 1221
这题的测试数据非常坑，一直WA，看了discuss才知道是因为，测试数据后面有还有空格，所以在输入x，y之后要加gets(temp),这道题的解决方法是，先用BFS在查找每两点之间的最短距离，构造出一幅无向图，然后再用prim算法，求出这幅图的最小生成树的权值和。还有一个要注意的地方就是，整个room是可以没有墙的，所以要加判断边界条件（我因此RE了几次）。 代码如下： #include
迷宫问题bfs， A Knight's Journey(dfs)
weixin_34026276的博客
02-26 81
迷宫问题（bfs） POJ - 3984 1 #include <iostream> 2 #include <queue> 3 #include <stack> 4 #include <cstring> 5 6 using namespace std; 7 8 /*广度优...
程序设计--迷宫问题
Joe_c 的专栏
01-27 4712
问题描述：给定一个大小为N*M的迷宫。迷宫有通道和墙壁组成，每一步可以向邻接的上下左右的通道移动。请求出从起点到终点所需要的最小步数。        例如，N为10， M为10，输入的迷宫如下表示，其中S表示起点，G表示终点，"."表示通道，“#”表示墙壁                    #S######.# ......#..# .#.##.##.# .#.....
hdu1078——FatMouse and Cheese（dfs+dp）
weixin_43719720的博客
02-10 134
题目：click me~ 题意： 在n*n的矩阵中，FatMouse从（0，0）出发，每次只能走上下左右四个方向，一步最多k格，而且跳到下一格必须满足条件：下一格的奶酪>本格的奶酪。要求能吃到的最大奶酪数。 解题思路： 用dp配合dfs来实现，dp[i][j]表示从（i，j）格出发能够吃到的最大奶酪数，整体还是用dfs来操作，套两层循环，第一层表四个方向，第二层表总共走几格。 co...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值