dijkstra算法+迷宫探索例题（牛客）

目录

题目描述

输入描述：

输出描述:

输入                                输出

算法介绍

朴素dijkstra算法

堆优化版的dijkstra算法

解题思路

代码实现

---

制作不易，点个赞再走吧

题目描述

链接：迷宫探索
来源：牛客网

在与boss的最终决战之后，小蓝来到了冒险的最后一关，在他面前有一个n*m的迷宫，迷宫中道路用’.’表示，墙壁则由‘#’表示。小蓝初始在[1,1]的位置，他只有到达[n,m]才能开启最终的宝藏。小蓝现在迫不及待的想要开启宝藏，所以他想最短的时间内走出迷宫。现在迷宫内有一种特殊的装置 –“弹射器”。弹射器的格子用’*’表示。当走到有弹射器的一格时，小蓝必须选择一个方向，弹射器会让他沿着这个方向弹射 x个距离，不同弹射器的弹射距离可以不同。弹射后的格子如果超过迷宫边界或者是墙壁则不能选择这个方向。小蓝现在可以向上下左右四个方向走，每走一个格子需要消耗一个单位时间，弹射则不消耗时间。求最短需要多少时间小蓝才能走出迷宫。如果无法到达终点，输出-1。

弹射器的数量，位置和弹射距离将在输入中给出。起点和终点一定不是弹射器。

输入描述：

第一行两个整数 n, m，接下来n行，每行m个只包含’ . ’ , ’ * ’ , ’#’的字符描绘迷宫。

接下来一行一个整数k，下面的k行每行三个整数x, y, w表示在[x,y]格子的弹射器能弹射的距离。（2≤n≤3000,2≤m≤3000, n*m≤500000, 0≤k, w在int范围内）

输出描述:

一行一个整数

输入                                输出

3 2                            1
.*
#.
..
1
1 2 2

算法介绍

朴素dijkstra算法

Dijkstra 算法是求一个图中一个点到其他所有点的最短路径的算法，是一个基于「贪心」、「广度优先搜索」、「动态规划」求一个图中一个点到其他所有点的最短路径的算法，时间复杂度 O()

目前我了解的dijkstra算法可以解决两类问题，一种就是该题这样的，还有一种就是邻接矩阵。

要点：

每次从 「未求出最短路径的点」中 取出 距离距离起点 最小路径的点，以这个点为桥梁 刷新「未求出最短路径的点」的距离

注意：dijkstra算法不能解决负权边的问题

模板代码：

求1到n点的距离

const int N = 1000005;
int n,m,k;
int djs[N];  // 存储 1到 N这两个点之间的最短距离 
bool used[N];   // 标记该该点是否已经存储好了 
int w[N][N];    // 储存距离 

int dijkstra()
{
    memset(djs, 0x3f3f3f3f, sizeof djs);
    djs[1] = 0;

    for (int i = 0; i < n - 1; i ++ ) // 迭代 n 次 
    {
        int k = -1;   
        for (int j = 1; j <= n; j ++ )
            if (!used[j] && (k == -1 || djs[k] > djs[j]))
                k = j;

        for (int j = 1; j <= n; j ++ )
            djs[j] = min(djs[j], djs[k] + w[k][j]);

        used[k] = true;
    }

    if (djs[k] == 0x3f3f3f3f) return -1;
    return djs[k];
}

堆优化版的dijkstra算法

因为每次查找都是找到达该点的距离最小的那个点，那么我们就可以用小根堆来实现。

在运用小根堆的时候之前要进行邻接表的处理。

模板代码：

求1到n点的距离

typedef pair<int, int> PII;
const int N = 100000;
int n,m;   
int h[N], w[N], e[N], ne[N], idx;    // 邻接表的模板 
int djs[N];     
bool used[N];    

void add(int x,int y,int val)   // 建立邻接表 
{
	e[idx] = y,w[idx] = val,ne[idx] = h[x],h[x] = idx++;
}

int dijkstra()
{
    memset(djs, 0x3f, sizeof djs);
    djs[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int x = t.second, len = t.first;

        if (used[x]) continue;
    	used[x] = true;

        for (int i = h[x]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (djs[j] > x + w[i])
            {
                djs[j] = len + w[i];
                heap.push({djs[j], j});
            }
        }
    }

    if (djs[n] == 0x3f3f3f3f) return -1;
    return djs[n];
}

解题思路

该题的思路就是运用dijkstra的算法进行操作，该题的思路更像的广度优先搜索，就是用该算法对该搜索进行优化。该题就是典型的dijkstra的算法，题目中写的有部分变量注释，更多细节请看代码，这里就不多说了。

代码实现

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

typedef pair<int,int> PII;
typedef pair<int,PII> PIP;
priority_queue<PIP,vector<PIP>,greater<PIP>> heap;
const int N = 10006;
char str[N][N];		 // 存储地图 
bool used[N][N];     // 标记该点是否已经走过了 
int w[N][N];		 //存储 * 能弹射的距离 
int dx[] = {1,-1,0,0},dy[] = {0,0,1,-1};
int n,m;

int dijkstra()
{
	heap.push({0,{1,1}});    // 从第一个位置开始遍历，那么就将第一个位置直接存下来。 
							 // heap.first 表示从第一个位置到该点位置的最短路径，heap.second 存的是该点的坐标 
	while(heap.size())
	{
		auto t = heap.top();  
		heap.pop();
		int len = t.first, x = t.second.first,y = t.second.second;  // 将该点的信息换个数据存下来 
		if(x == n && y == m) return len;			 // 如果找到这个点了，就返回这个值。 
		if(used[x][y]) continue;					// 如果初始位置到该点的最小距离已经找到了，就跳过 
		used[x][y] = true;
		for(int i = 0; i < 4; i++)
		{
			int flag = 0;
			int xx,yy;
			if(str[x][y] == '.')
			{
				flag = 1;
				xx = x + dx[i],yy = y + dy[i];
			}
			else if(str[x][y] == '*')
			{
				xx = x + dx[i] * w[x][y],yy = y + dy[i] * w[x][y];
			}
			if(used[xx][yy]) continue;
			if(xx >= 1 && yy >= 1 && xx <= n && yy <= m && str[xx][yy] != '#') // 确定下一个能走的位置 
			{
				heap.push({len + flag,{xx,yy}});
			}
		}
	}
	return -1;
}

int main (void)
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> str[i] + 1; // 为了使输入的初始位置为1 1 
	}
	int t;
	cin >> t;
	while(t--){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		w[a][b] = c;       // 将 * 能移动的位置存下来 
	}
	int k = dijkstra();
	printf("%d",k);
	return 0;
}