图的最短路径问题

<pre name="code" class="cpp">#include <iostream>
#include <cassert>
#include <vector>
#include <stack>
#include <functional>
#include <iterator>

using namespace std;

/*左右的图都使用邻接矩阵（vector<vector<int>>）的表示方法*/


/*Dijkstra算法：设图的顶点集合为U，已确定到原点s的最短路径的顶点集合为S。每次在U-S中选择一个离s最近的顶点v（dist[v]最小）加入S，接着遍历U-S中所有顶点，如果其经过v到达s
更近，那么更新其到s的最短距离dist[i]*/
/*s为源点，dist[i]为顶点i到s的最短距离，prev[i]保存到顶点i到s的最短路径的前驱顶点*/
//dijkstra算法只支持权值为正的图
void dijkstra(const vector<vector<int>>& graph, int s, vector<int>& dist, vector<int>& prev)
{
	size_t nVertex = graph.size();
	dist.resize(nVertex);
	prev.resize(nVertex);
	vector<bool> isVisited(nVertex, false);
	for (size_t i = 0; i < nVertex; ++i)//初始化dist[i]为顶点i到s的距离
	{
		dist[i] = graph[s][i];
		if (dist[i] != INT_MAX)
		{
			prev[i] = s;//如果i与s相邻则prev[i]=s
		}
		else
		{
			prev[i] = -1;//如果i与s不相邻则prev[i]=-1
		}
	}

	isVisited[s] = true;//在集合S中的顶点都会被标记
	prev[s] = -1;

	//每次循环，S中会增加一个顶点，所以只要循环nVertex-1次
	int count = nVertex - 1;
	while (count-- > 0)
	{
		int selected = -1, minDistance = INT_MAX;
		//找出距离s最近的顶点selected
		for (size_t i = 0; i < nVertex; ++i)
		{
			if (!isVisited[i])
			{
				if (dist[i] < minDistance)
				{
					minDistance = dist[i];
					selected = i;
				}
			}
		}
		isVisited[selected] = true;//将selected加入集合S
		//
		//更新dist，看看U-S中的顶点经过selected到达s是不是更短
		//很傻瓜的做法就是对于U-S中的一个顶点，遍历它经过S中的每个顶点到大s会不会更短，然而并不需要遍历S中的每个点，只需要判断
		//刚加入的那个顶点就好了，因为更早前加入S的顶点已经被判断过了
		for (size_t j = 0; j < nVertex; ++j)
		{
			if (!isVisited[j])
			{
				if (graph[selected][j] != INT_MAX && dist[j] > dist[selected] + graph[selected][j])
				{
					dist[j] = dist[selected] + graph[selected][j];
					prev[j] = selected;
				}
			}
		}
	}
}

void printRoute(const vector<int>& prev, const vector<int>& dist, int s)
{
	for (size_t i = 0; i < prev.size(); ++i)
	{
		if (i != s)
		{
			for (int j = i; j != -1; j = prev[j])
			{
				cout << j << "  ";
			}
			cout << endl;
		}
	}
}


/*最小生成树prim算法：设图的顶点集合为U，最小生成树集合为S，任取一个顶点加入到S。每次在U-S中选择一个离S最近的顶点v加入S，直到U-S为空*/
int prim(const vector<vector<int>>& graph, vector<int>& route)//返回最小生成树的边缘权值和
{
	size_t nVertex = graph.size();
	vector<bool> isVisited(nVertex, false);
	vector<int> dist(nVertex);//dist[i]表示顶点i距离集合S最近距离（距离集合S中所有点的最近距离）
	isVisited[0] = true;
	route.reserve(nVertex);
	route.push_back(0);
	dist[0] = 0;
	for (size_t i = 1; i < nVertex; ++i)
	{
		dist[i] = graph[0][i];
	}
	int cost = 0;
	//每次循环，S中会增加一个顶点，所以只要循环nVertex-1次
	int count = nVertex - 1;
	while (count-- > 0)
	{
		int selected = -1, minDistance = INT_MAX;
		//找出距离集合S最近的顶点
		for (size_t i = 0; i < nVertex; ++i)
		{
			if (!isVisited[i])
			{
				if (dist[i] < minDistance)
				{
					minDistance = dist[i];
					selected = i;
				}
			}
		}
		cost += minDistance;
		isVisited[selected] = true;
		route.push_back(selected);
		//
		//更新dist，在U-S中找出距离集合S最近的顶点（距离集合中每个元素最近距离），只要比较每个顶点与刚加入的顶点即可，因为U-S中顶点与S
		//中其它顶点的最短距离早前已经计算过
		for (size_t j = 0; j < nVertex; ++j)
		{
			if (!isVisited[j])
			{
				dist[j] = dist[j] > graph[selected][j] ? graph[selected][j] : dist[j];
			}
		}
	}

	return cost;
}

