圖論----最短路徑

1、Floyd算法

       原理：圖中任意兩點之間的最短距離等於兩點之間的直接距離和經過其他中間節點的距離之和的最小距離，即D[i][j] = min{ D[i][j] , D[i][k] + D[k][j] }，Floyd通常用來求所有頂點到所有頂點的最短路徑。

代碼如下：

#include "stdafx.h"
#include <iostream.h>
#include <stdlib.h>
#pragma warning(disable:4786)
#include <queue>
#include <stack>
#include <set>
#include <vector>
using namespace std;

const int n=5;
void ShortestPath_Floyd(int a[][n],int D[][n],int P[][n])
{
	int i,j,k;
	//初始化
	for (i=0;i<n;i++)
		for (j=0;j<n;j++)
		{
			D[i][j]=a[i][j];
			P[i][j]=j;
		}

	for (k=0;k<n;k++)
		for(i=0;i<n;i++)
			for (j=0;j<n;j++)
				if(D[i][j]>D[i][k]+D[k][j])
				{	
					D[i][j]=D[i][k]+D[k][j]; //更新最小權值和
			     	P[i][j]=P[i][k];         //更新路徑
				}
}

int main(int argc, char* argv[])
{
	//鄰接矩陣5*5，節點0~8
	int a[n][n]={
		0,1,4,30,5,
		1,0,10,37,2,
		4,10,0,20,12,
		3,3,20,0,15,
		5,2,12,15,0
	};	

	int P[n][n]; //保存最短路徑節點
	int D[n][n]; //保存最短路徑權值和
	int k;
	ShortestPath_Floyd(a,D,P);
	//打印最短路徑
	for (int i=0;i<n;i++)
	{
		for (int j=i+1;j<n;j++)
		{
			cout<<"v"<<i<<"-"<<"v"<<j<<" weight： "<<D[i][j];
			k=P[i][j];
			cout<<"\tpath: "<<i;
			while(k!=j)
			{
				cout<<" -> "<<k;
				k=P[k][j];
			}
			cout<<" -> "<<j<<endl;
		}
		cout<<endl;
	}

	return 0;
}

2、Dijkstra算法

原理;D算法並不是一下子就求出頂點v0到vi的最短路徑，而是一步步先求出他們之間的頂點的最短路徑，過程中都是基於已經求出的最短路徑基礎上，求得更遠頂點的最短路徑，最終得到結果。

#include "stdafx.h"
#include <iostream.h>
#include <stdlib.h>
#pragma warning(disable:4786)
#include <queue>
#include <stack>
#include <set>
#include <vector>
using namespace std;

const int n=5;
const int MAXVEX=65536;
void ShortestPath_Dijkstra(int a[][n],int v0,int D[n],int P[n])
{
	int i,j,k,min=MAXVEX;
	int final[n]; //標記是否已求得最短路徑
	//初始化
	for(i=0;i<n;i++)
	{
		final[i]=0;
		D[i]=a[v0][i];
		P[i]=0;
	}
	D[v0]=0; //v0到v0路徑爲0
	final[v0]=1;

	//循環找出v0到某個頂點v的最短路徑
	for (i=0;i<n;i++)
	{
		min=MAXVEX;
		for (j=0;j<n;j++)
		{
			if (!final[j]&&D[j]<min)
			{
				min=D[j]; //j節點距離v0更近
				k=j;
			}
		}
		final[k]=1; //標記已訪問過	
		
		//修正當前最短最短距離
		for (j=0;j<n;j++)
		{
			if (!final[j]&&(min+a[k][j])<D[j])
			{
				P[j]=k;
				D[j]=min+a[k][j];
			}
		}
	}	
}

int main(int argc, char* argv[])
{
	//鄰接矩陣5*5，節點0~8
	int a[n][n]={
		0,1,4,30,5,
		1,0,10,37,2,
		4,10,0,20,12,
		3,3,20,0,15,
		5,2,12,15,0
	};	

	int P[n]; //保存最短路徑節點
	int D[n]; //保存最短路徑權值和
	int v0=0; //起始節點
	int k[n],j=0;
	ShortestPath_Dijkstra(a,v0,D,P);

	//打印最短路徑
	for (int i=0;i<n;i++)
	{
		cout<<"v0-v"<<i<<" weight： "<<D[i];
		cout<<"\tpath：v0";
		k[j]=P[i];
		while(k[j]!=0)
		{	
			k[j+1]=P[k[j]];
			j++;
		}
		//採用逆向輸出數組內容打印最短路徑
		for(j--;j>=0;j--)
		    cout<<"->v"<<k[j];	
		j=0;
		cout<<"->v"<<i<<endl;
	}
	cout<<endl;
	
	return 0;
}