1. 程式人生 > >最短路徑的Dijkstra演算法

最短路徑的Dijkstra演算法

  1 /*  2  *    Copyright (c) 2013 eryar All Rights Reserved.
  3  *
  4  *        File    : Main.cpp
  5  *        Author  : [email protected]
  6  *        Date    : 2013-1-1 16:50
  7  *        Version : 0.1v
  8  *
  9  *    Description : Use adjacency matrix of a graph.
 10  *                Use Dijkstra method to find the shortest path.
 11  *
 12 */
 13 
 14 #include <CFLOAT>
 15 #include <IOSTREAM>
 16 using namespace std;
 17 
 18 const int VERTEX_NUM = 20;
 19 const double INFINITY = DBL_MAX;
 20 
 21 // Arc of the graph. 22 typedef struct SArc
 23 {
 24     double  dWeight;
 25 }AdjMatrix[VERTEX_NUM][VERTEX_NUM];
 26 
 27 // The graph: include vertex size and
 28 // arc size also the adjacency matrix. 29 typedef struct SGraph
 30 {
 31     int         mVertexSize;
 32     int         mArcSize;
 33     int         mVertex[VERTEX_NUM];
 34     AdjMatrix   mAdjMatrix;
 35 }Graph;
 36 
 37 // Function declarations. 38 void    CreateGraph(Graph& graph, bool isDigraph = false
);
 39 int     LocateVertex(const Graph& graph, int vertex);
 40 void    ShowGraph(const Graph& graph);
 41 void    Dijkstra(const Graph& graph, int src);
 42 
 43 // Main function. 44 int main(int argc, char* argv[])
 45 {
 46     Graph   graph;
 47     int iSrc = 0;
 48 
 49     CreateGraph(graph, true);
 50 
 51     ShowGraph(graph);
 52 
 53     cout<<"Input the source node of the shortest path:";
 54     cin>>iSrc;
 55 
 56     Dijkstra(graph, iSrc);
 57 
 58     return 0;
 59 }
 60 
 61 /**
 62 * brief  Create the graph.
 63 * param  [in/out] graph: the graph.
 64 *        [in] isDigraph: Create a digraph when this flag set true.
 65 * return none.
 66 */
 67 void CreateGraph( Graph& graph, bool isDigraph /*= false*/ )
 68 {
 69     cout<<"Create the graph"<<endl;
 70     cout<<"Input vertex size:"; 
 71     cin>>graph.mVertexSize;
 72 
 73     cout<<"Input arc size:";
 74     cin>>graph.mArcSize;
 75 
 76     // Input vertex 77     for (int iVertex = 0; iVertex < graph.mVertexSize; iVertex++)
 78     {
 79         cout<<"Input "<<iVertex+1<<" vertex value:";
 80         cin>>graph.mVertex[iVertex];
 81     }
 82 
 83     // Initialize adjacency matrix. 84     for (int i = 0; i < graph.mVertexSize; i++)
 85     {
 86         for (int j = 0; j < graph.mVertexSize; j++)
 87         {
 88             graph.mAdjMatrix[i][j].dWeight   = INFINITY;
 89         }
 90     }
 91 
 92     // Build adjacency matrix. 93     int     iInitial  = 0;
 94     int     iTerminal = 0;
 95     int     xPos    = 0;
 96     int     yPos    = 0;
 97     double  dWeight = 0;
 98 
 99     for (int k = 0; k < graph.mArcSize; k++)
100     {
101         cout<<"Input "<<k+1<<" arc initial node:";
102         cin>>iInitial;
103 
104         cout<<"Input "<<k+1<<" arc terminal node:";
105         cin>>iTerminal;
106 
107         cout<<"Input the weight:";
108         cin>>dWeight;
109 
110         xPos  = LocateVertex(graph, iInitial);
111         yPos  = LocateVertex(graph, iTerminal);
112 
113         graph.mAdjMatrix[xPos][yPos].dWeight = dWeight;
114 
115         if (!isDigraph)
116         {
117             graph.mAdjMatrix[yPos][xPos].dWeight = dWeight;
118         }
119     }
120 }
121 
122 /**
123 * brief  Show the weight of the graph arc.
124 * param  [in] graph
125 * return none.
126 */
127 void    ShowGraph(const Graph& graph)
128 {
129     cout<<"Show the graph represented by adjacency matrix:"<<endl;
130 
131     // Output adjacency matrix.132     for (int m = 0; m < graph.mVertexSize; m++)
133     {
134         for (int n = 0; n < graph.mVertexSize; n++)
135         {
136             cout<<graph.mAdjMatrix[m][n].dWeight<<"\t";
137         }
138 
139         cout<<endl;
140     }
141 }
142 
143 /**
144 * brief  Locate vertex position in the adjacency matrix.
145 * param  [in] graph:
146 *        [in] vertex: 
147 * return The position of the vertex. If not found return -1.
148 */
149 int LocateVertex( const Graph& graph, int vertex )
150 {
151     for (int i = 0; i < graph.mVertexSize; i++)
152     {
153         if (graph.mVertex[i] == vertex)
154         {
155             return i;
156         }
157     }
158 
159     return -1;
160 }
161 
162 /**
163 * brief  Dijkstra algorithm to find the shortest path.
164 * param  [in] graph.
165 *        [in] source node.
166 * return none.
167 */
168 void Dijkstra(const Graph& graph, int src )
169 {
170     int iMin = 0;
171     double dMin = 0;
172     double dTempMin = 0;
173 
174     // The distance between source node to the vi node.175     double dDist[VERTEX_NUM] = {0};
176 
177     // The set of all the shortest path node.178     bool bFinalSet[VERTEX_NUM] = {false};
179 
180     // Initialize status: if there is an arc between
181 // source node and vi node, set the distance to 
182 // its weight value.183     for (int i = 0; i < graph.mVertexSize; i++)
184     {
185         bFinalSet[i] = false;
186 
187         dDist[i] = graph.mAdjMatrix[src][i].dWeight;
188     }
189 
190     // Mark the visit flag.191     dDist[src] = 0;
192     bFinalSet[src] = true;
193 
194     // Dijstra algorithm: other N-1 vertex.195     for (int j = 1; j < graph.mVertexSize; j++)
196     {
197         // Find a vertex that its distance is the shortest
198 // to the source node.199         dMin = INFINITY;
200 
201         for (int k = 0; k < graph.mVertexSize; k++)
202         {
203             if ((!bFinalSet[k]) && (dDist[k] <= dMin))
204             {  
205                 iMin = k;
206                 dMin = dDist[k];
207             }
208         }
209 
210         // Add the nearest vertex to the final set.211         bFinalSet[iMin] = true;
212 
213         // Output the shortest path vertex and its distance.214         cout<<"The shortest path between "<<src<<" and "<<iMin<<" is: "<<dMin<<endl;
215 
216         // Update the shortest path.217         for (int l = 0; l < graph.mVertexSize; l++)
218         {
219             dTempMin = dMin + graph.mAdjMatrix[iMin][l].dWeight;
220 
221             if ((!bFinalSet[l]) && (dTempMin < dDist[l]))
222             {
223                 dDist[l] = dTempMin;
224             }
225         }
226     }
227 }
228 

