/************************
author's email:[email protected]
date:2018.1.30
************************/
/*
迪傑斯特拉演算法思想：
	設有兩個頂點集合S和T,集合S中存放圖中已找到最短路徑的頂點，集合T存放圖中剩餘頂點，初始狀態時
	集合S中只包含源點v0,然後不斷從集合T中選取到頂點v0路徑長度最短的頂點Vu併入到集合S中。集合S
	每併入一個新的頂點Vu,都要修改頂點V0到集合T中頂點的最短路徑長度值。不斷重複此過程，直到集合T
	的頂點全部併入到S中為止。
迪傑斯特拉演算法時間複雜度分析：
	由演算法程式碼可知，本演算法主要部分為一個雙重迴圈，外層迴圈內部有兩個並列的單層迴圈，可以在取一個
	迴圈內的操作作為基本操作，基本操作執行的總次數即為雙重迴圈執行的次數，為n^2次，因此本演算法的
	時間複雜度為O(n^2)。
*/
#include<iostream>
#define INF 100//INF為比圖中任何權值都大的數
#define maxSize 7   //圖的頂點數
#define number 12   //圖的邊數
using namespace std;
typedef struct {//圖的定義
	int edges[maxSize][maxSize];//鄰接矩陣的定義
	int n, e;   //分別為頂點數和邊數
}MGraph;
MGraph createGraph(MGraph g);
void Dijkstra(MGraph g, int v, int dist[], int path[]);/*迪傑斯特拉演算法程式碼，函式結束時
dist[]存放了v點到其餘各頂點的最短路徑長度，path[]中儲存從V到各頂點的最短路徑*/
void printfPath(int path[], int a);//輸出起始點v到終點a之間的最短路徑
int main() {

	MGraph g;//定義並初始化圖g
	g.edges[maxSize][maxSize] = { 0 };
	g.n = maxSize; g.e = number;
	g = createGraph(g);//建立一個圖

	int dist[maxSize] = {0};
	int path[maxSize] = {0};
	int v = 0;//起始點
	Dijkstra(g, v, dist, path);

	cout << "頂點"<<v<<"到各頂點的最短路徑及最短路徑長度為：" << endl;
	for (int i = 1; i < maxSize; ++i)
	{
		printfPath(path, i);
		cout<<"最短路徑長度為：" << dist[i]<<endl;
	}
	system("pause");
	return 0;
}

MGraph createGraph(MGraph g) {
	int i, j;
	for (i = 0; i < maxSize; i++)
	{
		for (j = 0; j < maxSize; j++)
		{
			g.edges[i][j] = INF;
		}
	}
	g.edges[0][1] = 4;
	g.edges[1][0] = 4;
	g.edges[0][2] = 6;
	g.edges[2][0] = 6;
	g.edges[0][3] = 6;
	g.edges[3][0] = 6;
	g.edges[1][2] = 1;
	g.edges[2][1] = 1;
	g.edges[1][4] = 7;
	g.edges[4][1] = 7;
	g.edges[2][3] = 2;
	g.edges[3][2] = 2;
	g.edges[2][4] = 6;
	g.edges[4][2] = 6;
	g.edges[2][5] = 4;
	g.edges[5][2] = 4;
	g.edges[3][5] = 5;
	g.edges[5][3] = 5;
	g.edges[4][5] = 1;
	g.edges[5][4] = 1;
	g.edges[4][6] = 6;
	g.edges[6][4] = 6;
	g.edges[6][5] = 8;
	g.edges[5][6] = 8;
	g.n = maxSize;
	g.e = number;
	return g;
}

/*迪傑斯特拉演算法程式碼，函式結束時
dist[]存放了v點到其餘各頂點的最短路徑長度，path[]中儲存從V到各頂點的最短路徑*/
void Dijkstra(MGraph g, int v, int dist[], int path[])
{
	int set[maxSize];/*set[]為標記陣列，set[Vi]=0表示Vi在T中，即沒有被併入最短路徑；
					 set[Vi]=1表示Vi在S中，即已經被併入最短路徑。*/
	int min, i, j, u;

	//對各陣列初始化
	for (i = 0; i < g.n; ++i)
	{
		dist[i] = g.edges[v][i];
		set[i] = 0;
		if (g.edges[v][i] < INF)
			path[i] = v;
		else
			path[i] = -1;
	}
	set[v] = 1; path[v] = -1;//初始化結束

	for (i = 0; i < g.n - 1; ++i)
	{
		min = INF;

		/*這個迴圈每次從剩餘頂點中選出一個頂點，通往這個頂點的路徑在通往所有剩餘頂點的路徑中
		是長度最短的*/
		for (j=0;j<g.n;++j)
		{
			if (set[j] == 0 && dist[j] < min)
			{
				u = j;
				min = dist[j];
			}
		}
		set[u] = 1;//將選出的頂點併入最短路徑中

		/*這個迴圈以剛併入的頂點作為中間點，對所有通往剩餘頂點的路徑進行檢測*/
		for (j = 0; j < g.n; ++j)
		{
			/*這個if語句判斷頂點u的加入是否會出現通往頂點j的更短的路徑，如果出現，則
			改變原來路徑及其長度，否則什麼都不做。*/
			if (set[j] == 0 && dist[u] + g.edges[u][j] < dist[j])
			{
				dist[j] = dist[u] + g.edges[u][j];
				path[j] = u;

			}
		}

	}
}
void printfPath(int path[], int a)//輸出起始點v到終點a之間的最短路徑
{
	int stack[maxSize], top = -1;//定義並初始化棧
	/*這個迴圈以由葉子節點到根節點的順序將其入棧*/
	while (path[a] != -1)
	{
		stack[++top] = a;
		a = path[a];
	}
	stack[++top] = a;
	while (top != -1)
	{
		cout << stack[top--] << " ";//出棧並打印出棧元素，實現了頂點的逆序列印
	}
	cout << endl;

}