單源最短路徑－－－－Dijkstra算法

#include <iostream>
#include <vector>
#define INFINITY 32768
#define VERTEX_MAX 50
using namespace std;

typedef char VertexType;				        //頂點類型
typedef int AdjType;					        //邊的關係類型
typedef struct {
	VertexType vertex[VERTEX_MAX];	            //頂點集
	AdjType arcs[VERTEX_MAX][VERTEX_MAX];      //邊集
	int vexnum,arcnum;					        //圖的當前頂點數和弧數
}MGraph;

void CreateDNGraph(MGraph *G);
void ShortestPath_DJS(MGraph G,int v0,int dist[VERTEX_MAX],int path[VERTEX_MAX]);

int main()
{
	MGraph G;
    CreateDNGraph(&G);
    int dist[VERTEX_MAX];
    int path[VERTEX_MAX];
    ShortestPath_DJS(G,0,dist,path);
	return 0;
}

//求頂點位置函數
int LocateVex(MGraph *G,VertexType v)
{
    int i;
    for(i=0;i<G->vexnum;i++)
    {
        if(G->vertex[i] == v)
            return i;
    }
    return -1;
}

//創建又向帶權圖
void CreateDNGraph(MGraph *G)
{
	 int i,j;
     VertexType v1,v2;
     int w;

     cout<<"請輸入頂點數和邊數：";
     cin>>G->vexnum>>G->arcnum;

     cout<<"請輸入各頂點的數據:";            
     for(int i=0;i<G->vexnum;i++)   
        cin>>G->vertex[i];  
      
     for (int i = 0; i < G->vexnum; i++)  
     {  
         for(int j=0;j< G->vexnum;j++)  
            G->arcs[i][j] = INFINITY;  
     }   
  
     cout<<"請輸入"<<G->arcnum<<"對頂點和相應的權重：\n";   
     for(int k=0; k<G->arcnum; k++)  
     {  
        cin>>v1>>v2>>w;  
        i = LocateVex(G,v1);  
        j = LocateVex(G,v2);          
        if(i>=0 && j>=0)  
            G->arcs[i][j] = w;                
     }  
}

//dist[i]：存放目前已經找到的，從開始點v0到終點vi的當前最短路徑長度
//path[i]: 存放目前已經找到的，從開始點v0到終點vi的當前最短路徑的頂點下標序列
void ShortestPath_DJS(MGraph G,int v0,int dist[VERTEX_MAX],int path[VERTEX_MAX])
{
    int min,j,k;
    int final[VERTEX_MAX];      //爲1代表已求得v0到v的最短路徑（最短路徑的終點集合）

    for (int i = 0; i < G.vexnum; i++)
    {
        final[i] = 0;   
        dist[i] = G.arcs[v0][i];     //將v0到各頂點的最短路徑長度初始化爲權值
        if(dist[i]<INFINITY)
            path[i] = v0;           //初始化各頂點的最短路徑爲邊(v0,vi)
    }

    final[v0] = 1;                  //講頂點v0加入終點集合
    dist[v0] = 0;                   //將最開始頂點(源點)的最短路徑置爲0

    for (int i = 0; i < G.vexnum; i++)
    {
        min = INFINITY;
        for (j = 0; j < G.vexnum; j++)
        {
            if (final[j]==0 && dist[j]<min)     //查找未用頂點的最小權值
            {
                min = dist[j];
                k = j;
            }
        }
        final[k] = 1;               //將頂點k加入終點集合

        for(j=0;j<G.vexnum;j++)
        {
            //以頂點k爲中間點，重新計算權重
            if (final[j]==0 && dist[k]+G.arcs[k][j]<dist[j])
            {
                dist[j] = dist[k]+G.arcs[k][j];     //更新權值
                path[j] = k;                        //將k加入最短路徑
            }
        }
    }

    cout<<"頂點"<<G.vertex[v0]<<"到各頂點的最短路徑爲:[(終點 <- 源點)倒序輸出]"<<endl;
    for (int i = 1; i < G.vexnum; i++)
    {
        if(final[i] == 1)       					//若頂點i在終點集合U中
        {
            k = i;
            while(k!=v0)							//頂點序列不與源點相同 
            {
                j = k;								//由終點向前追溯 
                cout<<"<- "<<G.vertex[k];    		//輸出經過的頂點
                k = path[j];                		//上一個頂點
            }
            cout<<"<- "<<G.vertex[k]<<endl;              //源點
            
            cout<<"最短路徑長度爲:"; 
        	cout<<dist[i]<<endl; 
        }else{
            cout<<G.vertex[v0]<<"->"<<G.vertex[i]<<":無路徑"<<endl;
        }
    }
}
/*
a b 50
a c 10
a e 45
b c 15
b e 10
c a 20
c d 15
d b 20
d e 35
e d 30
f d 3
*/