web-dev-qa-db-ja.com

Floyd-Warshall、Dijkstra、Bellman-Fordのアルゴリズムの違いについては正しいですか？

私は3つを研究してきました、そして私はそれらからの私の推論を以下に述べています。私がそれらを十分に正確に理解したかどうか誰かに教えてもらえますか？ありがとうございました。

  1. ダイクストラのアルゴリズムは、ソースが1つで、あるノードから別のノードへの最小パスを知りたい場合にのみ使用されますが、 this のような場合は失敗します。

  2. Floyd-Warshallのアルゴリズムは、すべてのノードのいずれかがソースになる可能性がある場合に使用されるため、任意のソースノードから任意の宛先ノードに到達するための最短距離が必要です。これは、負のサイクルがある場合にのみ失敗します

（これは最も重要なものです。つまり、これは私が最も確信が持てないものです：）

3.Bellman-Fordは、ソースが1つしかない場合、ダイクストラのように使用されます。これは負の重みを処理でき、その動作は1つのソースを除いて、Floyd-Warshallと同じですよね？

確認する必要がある場合、対応するアルゴリズムは次のとおりです（提供：ウィキペディア）。

ベルマンフォード：

 procedure BellmanFord(list vertices, list edges, vertex source)
   // This implementation takes in a graph, represented as lists of vertices
   // and edges, and modifies the vertices so that their distance and
   // predecessor attributes store the shortest paths.

   // Step 1: initialize graph
   for each vertex v in vertices:
       if v is source then v.distance := 0
       else v.distance := infinity
       v.predecessor := null

   // Step 2: relax edges repeatedly
   for i from 1 to size(vertices)-1:
       for each Edge uv in edges: // uv is the Edge from u to v
           u := uv.source
           v := uv.destination
           if u.distance + uv.weight < v.distance:
               v.distance := u.distance + uv.weight
               v.predecessor := u

   // Step 3: check for negative-weight cycles
   for each Edge uv in edges:
       u := uv.source
       v := uv.destination
       if u.distance + uv.weight < v.distance:
           error "Graph contains a negative-weight cycle"

ダイクストラ：

 1  function Dijkstra(Graph, source):
 2      for each vertex v in Graph:                                // Initializations
 3          dist[v] := infinity ;                                  // Unknown distance function from 
 4                                                                 // source to v
 5          previous[v] := undefined ;                             // Previous node in optimal path
 6                                                                 // from source
 7      
 8      dist[source] := 0 ;                                        // Distance from source to source
 9      Q := the set of all nodes in Graph ;                       // All nodes in the graph are
10                                                                 // unoptimized - thus are in Q
11      while Q is not empty:                                      // The main loop
12          u := vertex in Q with smallest distance in dist[] ;    // Start node in first case
13          if dist[u] = infinity:
14              break ;                                            // all remaining vertices are
15                                                                 // inaccessible from source
16          
17          remove u from Q ;
18          for each neighbor v of u:                              // where v has not yet been 
19                                                                                 removed from Q.
20              alt := dist[u] + dist_between(u, v) ;
21              if alt < dist[v]:                                  // Relax (u,v,a)
22                  dist[v] := alt ;
23                  previous[v] := u ;
24                  decrease-key v in Q;                           // Reorder v in the Queue
25      return dist;

フロイド-ウォーシャル：

 1 /* Assume a function edgeCost(i,j) which returns the cost of the Edge from i to j
 2    (infinity if there is none).
 3    Also assume that n is the number of vertices and edgeCost(i,i) = 0
 4 */
 5
 6 int path[][];
 7 /* A 2-dimensional matrix. At each step in the algorithm, path[i][j] is the shortest path
 8    from i to j using intermediate vertices (1..k−1).  Each path[i][j] is initialized to
 9    edgeCost(i,j).
10 */
11
12 procedure FloydWarshall ()
13    for k := 1 to n
14       for i := 1 to n
15          for j := 1 to n
16             path[i][j] = min ( path[i][j], path[i][k]+path[k][j] );
algorithmgraph-theorydijkstrafloyd-warshallbellman-ford
22
GrowinMan

最初の2つの質問と、Floyd-Warshallの目標（すべてのペア間の最短経路を見つける）については正しいですが、Bellman-FordとFloyd-Warshallの関係については正しくありません。どちらのアルゴリズムも動的計画法を使用して最短を見つけます。パスですが、FWは、各開始ノードから他のすべてのノードにBFを実行することと同じではありません。

BFでは、問題は次のとおりです。最大kステップを使用してソースからターゲットまでの最短パスはどれくらいですか。実行時間はO（E V）です。他のノードに対して実行する場合、実行時間はO（E V ^ 2）になります。

FWでは、問題は次のとおりです。すべてのノードi、j、kについて、iからjを経由してkを経由する最短経路は何ですか。これにより、O（V ^ 3）の実行時間が発生します。これは、各開始ノードのBFよりも優れています（密グラフの場合は最大| V |の係数）。

負のサイクル/重みに関するもう1つの注意：ダイクストラは単に正しい結果を出せない可能性があります。 BFとFWは失敗しません。負の重みには制限がないため、最小の重みパスがないことを正しく示します。

19
Guy Adini

単一ソースの最短パス：

ダイクストラアルゴリズム-負の重みは許可されていません-O（E + Vlg（V））

ベルマンフォードアルゴリズム-負の重みが許可されます。しかし、負のサイクルが存在する場合、ベルマンフォードは-veサイクルを検出します-O（VE）

有向非巡回グラフ-名前が示すように、DAGでのみ機能します-O（V + E）

すべてのペアの最短経路：

ダイクストラアルゴリズム-負の重みは許可されません-O（VE + V ^ 2lg（V））

ベルマンフォードアルゴリズム-O（V ^ 2E）

行列の連鎖乗積法-ベルマンフォードアルゴリズムと同じ複雑さ

フロイドウォーシャルアルゴリズム-動的計画法を使用-複雑さはO（V ^ 3）

8
arunmoezhi