算法储备之Dijkstra算法求单源点最短路径

迪杰斯特拉算法求单元点最短路径，图的存储结构为邻接矩阵 在找最短距离和更新距离时都用for循环遍历结点数 时间复杂度为O(V²)

#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

#define V 9

int minDistance(int dist[], bool sptSet[])
{
	int min = INT_MAX, min_index;

	for (int v = 0;v < V;v++)
		if (sptSet[v] == false && dist[v] <= min)
		{
			min = dist[v];
			min_index = v;
		}
	return min_index;
}

void printSolution(int dist[],int path[],int src)
{
	printf("Vertex   Distance from Source\n");
	for (int i = 0;i < V;i++)
	{
		printf("%d\t\t%d\t", i, dist[i]);
		for (int u = i;u != src;u = path[u])
			printf("v%d <- ", u);
		printf("v%d\n", src);
	}
}

void dijkstra(int graph[][V], int src)
{
	int dist[V];
	int path[V];
	bool sptSet[V];
	for (int i = 0;i < V;i++) {
		dist[i] = INT_MAX;
		sptSet[i] = false;
	}

	dist[src] = 0;
	path[src] = src;

	for (int count = 0;count < V - 1;count++)
	{
		int u = minDistance(dist, sptSet);

		sptSet[u] = true;

		for (int v = 0;v < V;v++)
		{
			if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
				&& dist[u] + graph[u][v] < dist[v])
			{
				dist[v] = dist[u] + graph[u][v];
				path[v] = u;
			}
		}
	}
	printSolution(dist,path,src);
}

int main()
{
	int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
	                               { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
	                               { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
	                               { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
	                               { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
	                               { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
	                               { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
	                               { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
	                               { 0, 0, 2, 0, 0, 0, 6, 7, 0 }
	};

	dijkstra(graph, 0);

	return 0;
}