相關推薦

【資料結構】單源路徑 Dijkstra演算法

單源最短路徑問題是指:對於給定的有向網路G=(V,E),求原點V0到其他頂點的最短路徑。 按照長度遞增的順序逐步產生最短路徑的方法,稱為Dijkstra演算法。 該演算法的基本思想: 把圖中的所有頂點分成兩組,第一組包括已確定最短路徑的頂點,初始時只含有一個源點,記為集合S;第

圖-路徑Dijkstra演算法和Floyd演算法

1.定義概覽 Dijkstra(迪傑斯特拉)演算法是典型的單源最短路徑演算法,用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴充套件,直到擴充套件到終點為止。Dijkstra演算法是很有代表性的最短路徑演算法,演算法使用了廣度優先搜尋解決賦權有向圖或者無向圖的單源

基礎演算法與資料結構(四)路徑——Dijkstra演算法

一般最短路徑演算法習慣性的分為兩種:單源最短路徑演算法和全頂點之間最短路徑。前者是計算出從一個點出發,到達所有其餘可到達頂點的距離。後者是計算出圖中所有點之間的路徑距離。 單源最短路徑 Dijkstra演算法 思維 本質上是貪心的思想,宣告一個數組dis來儲存源點到各個頂點的最短距離和一個儲存已經

單源路徑Dijkstra演算法

