Dijkstra求最短路

Dijkstra求最短路

用于单元最短路，即给定一个带权有向图 G=(V,E) ，其中每条边的权是一个非负实数。另外，还给定 V 中的一个顶点，称为源。我们要计算从源到所有其他各顶点的最短路径长度。这里的长度是指路上各边权之和。这个问题通常称为单源最短路径问题。
存储，稠密图用邻接矩阵（数组），稀疏图通领接表（一维数组模拟链表）
稠密图：点数 ^2 和 边数 一个数量级
稀疏图：点数较多，边数较少

Dijkstra求最短路

思路

1. 初始化距离数组，数比最大边大
2. 更新题中一条边到另一条边的值（要较小的一个，也是初始化要大于最大的边的原因）
3. 调用Dijkstra函数

Dijkstra函数（自己写）

1. 初始化所有的距离
2. 将第一个点的距离更新为0 （第一个点到第一个点的值为0 ）
3. 从第一个点更新其余点的距离，即 1到2 ，1 到3 ，1到4 ……
4. 第一个点标记一下已经确定最短路
5. 再共下一个点更新后面的点，取min;

数组（个人习惯）：
all[][]：存储点与点的距离
dis[]:最短路
st[]:是否确定这个点

题目

Dijkstra求最短路
代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 510;//多开十个（个人习惯）
int all[N][N], dis[N], n , m , x , y , z, st[N];

int dij()
{
	memset(dis , 0x3f , sizeof dis);初始化最短路距离的数组
	
	dis[1] = 0;//第一个点距离第一个点的距离为0
	
	for(int i = 1 ; i <= n ; i ++)//循环1 - n 个点
	{
		int t = -1;//记录最短的点
		for(int j = 1 ; j <= n ; j ++)//循环1 - n 个点（用于更新t 在后面循环中更新dis数组中的值）
		{
			if(!st[j] && (t == -1 ||dis[t] > dis[j]))//如果这个点没有确定最短路，且这个点到第一个点的距离较小
				t= j;//将t更新为j
		}
		
		for(int j = 1 ; j <= n ; j ++)//用t电更新其余的没确定最短路的点，不用担心会改变前面确定的点， 前面确定的点一点比dis[t]小
		{
			dis[j] = min(dis[j] , dis[t] + all[t][j]);//更新t点到j点的距离，和原来的距离作比较取小 
		}
		
		st[t] = 1;//将t点标记为确定最短路的点
	}
	
	if(dis[n] == 0x3f3f3f3f) return -1;//如果没有可以到达终点的值返回-1
	else return dis[n];//返回dis[n]
}

int main()
{
	cin>>n>>m;//读入点和边
	memset(all , 0x3f , sizeof all); //初始化距离的点
	
	while(m--)//读入边
	{
		cin>>x>>y>>z;
		all[x][y] = min(all[x][y] , z);//更新距离
	}
	
	cout<<dij();//输出
	
	return 0;
}

堆优化版Dijkstra

适用于稀疏图
（类似于bfs）

思路

和上面的Dijkstra差不多，差别在用数组模拟链表来存储数据，和Dijkstra函数实方式不同

数据存储 ：邻接表

Dijkstra：
用优先队列实现（也可以手写堆）

初始化最短路数组的距离
d[1]= 0
用priority_queue<PII , vector<PII> , greater<PII> > 存储
将 {距离，点} 存到优先队列中
当队列不为空继续循环
从对头弹出第一个pair
如果这个点被更新，下一个
如果没有将他标记为确定 ，下面代码就更新这个点链接点dis[]的距离
循环以这个点为头结点的链表 ， 如果dis有更新，将距离和点加到优先队列中
返回值

题目

Dijkstra

代码：

#include <bits/stdc++.h>
using namespace std;

typedef pair<int ,int >PII;
const int N = 1e6+ 10;//N的值要大于点的数量
int h[N] , e[N] , ne[N] , w[N] ;//存储
int idx, dis[N], n , m, x, y , z, st[N];

void add(int x ,int y ,int z)//链表更新
{
	e[idx] = y;
	ne[idx] = h[x];
	h[x] = idx;
	w[idx] = z;
	idx ++; 
}

int dij()//Dijkstra函数实现
{
	memset(dis , 0x3f , sizeof dis);
	
	dis[1] = 0;
	priority_queue<PII , vector<PII> , greater<PII> >heap;
	heap.push({0 , 1});
	
	while(heap.size())
	{
		auto t = heap.top();
		heap.pop();
		
		int ver = t.second ,dist= t.first;
		
		if(st[ver] == 1) continue;
		st[ver] = 1;
		for(int i = h[ver] ; i != -1 ; i = ne[i])
		{
			int j =e[i];
			if(dis[j] > dis[ver] + w[i])
			{
				dis[j] = dis[ver] +w[i];
				heap.push({dis[j] , j });
			}
		}
	}
	
	if(dis[n] == 0x3f3f3f3f ) return -1;
	return dis[n];
    
	
}

int main()
{
	cin>>n>>m;
	memset(h , -1 , sizeof h);//初始化链表头
	for(int i = 0 ; i < m  ; i ++)
	{
		cin>>x>>y>>z;
		add(x , y , z);
	}
	
	cout<<dij();
	return 0;
}

#个人学习使用