基础算法复习之六：最短路径算法

  记录两种最短路径算法，一种是迪杰斯特拉算法，一种是弗洛伊德算法：

 最短路径是指两个顶点之间经过的边上权值之和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点；

1.迪杰斯特拉算法（Djikstra），时间复杂度为O(N^2);

#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<limits.h>
using namespace std;
//迪杰斯特拉算法求最短路径
//将所有顶点分为两部分，一部分为最短路劲的顶点集合P，一个为未知最短路径的顶点集合Q；
//visited=1表示在集合P中，否则在Q中；
#define Max_Vertex 100
int weight[Max_Vertex][Max_Vertex], dis[Max_Vertex], visited[Max_Vertex];//假设有100个顶点
int vertexs, edges;
void init1()//初始化每两个顶点间的权值；
{
	for(int i=0;i<vertexs;i++)
		for (int j = 0; j < vertexs; j++)
		{
			if (i == j)
				weight[i][j] = 0;
			else
				weight[i][j] = INT_MAX;
		}
}
void init2()
{
	for (int i = 0; i < vertexs; i++)
		dis[i] = weight[0][i];//初始化起点到其他所有点的距离；
	for (int i = 0; i < vertexs; i++)
		visited[i] = 0;
	visited[0] = 1;
}

void shortestPath_djikstra()
{
	int i, j, v, u, min;
	for (int i = 1; i < vertexs; i++)
	{
		min = INT_MAX;
		for (int j = 1; j < vertexs; j++)//在Q集合中选择一个离起始点最近的一个点U；
		{
			if (visited[j] == 0 && dis[j] < min)
			{
				min = dis[j];
				u = j;
			}
		}
		visited[u] = 1;//将点u加入集合P；
		for (v = 1; v < vertexs; v++)//以顶点u为中介，考察起始点经过顶点u达到另一个顶点的路径是否更短；
		{
			if (weight[u][v] < INT_MAX)
			{
				//如果经过顶点u的距离比之前的距离更短，则更新距离
				if (visited[v] == 0 && dis[v] > dis[u] + weight[u][v])
					dis[v] = dis[u] + weight[u][v];
			}
		}
	}
}

int main()
{
	int i, j, v1, v2, w;
	cin >> vertexs>> edges;
	init1();
	for (int i = 0; i < edges; i++)//输入两个顶点间的权值
	{
		cin >> v1 >> v2 >> w;
		weight[v1][v2] = w;
	}
	init2();
	shortestPath_djikstra();
	return 0;
}

2.弗洛伊德算法，时间复杂度为O(N^3),本质是动态规划

#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<limits.h>
using namespace std;
//弗洛伊德算法求最短路径
//将所有顶点分为两部分，一部分为最短路劲的顶点集合P，一个为未知最短路径的顶点集合Q；
//visited=1表示在集合P中，否则在Q中；
#define Max_Vertex 100
int weight[Max_Vertex][Max_Vertex], dis[Max_Vertex], visited[Max_Vertex];//假设有100个顶点
int vertexs, edges;
void init()//初始化每两个顶点间的权值；
{
	for(int i=0;i<vertexs;i++)
		for (int j = 0; j < vertexs; j++)
		{
			if (i == j)
				weight[i][j] = 0;
			else
				weight[i][j] = INT_MAX;
		}
}

void shortestPath_floyd()
{
	int i, j, k;
	//这就是O(N^3)的由来,把每两个顶点之间的最短路径都计算出来了；
	for (int k = 0; k < vertexs; k++)//k是中间节点，要放在循环最外层；
	{
		for (int i = 0; i < vertexs; i++)
		{
			for (int j = 0; j < vertexs; j++)
			{
				//如果顶点i和顶点j之间的距离大于顶点i先到顶点k再到顶点j的距离，则更新
				if (weight[i][k] < INT_MAX &&weight[k][j]<INT_MAX && weight[i][j]>weight[i][k] + weight[k][j])
					weight[i][j] = weight[i][k] + weight[k][j];
			}
		}
	}
}
int main()
{
	int i, j, v1, v2, w;
	cin >> vertexs>> edges;
	init();
	for (int i = 0; i < edges; i++)//输入两个顶点间的权值
	{
		cin >> v1 >> v2 >> w;
		weight[v1][v2] = w;
	}
	shortestPath_floyd();
	return 0;
}