【人话聊算法】Dijkstra算法（第二版）

适用范围：Dijkstra算法适用于【单源点】【正边权】的【有向图】或者【无向图】，是一种用于求最小路径的比较高效的算法。

题目类型：题目一般会给出，若干个点到点的距离，让你求出某点到某点的最小的路径

步骤一：构建邻接矩阵，也就是创建一个地图，将路径存放地图内。

	1	2	3	4	5	6	7	8	9
1	0
2		0
3			0			……
4				0
5					0
6		……				0
7							0
8								0
9									0

注意：这里距离的设置

1、点到自己的距离为0；

2、如果这条路径可以从(a, b)走，也可以（b，a)走的话，也就是无向图，那么在填表的时候就要注意不要遗漏；

3、如果说没有路径可以走的初始化为无穷大 ；

4、如果说（a, b)之间有多条路的话我们就取最小的路。

memset(mp, 0x3f, sizeof(mp));//将所有不存在的路径给定义为INF 
int k, l, r;//这里k，l是点，r是距离
		   for(int i = 0;i < n;++i)
        {
            scanf("%d %d %d", &k, &l, &r); 
            mp[k][l] = min(mp[k][l], r); //多条路选最短的 
            mp[l][k] = mp[k][l];//无向图，可以回头 
        }
for(int i = 0;i < m;++i)
            mp[i][i] = 0;//小心原地打转

步骤二：初始化数组

1、我们需要两个数组v[]记录是否被标记（visit）过和最短距离（distance）数组d[]。

2、注意初始化

memset(v, 0, sizeof(v));//将所有的点未标记 
for (int i = 0; i < m; i++)//注意，这里m代表的是节点总数，a代表的是除发点
		{
			d[i] = (i == a ? 0 : INF);//初始化记录所有节点到起点的数组 
		}

假设此刻还不知道有路可走，那么只有到自己距离是0，其他都是无路可走，故设置成无穷大，0x3f3f3f3f 

 步骤三：遍历求最小路径

		for (int i = 0; i < m; i++)//m是节点数
		{
			int x;//x是用来记录最小的点
			int w = INF;//w是用来存储最小路径的
			for (int y = 0; y < m; y++)//访问每一个点
			{
				if (!v[y] && d[y] <= w)//找到未标记的节点里最近的点 
				{
					w = d[x = y];//记录一下最小点距离 
				}
			}
			v[x] = 1;//标记最小节点 
			for (int y = 0; y < m; y++)
			{
				d[y] = min(d[y], d[x] + mp[x][y]);//更新每一个点到起点的距离 
			}
		}

步骤四：输出 

printf("%d\n", d[b] == INF ? -1 : d[b]);//输出
//如果等于无穷大的话，输出-1，表示没有路径

 原理思考：我思考了很久，想了两天查了很多资料才想明白

 简单理解： 第一次取点之后，原点扩大了，变成了一个名为S的大原点，相当于原点扩大了一些，把确定的点和原点优化成一个综合的点，直接取最短路径就是正确的。

严谨理解：

首先我们把已经标记了的确定最小距离的所有点看成一个集合S，S的元素开始为1。

我们在历次的遍历过程中，已经把S集合中每一个点直接到达未标记点的距离更新到了最小的状态。

我们想要知道，这些没有标记的点里面的距离最小的点就是下一个进入集合S的点。

反证法：如果存在某个在外面的其他中间节点，那么原点到这个节点的距离，这个距离肯定比那个最小点要大，再加上一段未知的距离（正的）肯定比这个大。所以不存在以其他点为转站的更优。

那么，也就只能从S集合直接到达了，故是下一个S集合的点。

注：S集合表示，从原点出发最小距离已经确定的点。

笔者在撸题的时候又发现失败之处了。-_- 

洛谷P3371

这道题，虽然用邻接矩阵也可以去做但是，MLE到死

因为它的量级太大了，这时候我们就要优化一下算法。

 

