HDU 2822 Dogs( BFS + 优先队列)

最新推荐文章于 2020-12-09 09:09:54 发布

原创最新推荐文章于 2020-12-09 09:09:54 发布 · 196 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#优先队列 #bfs #解题报告

基本算法--广度优先搜索同时被 2 个专栏收录

5 篇文章

订阅专栏

数据结构--优先队列

3 篇文章

订阅专栏

本文介绍了一种使用优先队列实现的最短路径算法，以解决懒惰小土拨鼠从家到朋友家的最少挖掘距离问题。通过定义节点结构和比较运算符，算法能够有效地找到从起点到终点的最小步数。

Problem Description

Prairie dog comes again! Someday one little prairie dog Tim wants to visit one of his friends on the farmland, but he is as lazy as his friend (who required Tim to come to his place instead of going to Tim’s), So he turn to you for help to point out how could him dig as less as he could.

We know the farmland is divided into a grid, and some of the lattices form houses, where many little dogs live in. If the lattices connect to each other in any case, they belong to the same house. Then the little Tim start from his home located at (x0, y0) aim at his friend’s home ( x1, y1 ). During the journey, he must walk through a lot of lattices, when in a house he can just walk through without digging, but he must dig some distance to reach another house. The farmland will be as big as 1000 * 1000, and the up left corner is labeled as ( 1, 1 ).

Input

The input is divided into blocks. The first line in each block contains two integers: the length m of the farmland, the width n of the farmland (m, n ≤ 1000). The next lines contain m rows and each row have n letters, with ‘X’ stands for the lattices of house, and ‘.’ stands for the empty land. The following two lines is the start and end places’ coordinates, we guarantee that they are located at ‘X’. There will be a blank line between every test case. The block where both two numbers in the first line are equal to zero denotes the end of the input.

Output

For each case you should just output a line which contains only one integer, which is the number of minimal lattices Tim must dig.

Sample Input

6 6
..X…
XXX.X.
….X.
X…..
X…..
X.X…
3 5
6 3

0 0

Sample Output

3

Hint
Hint: Three lattices Tim should dig: ( 2, 4 ), ( 3, 1 ), ( 6, 2 ).

题意：

给出n,m表示图的范围。给出起点坐标和终点坐标。走X不增加步数，走“.”增加一步。问从起点到终点最少多少步。

思路：

定义优先队列按步数从小到大排序，注意重载符应该是>号。

这样在每一步往下bfs扩展的时候，步数少的那个点先出队列，这样bfs扩展到终点时即为最少步数。

代码：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=1005;
char Map[maxn][maxn];
bool vis[maxn][maxn];
struct node
{
    int x,y;
    int s;
    bool friend operator < (node a,node b)
    {
        return a.s>b.s;
    }
};
int n,m,sx,sy,ex,ey;
int dir[][2]={ {0,1},{-1,0},{0,-1},{1,0},{-1,1},{-1,-1},{1,-1},{1,1}};
int bfs()
{
    priority_queue<node>q;
    node now,t;
    now.x=sx,now.y=sy,now.s=0;
    q.push(now);
    memset(vis,0,sizeof(vis));
    vis[sx][sy]=1;
    while(q.size())
    {
        now=q.top();q.pop();
        if(now.x==ex&&now.y==ey) return now.s;
        for(int i=0;i<4;i++)
        {
            t=now;
            t.x+=dir[i][0],t.y+=dir[i][1];
            if(1<=t.x&&t.x<=n&&1<=t.y&&t.y<=m&&!vis[t.x][t.y])
            {
                vis[t.x][t.y]=1;
                if(Map[t.x][t.y]=='.') t.s++;
                q.push(t);
            }
        }
    }
    return -1;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n+m)
    {
        for(int i=1;i<=n;i++) scanf("%s",Map[i]+1);
        scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
        printf("%d\n",bfs());
    }
    return 0;
}