Dijkstra算法_数组实现

算法思想：**

贪心思想实现
首先把源点到所有点的距离数组存下来
每次循环找个距离最短的，然后对其访问，并且更新剩余点的距离
把所有的点找遍之后就存下了源点到其他所有点的最短距离。

图解详情可以看看
https://www.jianshu.com/p/8efcacb6bdf3

代码：

#include<iostream>
using namespace std;
#define maxv 100										//设最长路径不超过9999,顶点数<=100
void Dijkstra(int G[][maxv],int N, int *D, int s) { 	//G为图,N为顶点数，D为距离数组，s代表源点0--N-1 

	bool visited[maxv];									//标记顶点是否访问
	for (int i=0; i<N; i++){
		D[i]=-1; 										//初始化距离为-1 
		visited[i]=0;									//全部设置未访问 
	}
	D[s]=0;												//初始化顶点的标记 即距离为0  


//循环N个顶点，全部访问	
	for (int i=0; i<N; i++){
		int Min=INT_MAX,pos=-1;							//min记录最近距离 
		
		for (int j=0; j<N; j++){
			if(visited[j]==0&&(D[j]>=0)&&(D[j]<Min)){
				Min=D[j];
				pos=j;									//找到距离最近的点访问
			 }
		 }

		if (pos== -1) return;							//图不连通时，结束 
		
		visited[pos]=1;									//标记找到的节点为已经访问。
		for(int t=0;t<N;t++)							//更新剩余点的距离 
		{
			if(G[pos][t]!=0&&visited[t]==0)
			{
				if((D[t]>(D[pos]+G[pos][t]))||(D[t]==-1))
				D[t]=D[pos]+G[pos][t];
			}
		 } 
	 }
}

int main()
{
	int n,m,s;
	cin>>n>>m>>s;
	int G[maxv][maxv];
	for(int i=1;i<=m;i++){
		int x1,y1,z1;
		cin>>x1>>y1>>z1;
		G[x1-1][y1-1]=z1;
		G[y1-1][x1-1]=z1;//默认无向图 
	}


	int D[maxv];
	Dijkstra(G,n,D,s);
	
	for(int i=0;i<n;i++)
	cout<<D[i]<<" ";
}
//第一行为顶点数，边数，源点
//10 15 0
//1 2 1
//1 4 3
//2 3 2
//3 4 1
//3 5 5
//3 6 7
//4 5 3
//5 6 2
//6 1 100
//5 7 6
//7 8 7
//8 9 8
//9 10 9
//1 9 100
//2 10 7
//结果：0 1 3 3 6 8 12 19 17 8

测试样例：

如下图中，10个顶点，15条边，无向图，源点为第一个顶点，
输入：
10 15 0
1 2 1
1 4 3
2 3 2
3 4 1
3 5 5
3 6 7
4 5 3
5 6 2
6 1 100
5 7 6
7 8 7
8 9 8
9 10 9
1 9 100
2 10 7
结果应该是：0 1 3 3 6 8 12 19 17 8

时间复杂度：

初始化距离数组的时间代价为O（n）。然后访问所有顶点需要循环n次，每次循环，需要遍历顶点找到其相邻顶点更新距离需要的时间代价为O（n）,故，整体的算法时间复杂度为O（n * n）