百练 4116 拯救行动(bfs)

最新推荐文章于 2020-03-15 16:55:51 发布
最新推荐文章于 2020-03-15 16:55:51 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： BFS|| DFS 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sUb_569/article/details/53450388
版权

描述

公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M (N, M <= 200)的矩阵来表示。矩阵中的每项可以代表道路（@）、墙壁（#）、和守卫（x）。
英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是“骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。
现假设骑士可以向上、下、左、右四个方向移动，每移动一个位置需要1个单位时间，杀死一个守卫需要花费额外的1个单位时间。同时假设骑士足够强壮，有能力杀死所有的守卫。

给定牢房矩阵，公主、骑士和守卫在矩阵中的位置，请你计算拯救行动成功需要花费最短时间。

输入
第一行为一个整数S，表示输入的数据的组数（多组输入）
随后有S组数据，每组数据按如下格式输入
1、两个整数代表N和M, (N, M <= 200).
2、随后N行，每行有M个字符。”@”代表道路，”a”代表公主，”r”代表骑士，”x”代表守卫, “#”代表墙壁。
输出
如果拯救行动成功，输出一个整数，表示行动的最短时间。
如果不可能成功，输出”Impossible”
样例输入

2
7 8
#@#####@
#@a#@@r@
#@@#x@@@
@@#@@#@#
#@@@##@@
@#@@@@@@
@@@@@@@@ 
13 40
@x@@##x@#x@x#xxxx##@#x@x@@#x#@#x#@@x@#@x
xx###x@x#@@##xx@@@#@x@@#x@xxx@@#x@#x@@x@
#@x#@x#x#@@##@@x#@xx#xxx@@x##@@@#@x@@x@x
@##x@@@x#xx#@@#xxxx#@@x@x@#@x@@@x@#@#x@#
@#xxxxx##@@x##x@xxx@@#x@x####@@@x#x##@#@
#xxx#@#x##xxxx@@#xx@@@x@xxx#@#xxx@x#####
#x@xxxx#@x@@@@##@x#xx#xxx@#xx#@#####x#@x
xx##@#@x##x##x#@x#@a#xx@##@#@##xx@#@@x@x
x#x#@x@#x#@##@xrx@x#xxxx@##x##xx#@#x@xx@
#x@@#@###x##x@x#@@#@@x@x@@xx@@@@##@@x@@x
x#xx@x###@xxx#@#x#@@###@#@##@x#@x@#@@#@@
#@#x@x#x#x###@x@@xxx####x@x##@x####xx#@x
#x#@x#x######@@#x@#xxxx#xx@@@#xx#x#####@

样例输出

13
7

思路
这道题用普通bfs可以过样例,但是提交过不了,这道题是看了别人代码做的,
有两种方法.
一种是用priority_queue 做（暂时不太懂）
另一种方法是拆点
拆点就是对于 ‘x’ ，它的扩展要分两次：
对于(‘x’,0) ，它只能扩展出 ( ‘x’ , 1 )
对于(‘x’,1) , 它可以往四个方向扩展.
第一种 priority_queue