1.單源最短路徑 函式:返回還未被收錄頂點中dist最小者 1 Vertex FindMinDist(MGraph Graph, int dist[], int collected[]) 2 { 3 /*返回未被收錄頂點中dist最小者*/ 4 Vertex MinV, V;

分支限界法:單源路徑--dijkstra演算法

單源最短路徑–dijkstra演算法 前面已經多次介紹過dijkstra演算法是貪心演算法,是動態規劃,實際上可以從分支限界的角度來理解; 分支限界法 分支限界法,實際上就是回溯法,一般意義的回溯法是基於深度優先搜尋,也可以配合限界函式剪枝,通常分支限界法基於寬度優先搜尋,通過佇

單源路徑-----Dijkstra演算法

#include<iostream> using namespace std; int a[100][100]; //鄰接矩陣 int book[10]= {0}; //book陣列用來標記哪些點目前是最短的距離 int dist[10]; //dist陣列用來儲存

演算法——路徑——Dijkstra演算法

下學期開學大三,是到了該考慮前程的時候了。感覺自己大一大二演算法基礎沒打好,acm也沒參加,成績也不高,唉       所以大三努力吧,接下來就是多看演算法,多寫部落格每天一個演算法   第一個   Dijkstra演算法Dijkstra演算法是一個求最短路徑的演算法作用:求

求圖的鄰接表表示法的單源路徑 Dijkstra演算法

           要求帶權有向圖中某一頂點到其他各頂點的最短路徑,常用Dijkstra演算法,該演算法基本思想是,先將圖的頂點分為兩個集合,一個為已求出最短路徑的終點集合(開始為原點v1),另一個為還未求出最短路徑的頂點集合(開始為除v1外的全部結點),然後按最短路徑長

資料結構與演算法——路徑Dijkstra演算法的C++實現

#ifndef GRAPH_H #define GRAPH_H #include <list> #include <iostream> #include <vector> #include <stdlib.h> #include <string.h>

sdut 2622 路徑(Dijkstra演算法短路)

最短路徑 Time Limit: 1000ms   Memory limit: 65536K  有疑問?點這裡^_^ 題目描述 為了準備一年一度的校賽,大家都在忙著往賽場搬運東西

單源有權圖的路徑 Dijkstra演算法(證明不能解決負權邊)7.1.2

單源最短路徑問題,即在圖中求出給定頂點到其它任一頂點的最短路徑。  Dijkstra演算法 假設存在G=<V,E>,源頂點為0,U={0+已確定的最短路徑頂點},dist[i]記錄頂點0到頂點i的最短距離(包括確定的和估算的),path[i]記錄從0到i路徑上的

單源路徑-Dijkstra演算法

package com.data.struct; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import

紫書第十一章-----圖論模型與演算法路徑Dijkstra演算法Bellman-Ford演算法Floyd演算法

最短路徑演算法一之Dijkstra演算法 演算法描述:在無向圖 G=(V,E) 中,假設每條邊 E[i] 的長度為 w[i],找到由頂點 V0 到其餘各點的最短路徑。 使用條件:單源最短路徑,適用於邊權非負的情況 結合上圖具體搜尋過程,我繪出下表,方便

無向圖路徑dijkstra演算法

#include <iostream> using namespace std; const int maxnum = 100; const int maxint = 999999; //Dijkstra(n, 1, dist, prev, c); v

圖的單源路徑--Dijkstra演算法

我們在生活中經常會遇到這樣的問題,你要從家裡去圖書館,去健身房,去公司,那麼走哪一條路會最省時間,或者路程最短?你可能會先走xxx路,在轉到yyy路,最後轉了一圈終於走到了目的地,也可以直接開車上高速然後直達,其實這就是最短路徑的問題,哪一條路徑可以讓你走的路最少,這也是最

《圖論》——路徑 Dijkstra演算法(戴克斯特拉演算法)

十大演算法之Dijkstra演算法: 最短路徑是圖論演算法中的經典問題。圖分為有向圖、無向圖,路徑權值有正值、負值,針對不同的情況需要分別選用不同的演算法。在維基上面給出了各種不同的場景應用不同的演算法的基本原則:最短路問題。 針對無向圖,正權值路徑,採取Dijkstra

圖的路徑-Dijkstra演算法和Floyd演算法

Dijkstra演算法 單源點最短路徑問題 Dijkstra演算法主要用來解決單源點最短路徑問題。 給定帶權有向圖G=(V,E),其中每條邊的權是非負數。另外,還給定V中的一個頂點,稱為源。現在要計算從源到所有其他各頂點的最短路徑長度,這裡路徑的長度是指路徑上各邊權之和。這個問題

【資料結構】圖(路徑Dijkstra演算法)的JAVA程式碼實現

最短路徑的概念最短路徑的問題是比較典型的應用問題。在圖中,確定了起始點和終點之後,一般情況下都可以有很多條路徑來連線兩者。而邊或弧的權值最小的那一條路徑就稱為兩點之間的最短路徑,路徑上的第一個頂點為源點,最後一個頂點為終點。圖的最短路徑的演算法有很多,本文主要介紹狄克斯特拉(

單源路徑Dijkstra演算法----(附完整程式)

1.Dijkstra演算法 2.輸出最短路徑 #include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 #define INFINITY 65535 //#define MaxSize 10 typ

單源路徑Dijkstra演算法(C++)

最近複習圖演算法,練練手 先拿Dijkstra演算法開刀吧 以下是C++程式碼 包含:Dijkstra演算法函式(返回源節點到其餘節點之間的最短路徑)、路徑列印輸出函式 PS:本人只喜歡用vector,不喜歡用原生陣列;只喜歡string,不喜歡char