Dijkstra算法C++实现总结

问题描述

求无负权图中点s到点t的最短凝聚力

备注

标准说法中，“缩短”/“松弛”（relax）操作是对边进行的。下面为了行文方便，将其拓展到点。即以下操作，其中A表示目前已经算出的点i到j的距离：
A[i][j]=min(A[i][v] + A[v][j] , A[i][j]) （同时维护path数组）

算法思路

类似于按拓扑排序的顺序，对所有点进行缩短操作。
下面具体阐述。
用d[i]记录已算出的点s到点j之间的距离，path[j]记录目前算出的s到j最短路径中,j节点的上一个节点
将点分为两个集合：已完成的Known和未完成的unknown.
初始时，将所有d赋为无穷大，d[s]赋为0；所有点均为unknown
循环：对unknown的所有点，择其d最小者，进行缩短操作，该点加入known。直到所有点都为known。

实现思路

用一个数组known，known[i]为1则表示known，为0 表示unknown

一些恼人的小问题

1.无穷大问题

假设输入的邻接矩阵中，每点与自己的权值为0，不邻接的两点权值为MAX，MAX被宏定义为一个非常大但不容易溢出的整数。

2.多维动态数组传参问题

受编译器原理的限制，C/C++将多维动态数组作为函数参数传递是非常麻烦的，比如邻接矩阵。

源码

#include<iostream>
using namespace std;


#define MAX 50000

void printPath(int path[], int n,int s,int t)
{
	if (t == s) 
		cout << s; 
	else 
	{ 
		printPath(path, n, s, path[t]); 
		cout << "->"<<t;
	}

}
/*
仅适用于无负权的图
distance是目前算出的s到某点的距离数组，path是从s到某点v的最短路径中，v的上一节点
初始化将distance全部赋为正无穷，之后从s点开始，进行缩短操作，
此后选择未进行缩短的点中distance最小者进行缩短，直至所有点都完成了缩短操作
*/
int main()
{
	/*-----------------------声明与定义--------------------*/
	int n  =7, s = 0, t = 0, i, distS2T;
	int G[7][7] =
	{	0,4,5,6,MAX,MAX,MAX,
		4,0,3,MAX,1,MAX,MAX,
		5,3,0,MAX,MAX,2,MAX,
		6,MAX,MAX,0,2,MAX,MAX,
		MAX,1,MAX,2,0,MAX,4,
		MAX,MAX,2,MAX,MAX,0,3,
		MAX,MAX,MAX,MAX,4,3,0
	};
	int *known = new int[n](), *distance = new int[n],*path = new int[n];

	//如果s到某点距离已经确定了(该点已经被用于relax过了)，则known为1，否则为0
	//disFromS[]数组是s到各点的最短距离.
	//---------------------------------赋初值-------------------------------
	for (i = 0; i < n; i++)      
	{
		distance[i] = MAX;
	}
	distance[s] = 0;
	path[s] = s;
	

	//------循环：选择unknown的点中dis最小的进行缩短操作，直到所有点全部为known------
	
	while (1)  //there's stil unknown vertex
	{
		
		i = 0;
		while (known[i] == 1 && i<n) 
			i++;//find the first unknown vertex
		if (i >= n) break; //if all vertices are known ,end the algorithm
		int v = i;
		for (; i < n; i++)  //find the unknown vertex with the min distance
		{
			if (!known[i] && distance[v] > distance[i]) v = i;
		}

		//relax(minPos);  modify dis and parent
		for (i = 0; i < n; i++)
		{
			//for each unknown vertex i, 
			if (known[i]) continue;
			if (distance[i] > distance[v] + G[v][i])
			{
				distance[i] = distance[v] + G[v][i];
				path[i] = v;
			}
		}
		known[v] = 1;
	}

	//--------------输出&释放内存----------------------
	distS2T = distance[t];
	cout << distS2T<<endl;
	for (i = 0; i < n;i++)
		cout << path[i] << " ";
	cout << endl;
	for (i = 0; i < n; i++)
		cout << distance[i]<<" ";
	cout << endl;
	printPath(path, n, 0, 6);

	delete[] known;
	delete[] distance;
	delete[] path;
	while (1);
	return 0;

}