/*************************************************************************
    > File Name: bl4116.cpp
    > Author:ukiy 
    > Mail: 
    > Created Time: 2016年12月03日 星期六 22时34分06秒
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<string>
#include<cstring>
#include<vector>
#include<set>
#include<list>
#include<map>
#include<queue>
int dire[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };
int dire2[8][2]={{-1,-1},{-1,0},{-1,1},{ 0,-1},{ 0,1},{ 1,-1},{ 1,0},{ 1,1}};
#define rep(i,a,b) for(int i=(a);i<=(b);(i++))
#define inf 0x3f3f3f
#define ll long long
#define pi acos(-1)
int dire3[6][3]={ {0,0,1},{0,1,0},{1,0,0},{0,0,-1},{0,-1,0},{-1,0,0} };
using namespace std;
const int maxn=205;
int visit[maxn][maxn];
char a[maxn][maxn];
int n,m;
int sx,sy,dx,dy;
struct node{
    int x,y,step;

    bool operator < (const node& p) const {  
        return step>p.step;  
    } 

    node(int xx,int yy,int s):x(xx),y(yy),step(s){};
};

int  bfs(int x,int y){
    priority_queue<node> q;
    q.push(node(x,y,0));
    visit[x][y]=1;
    while(!q.empty()){
        int hx=q.top().x,hy=q.top().y,hs=q.top().step;q.pop();
        if(hx==dx && hy==dy)  return hs;
        rep(i,0,3){
            int tx=hx+dire[i][0];
            int ty=hy+dire[i][1];
            if(tx<0||tx>=n||ty<0||ty>=m||a[tx][ty]=='#'||visit[tx][ty])
                continue;
            if(a[tx][ty]=='x') q.push(node(tx,ty,hs+2));
            else q.push(node(tx,ty,hs+1));
            visit[tx][ty]=1;
        }
    }
    return -1;
}
/*
int bfs(){

    int front=0;
    int rear=1;
    q[front].x=sx,q[front].y=sy,q[front].step=0;
    visit[sx][sy]=1;
    int flag=0;
    while(front < rear){
        if(q[front].x==dx && q[front].y==dy) return q[front].step;

        rep(i,0,3){
            int px=q[front].x+dire[i][0];
            int py=q[front].y+dire[i][1];
            if(px<0||px>=n||py<0||py>=m||visit[px][py]||a[px][py]=='#')
                continue;
            else{
                q[rear].x=px;
                q[rear].y=py;
                if(a[px][py]=='@'||a[px][py]=='a')
                    q[rear].step=q[front].step+1;
                else if(a[px][py]=='x')
                    q[rear].step=q[front].step+2;
                visit[px][py]=1;
                rear++;
            }
        } 
        front++;
    }
    return -1;
}
*/
int main()
{
    std::ios::sync_with_stdio(false);
    #ifndef OnlineJudge
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    #endif
    int t;
    cin>>t;
    while(t--){
        cin>>n>>m;
        rep(i,0,n-1){
        rep(j,0,m-1){
            cin>>a[i][j];
            if(a[i][j]=='r') sx=i,sy=j;
            if(a[i][j]=='a') dx=i,dy=j;
            }
        }
        memset(visit,0,sizeof(visit));

        int ans=bfs(sx,sy);
        if(ans==-1) printf("Impossible\n");  
        else printf("%d\n",ans);
    }

    return 0;
}

第二种 拆点