/*floyd解决任意两点之间的最短距离，动态规划，
for k in vertex 
	if Dis(i,k) + Dis(k,j) < Dis(i,j) 
		Dis(i,j) = Dis(i,k) + Dis(k,j)
这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离*/
void floyd(const vector<vector<int>>& graph, vector<vector<int>>& dists, vector<vector<int>>& path)
{
	//path[i][j]存储最短路径i->j中顶点j的前驱
	size_t n = graph.size();
	path.resize(n);
	for (size_t i = 0; i < n; ++i)
	{
		path[i].resize(n);
		for (size_t j = 0; j < n; ++j)
		{
			if (graph[i][j] == INT_MAX)
			{
				path[i][j] = -1;
			}
			else {
				path[i][j] = i; //初始化为i,因为 
			}
		}
	}
	std::copy(graph.begin(), graph.end(), std::back_inserter(dists));

	for (int k = 0; k < n; ++k)//k一定要放在最外面
	{
		for (int i = 0; i < n; ++i)
		{
			for (int j = 0; j < n; ++j)
			{
				if (dists[i][k] != INT_MAX && dists[k][j] != INT_MAX && dists[i][k] + dists[k][j] < dists[i][j])
				{
					dists[i][j] = dists[i][k] + dists[k][j];
					path[i][j] = k;
				}
			}
		}
	}
}

void printPath(const vector<vector<int>>& path, int from, int to)
{
	if (path[from][to] == -1)
	{
		cout << "No path" << endl;
		return;
	}
	
	if (path[from][to] != from)
	{
		printPath(path, from, path[from][to]);
	}
	cout << path[from][to] << "->" << to << " ";
}

int _tmain(int argc, char* argv[])
{	
	int a[] = {0, 13, 8, INT_MAX, 30, INT_MAX, 32,
		INT_MAX, 0, INT_MAX, INT_MAX, INT_MAX, 9, 7, 
		INT_MAX, INT_MAX, 0, 5, INT_MAX, INT_MAX, INT_MAX, 
		INT_MAX, INT_MAX, INT_MAX, 0, 6, INT_MAX, INT_MAX, 
		INT_MAX, INT_MAX, INT_MAX, INT_MAX, 0, 2, INT_MAX, 
		INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, 0, 17, 
		INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, 0};
	int* p = a;
	//输入一个图
	int nRows = 7, nCols = 7;
	vector<vector<int>> graph(nRows, vector<int>(nCols));
	for (size_t i = 0; i < nRows; ++i)
	{
		for (size_t j = 0; j < nCols; ++j)
		{
			graph[i][j] = *(p++);
		}
	}

	vector<int> dist, prev;
	dijkstra(graph, 0, dist, prev);
	printRoute(prev, dist, 0);
	
	vector<int> route;
	cout << "cost of prim = " << prim(graph, route) << endl;
	cout << "prim = " << endl;
	for (auto r : route)
	{
		cout << r << "  ";
	}
	cout << endl;

	cout << "path of route floyd" << endl;
	vector<vector<int>> dists, path;
	floyd(graph, dists, path);

	printPath(path, 4, 6);

	system("pause");
	return 0;
}