单源最短路径dijkstra（学习笔记）

概念：一个指定的点（源点)到其余各个顶点的最短路径。

dijkstra算法主要思想：通过“边”来松弛源点到其余各个顶点的路径。

已学习两种存储顶点之间边的关系：

1. 邻接矩阵——二维数组与Floyd类似  i,j表示点i到j的距离（单向）
2. 邻接表——一种链表，储存以某个点为顶点的所有的边。每条输入的边都有编号。

 

例题 P3371 【模板】单源最短路径（弱化版）https://www.luogu.com.cn/problem/P3371

---

邻接矩阵

思路：先存图，然后为dis数组存入估计值（源点到各个顶点的距离初始值）。

取其中最小的边，将源点到这个顶点的距离由估计值变为确定值（book变为1，下次不在访问），然后去松弛源点到其余的各个顶点（贪心）。

 重复操作，知道所有的点都无法访问。

代码实现

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

long long dis[10000+5];
int book[10000+5];
int side[10000+5][10000+5];
#define inf 2147483647

int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)//初始化  边  数组
	{
		for(int j=1;j<=n;j++)
		{
			side[i][j]=inf;
		}
		side[i][i]=0;
	}
	long long u,v,w;
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%lld%lld%lld",&u,&v,&w);
		if(w<side[u][v]) side[u][v]=w;
	}
	for(int i=1;i<=n;i++)//估计值
	{
		dis[i]=side[s][i];
	}
	book[s]=1;
	for(int i=1;i<=n-1;i++)
	{
		long long min=inf;
		int near=0;
		for(int j=1;j<=n;j++)//找到最近的点
		{
			if(book[j]==0&&dis[j]<min)
			{
				min=dis[j];
				near=j;
			}	
		}
		book[near]=1;//接下来通过s-near这条边来松弛顶点到其余各个顶点的距离
		for(int j=1;j<=n;j++)
		{
			long long temp=dis[near]+side[near][j];
			if(side[near][j]<inf&&dis[j]>temp)
			{
				dis[j]=temp;
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%lld ",dis[i]);
	}
    return 0;
}

60分 orz

---

邻接表

与邻接矩阵，只有访问边的手段不同。

邻接矩阵在进行松弛操作时（假设用s，near这条边），是用这条边和near到所有点的边去尝试松弛s到所有点的距离。（即使near到所有点并不接通）

邻接表则是，用这条边和与near到连通点的边来松弛s到该连通点的边。访问与near联通的边时，按照first与next数组访问。first为与要访问的第一条边，其值为该条边的编号。next则是下一条要访问的边。

代码实现

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define inf 2147483647
int u[500000+5];
int v[500000+5];
long long w[500000+5];
int first[10000+5];
int next[500000+5];
long long dis[10000+5];
int book[10000+5];

void valuation(int s)
{	
	int k=first[s];
	while(k!=-1)//遍历与s相连所有的边
	{
		if(dis[v[k]]>w[k])//考虑重边 取较小值
		dis[v[k]]=w[k];
		k=next[k];
	}
}
int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%lld",&u[i],&v[i],&w[i]);
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
	}	
	dis[s]=0;	
	valuation(s);//估计值
	book[s]=1;
	int k;
	for(int i=1;i<=n-1;i++)
	{
		long long min=inf;
		int near=0;
		for(int j=1;j<=n;j++)//找到最近的点
		{
			if(book[j]==0&&dis[j]<min)
			{
				min=dis[j];
				near=j;
			}	
		}
		book[near]=1;
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		while(k!=-1)//遍历与near相连所有的边
		{
			if(dis[v[k]]>dis[near]+w[k])
			{
				dis[v[k]]=dis[near]+w[k];
			}
			k=next[k];
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%lld ",dis[i]);
	}
    return 0;
}

90分 弱小无助，哭

---

AC代码

要么把near放在外面定义，要么把first[0]=-1.

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define inf 2147483647
int u[500000+5];
int v[500000+5];
long long w[500000+5];
int first[10000+5];
int next[500000+5];
long long dis[10000+5];
int book[10000+5];

void valuation(int s)
{	
	int k=first[s];
	while(k!=-1)//遍历与s相连所有的边
	{
		if(dis[v[k]]>w[k])//考虑重边 取较小值
		dis[v[k]]=w[k];
		k=next[k];
	}
}
int main()
{
	int n,m,s;
	scanf("%d%d%d",&n,&m,&s); 
	for(int i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(int i=1;i<=m;i++)//输入 边
	{
		scanf("%d%d%lld",&u[i],&v[i],&w[i]);
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	for(int i=1;i<=n;i++)
	{
		dis[i]=inf;
	}	
	dis[s]=0;	
	valuation(s);//估计值
	book[s]=1;
	int k;
	int near=0;
	for(int i=1;i<=n-1;i++)
	{
		k=first[s];//找到第一条边
		long long min=inf;
		for(int j=1;j<=n;j++)//找到最近的点
		{
			if(book[j]==0&&dis[j]<min)
			{
				min=dis[j];
				near=j;
			}	
		}
		book[near]=1;
		//接下来，通过这条 边 去松弛 顶点到其余的各点的距离
		k=first[near];
		while(k!=-1)//遍历与near相连所有的边
		{
			if(dis[v[k]]>dis[near]+w[k])
			{
				dis[v[k]]=dis[near]+w[k];
			}
			k=next[k];
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%lld ",dis[i]);
	}
    return 0;
}