/*************************************************************************
    > File Name: bl4116_2.cpp
    > Author:ukiy 
    > Mail: 
    > Created Time: 2016年12月04日 星期日 01时19分50秒
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<string>
#include<cstring>
#include<vector>
#include<set>
#include<list>
#include<map>
#include<queue>
int dire[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };
int dire2[8][2]={{-1,-1},{-1,0},{-1,1},{ 0,-1},{ 0,1},{ 1,-1},{ 1,0},{ 1,1}};
#define rep(i,a,b) for(int i=(a);i<=(b);(i++))
#define inf 0x3f3f3f
#define ll long long
#define pi acos(-1)
int dire3[6][3]={ {0,0,1},{0,1,0},{1,0,0},{0,0,-1},{0,-1,0},{-1,0,0} };
using namespace std;
#define maxn 205
struct node{
    int r,c,t;
    node (int r,int c,int t):r(r),c(c),t(t){}
};


char g[maxn][maxn];
int G[maxn][maxn];
int  vis[maxn][maxn];
int sx,sy,dx,dy;
int n,m;
int bfs(){
    int ans=inf;
    queue<node> q;
    q.push(node(sx,sy,0));
    while(!q.empty()){
        node p = q.front();
        if(g[p.r][p.c]=='a'){
            ans=min(ans,p.t);
            q.pop();
            break;
        }

        if(g[p.r][p.c]=='x'&&G[p.r][p.c]==1){ //第二次拆点
            q.push(node(p.r,p.c,p.t+1));
            G[p.r][p.c]=0;
        }
        else{
            rep(i,0,3){
                int tr=p.r+dire[i][0];
                int tc=p.c+dire[i][1];
                if(tr>=0&&tr<n&&tc>=0&&tc<m && G[tr][tc]){
                    if(g[tr][tc]!='x'){
                        q.push(node(tr,tc,p.t+1));
                        G[tr][tc]=0;
                    }
                    if(g[tr][tc]=='x'&&G[tr][tc]==2){//第一次拆点 
                        q.push(node(tr,tc,p.t+1));
                        G[tr][tc]=1;
                    }
                }
            }
        }
        q.pop();
    }
    if(ans==inf)
        return -1;
    else
        return ans;
}


int main()
{
    std::ios::sync_with_stdio(false);
    #ifndef OnlineJudge
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    #endif
    int T;
    cin>>T;
    while(T--){
        cin>>n>>m;
        rep(i,0,n-1){
            rep(j,0,m-1){
                cin>>g[i][j];
                if(g[i][j]=='x') G[i][j]=2;
                else if(g[i][j]=='@'||g[i][j]=='a') G[i][j]=1;
                else if(g[i][j]=='r') G[i][j]=0,sx=i,sy=j;
                else G[i][j]=0;
            }
        }
        //memset(G,0,sizeof(G));
        int ans=bfs();
        if(ans==-1) printf("Impossible\n");
        else  printf("%d\n",ans);
    }
    return 0;
}

priority_queue 原文
BRCOCOLI http://blog.csdn.net/qq_34446253/article/details/51986930

拆点 原文
appledaily http://blog.csdn.net/hhhhhhj123/article/details/47070659

ukiy
关注
专栏目录
Openjudge4980 拯救行动(bfs)
GKHack's Blog
08-05 2099
总时间限制: 10000ms 内存限制: 65536kB 描述 公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M (N, M 英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是“骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。  现假设骑士可以向上、下、左、右四个方向移动，每移动一个位
百练4980--拯救行动(BFS)
Apple.Daily的专栏
07-26 3544
题目大意：给一个迷宫，骑士救公主，经过一个格子，耗费一个时间，路上有守卫，杀死守卫要耗费一个时间，也就是有守卫的格子要花费两个时间，求最短时间，如果不能，输出Impossible。 分析：BFS。在遇到有守卫的格子时，不能直接加两个时间，而是要把这个格子当做两个格子来走。因为，这样得出最短路不一定是最短时间，比如，你正前方有三个守卫，你要走到正前方第四个格子，走直线的话，花费的时间就是7，假设旁
百炼4116:拯救行动
丶益达丶的博客
05-06 1035
4116:拯救行动 总时间限制: 1000ms内存限制: 65536kB 描述 公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M (N, M 英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是“骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。 现假设骑士可以向上、下、左、右四个方向移动，
救援行动(save) (BFS)
weixin_34392843的博客
07-25 900
时间限制: 1 Sec内存限制: 64 MB提交: 42解决: 9[提交][状态][讨论版] 题目描述 Angel被人抓住关在一个迷宫了！迷宫的长、宽均不超过200，迷宫中有不可以越过的墙以及监狱的看守。Angel的朋友带了一个救援队来到了迷宫中。他们的任务是：接近Angel。我们假设接近Angel就是到达Angel所在的位置。假设移动需要1单位时间，杀死一个看守也需要1单位时间。...
百练 4116 拯救行动
qq_33901573的博客
07-21 579
#include #include #include #include #include using namespace std; const int maxn=200+5; char p[maxn][maxn]; int n,m,xm,ym,xw,yw; int vis[maxn][maxn]; struct node{ int l,x,y; int steps; nod
（简单bfs）百练4116:拯救行动
08-18 707
传送门：百练4116:拯救行动 题解：因为骑士杀死守卫会耗费时间，所以要用优先队列来维护步数。 收获：学会了无参构造方法的使用。 代码1：注意用无参构造方法的话，就不能再构造结构体类型的变量啦，例如，Maze tmp;这样的就不可以。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;queue&gt; #includ...
拯救行动（变种bfs）
Ema1997的博客
08-01 2056
拯救行动（变种bfs）
poj 4980 拯救行动（变式bfs）
PKU_ZZY的博客
06-04 3459
poj 4980 拯救行动（变式bfs） 程序设计实习2016推荐练习题
Java实现 计蒜客 拯救行动
热门推荐
南 墙
02-23 1万+
拯救行动 公主被恶人抓走，被关押在牢房的某个地方。牢房用 N \times M (N, M \le 200)N×M(N,M≤200) 的矩阵来表示。矩阵中的每项可以代表道路（@）、墙壁（#）、和守卫（x）。 英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是 “骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。 ...
百练4980 拯救行动[BFS]
思卟予
07-26 3017
公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M  (N, M 、墙壁（#）、和守卫（x）。 英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设 拯救成功的表示是‚骑士到达了公主所在的位置‛。由于在通往 公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须 杀死守卫才能继续前进。 现假设骑士可以向上、下、左、右四个方向移动，每移动一 个位置需要1个单位时间，杀死一个守
[百练]4116 拯救行动
A-lex的博客
08-10 219
广搜加优先队列 import java.util.Arrays; import java.util.Comparator; import java.util.PriorityQueue; import java.util.Scanner; public class Main { static int n,m; static int max_n=205,max_m=205; static...
百练 4116.拯救行动
CuriousLiu的博客
07-27 588
这道题相比于平常的bfs走迷宫，多了一个，原来因为要维护步数优先的队列，所以先出队的元素永远处在步数+1的位置  但这个题由于杀死守卫需要多花一个步数，所以平常的队列不能做到按照这个，所以要使用到优先队列的技巧 优先队列结构体的使用方法： struct node { int x; int y; int step; node(int a,int b,int c) { x = ...
营救BFS
alidadaaaa的博客
03-29 336
营救BFSbfs通常用来寻找从特定源节点出发的最短路径，dfs找到的解不是最优的，可能从多个源节点重复进行。（ZOJ1649）Angel的朋友营救angel，x为警卫，须杀死警卫才能到达其方格，费时一个单位，移动一格费时一个单位，#为墙壁。问至少需要多长时间。#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;queu...
【BFS】Oliver的救援
LCWLH
05-23 965
问题描述】 在你的帮助下，Oliver终于追到小X了，可有一天，坏人把小X抓走了。这正是Oliver英雄救美的时候。所以，Oliver又找到哆啦A梦，借了一个机器，机器显示出一幅方格地图，它告诉Oliver哪里能走，哪里不能走,。并且Oliver在这个地图的右下角，而小X在左上角。时间紧急，Oliver想知道，最少要走多少个格子,才能找到小X。（只能直走）。 【输入格式】 sos.in共N
Rescue（BFS）
Oenheng的博客
08-02 440
B - Rescue Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Practice HDU 1242 Description Angel was caught by the MOLIGPY! He was put in p
百练 4116 拯救行动 【bfs的内涵理解】
Anxdada -- 我等风来也等你
08-10 885
传送门 //中文题面就不说了. //提示 : 既然是最短时间, 第一反应肯定是bfs, 但是这道题需要你对bfs的理解要深刻一点. 如果单纯以最短去搜索, 遇到x时间就加2, @就加1, 然后去找. 这样肯定会WA的. 因为这样找只是找到的最短路径下的最短时间, 并不是全局的最短时间, 所以我们不能以路径来扩充下一个节点, 而是应该以时间来扩充下一个节点, 即队列中推出来的是目前到这个点的最短时
POJ拯救行动
qq_39503067的博客
03-15 224
当各个节点的权重一样的时候，最小代价的路径=最短距离路径。可以把bfs理解为每次扩张一圈，只要记录每个节点在第几圈即可，与具体怎么从一个圈到达另一个圈的路径无关。 解法一：bfs+优先队列 当每个节点权重不一样时，要想使每个节点的代价最小，只要保证所有能到达它的节点的代价都是最小的，并从中选择最小的那个用来确定它的代价即可。 bfs+优先队列中，每次出队的时候，出队元素的代价都是全局最小的，因为之...
BFS+优先队列解决POJ上的拯救行动问题
ls8023yx的博客
04-19 501
描述 公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M (N, M <= 200)的矩阵来表示。矩阵中的每项可以代表道路（@）、墙壁（#）、和守卫（x）。 英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是“骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。 现假设骑士可以向上、下、左、右四个方向...
PTA - 拯救007 ( BFS )
最新发布
06-07
PTA - 拯救007是一道经典的图论问题，其中使用了BFS算法。问题的具体描述是：有一个迷宫，007需要从起点到达终点，但是迷宫中有一些点是危险的，如果007经过这些点就会被捕捉。现在给定起点和终点，以及危险点的位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值