#include <bits/stdc++.h>
using namespace std;
#define inf 0x7fffffff 
#define MAXN 100005
#define MAXM 500005
#define ll long long
struct edge {
	ll to, dis, next;
};
edge e[MAXM];
ll head[MAXN], dis[MAXN], cnt = 0, vis[MAXN];
void add_edge(ll u, ll v, ll d) {
	cnt++;
	e[cnt].dis = d;
	e[cnt].to = v;
	e[cnt].next = head[u];
	head[u] = cnt;
}
struct node {
	ll dis, pos;
	bool operator < (const node &x) const {
	      return x.dis < dis;
	}
};
priority_queue<node> q;
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	ll n, m, s;
	cin >> n >> m >> s;
	for (int i = 0; i <= n; i++) {
		dis[i] = inf;
	}
	for (int i = 0; i < m; i++) {
		ll u, v, d;
		cin >> u >> v >> d;
		add_edge(u, v, d);
	}
	dis[s] = 0;
	q.push((node){0, s});
	while (!q.empty()) {
		node tmp = q.top();
		q.pop();
		ll x = tmp.pos, d= tmp.dis;
		if (vis[x]) {
			continue;
		}
		vis[x] = 1;
		for (int i = head[x]; i; i = e[i].next) {
			ll y = e[i].to;
				if (dis[y] > dis[x] + e[i].dis) {
			dis[y] = dis[x] + e[i].dis;
			if (!vis[y]) {
				q.push((node){dis[y], y});
			}
		} 
		}
	}
	for (int i = 1; i <= n; i++) {
		cout << (dis[i] == inf ? 0x7fffffff : dis[i]) << ' ';
	} 
	return 0;
}

我们称之为堆优化的dijkstra  

ps：个人认为这个是链式前向星和堆优化都有。 

 观察多了什么。

首先：我们发现多了一个add_edge函数，这就是所谓的【链式前向星】 ，据说这是夹在难写高效的【邻接表】和好写低效的【邻接矩阵】(0(n^2))之间的好东西。

定义一个edge结构体：

to - 终点；

dis-边权；

next-记录上一个同起点的点的编号 

 

void add_edge(ll u, ll v, ll d) {
	cnt++;
	e[cnt].dis = d;
	e[cnt].to = v;
	e[cnt].next = head[u];
	head[u] = cnt;
}

这是加边的操作。

cnt是计数器，用来给head【u】标号。

边权没有什么好解释的，和to是存在一起的。

for (int i = head[x]; i; i = e[i].next) {
			。。。。
}

链式前向星的作用是将同起点的边整合在一起。

这里以起点1为例

我们如果输入了许多的以1为起点的边，

1 2 3 

1 2 4

1 2 4

,,,

.next里面存储的是上一次更新后的点的编号。

head[起点] = 最后一个更新的边的编号

我们遍历的时候,i的入口赋值为最后一个边的编号，然后得到上一次更新的编号，依此类推直到没有边。

struct node {
	ll dis, pos;
	bool operator < (const node &x) const {
	      return x.dis < dis;
	}
};

然后是优先队列的使用，小顶堆。

关于这个的书写格式：运算符重载，只能记忆一下了，这个理解上可能有些麻烦，何况我也不是很明白。 

 bool operator < (const node &x） const {

return x.dis < dis;

}首先两个关键字，一个小于号，类似强制转换类型的东西，const 然后声名优先级。

这里我们把x.dis放左边，因为我们比较的是dis该放哪里。

这样就可以和sort函数统一了，小于号就是从小到大（队头到队尾，从左到右）

 

	dis[s] = 0;
	q.push((node){0, s});
	while (!q.empty()) {
		node tmp = q.top();
		q.pop();
		ll x = tmp.pos, d= tmp.dis;
		if (vis[x]) {
			continue;
		}
		vis[x] = 1;
		for (int i = head[x]; i; i = e[i].next) {
			ll y = e[i].to;
				if (dis[y] > dis[x] + e[i].dis) {
			dis[y] = dis[x] + e[i].dis;
			if (!vis[y]) {
				q.push((node){dis[y], y});
			}
		} 
		}
	}

 利用优先队列。

我们找距离最短的点，x是节点， d是距离 

 跳过标记过的节点， 标记。

链式前向星，y记录指向的终点。

逐个更新点，

如果说这个点没有被标记但是是起点可以到达的，就进入队列，直到更新完毕。

小结：链式前向星将同起点的边整合到一起，优先队列将较小的边存到前面。