web-dev-qa-db-ja.com

Java-距離加重マップ内の2点間の最短経路を見つける

道路の距離が数字で示されるマップ内の2つのポイント間の最短パスを見つけるアルゴリズムが必要です。

与えられているもの：開始都市A宛先都市Z

都市間の距離のリスト：

A-B：10
F-K：23
R-M：8
K-O：40
Z-P：18
J-K：25
D-B：11
M-A：8
P-R：15

ダイクストラのアルゴリズムを使用できると考えましたが、すべての目的地までの最短距離を見つけます。 1つだけではありません。

どんな提案も大歓迎です。

javapathshortest
11
sanjan

SplinterRealityが言ったように：There's no reason not to use Dijkstra's algorithm here.

以下のコードは here からニックネームを付け、質問の例を解決するために修正しました。

import Java.util.PriorityQueue;
import Java.util.List;
import Java.util.ArrayList;
import Java.util.Collections;

class Vertex implements Comparable<Vertex>
{
    public final String name;
    public Edge[] adjacencies;
    public double minDistance = Double.POSITIVE_INFINITY;
    public Vertex previous;
    public Vertex(String argName) { name = argName; }
    public String toString() { return name; }
    public int compareTo(Vertex other)
    {
        return Double.compare(minDistance, other.minDistance);
    }

}


class Edge
{
    public final Vertex target;
    public final double weight;
    public Edge(Vertex argTarget, double argWeight)
    { target = argTarget; weight = argWeight; }
}

public class Dijkstra
{
    public static void computePaths(Vertex source)
    {
        source.minDistance = 0.;
        PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();
        vertexQueue.add(source);

        while (!vertexQueue.isEmpty()) {
            Vertex u = vertexQueue.poll();

            // Visit each Edge exiting u
            for (Edge e : u.adjacencies)
            {
                Vertex v = e.target;
                double weight = e.weight;
                double distanceThroughU = u.minDistance + weight;
                if (distanceThroughU < v.minDistance) {
                    vertexQueue.remove(v);

                    v.minDistance = distanceThroughU ;
                    v.previous = u;
                    vertexQueue.add(v);
                }
            }
        }
    }

    public static List<Vertex> getShortestPathTo(Vertex target)
    {
        List<Vertex> path = new ArrayList<Vertex>();
        for (Vertex vertex = target; vertex != null; vertex = vertex.previous)
            path.add(vertex);

        Collections.reverse(path);
        return path;
    }

    public static void main(String[] args)
    {
        // mark all the vertices 
        Vertex A = new Vertex("A");
        Vertex B = new Vertex("B");
        Vertex D = new Vertex("D");
        Vertex F = new Vertex("F");
        Vertex K = new Vertex("K");
        Vertex J = new Vertex("J");
        Vertex M = new Vertex("M");
        Vertex O = new Vertex("O");
        Vertex P = new Vertex("P");
        Vertex R = new Vertex("R");
        Vertex Z = new Vertex("Z");

        // set the edges and weight
        A.adjacencies = new Edge[]{ new Edge(M, 8) };
        B.adjacencies = new Edge[]{ new Edge(D, 11) };
        D.adjacencies = new Edge[]{ new Edge(B, 11) };
        F.adjacencies = new Edge[]{ new Edge(K, 23) };
        K.adjacencies = new Edge[]{ new Edge(O, 40) };
        J.adjacencies = new Edge[]{ new Edge(K, 25) };
        M.adjacencies = new Edge[]{ new Edge(R, 8) };
        O.adjacencies = new Edge[]{ new Edge(K, 40) };
        P.adjacencies = new Edge[]{ new Edge(Z, 18) };
        R.adjacencies = new Edge[]{ new Edge(P, 15) };
        Z.adjacencies = new Edge[]{ new Edge(P, 18) };


        computePaths(A); // run Dijkstra
        System.out.println("Distance to " + Z + ": " + Z.minDistance);
        List<Vertex> path = getShortestPathTo(Z);
        System.out.println("Path: " + path);
    }
}

上記のコードは以下を生成します。

Distance to Z: 49.0
Path: [A, M, R, P, Z]
35
luke

推定サンジャン：

ダイクストラのアルゴリズムの背後にある考え方は、グラフのすべてのノードを順番に探索することです。アルゴリズムは優先度キューを格納します。ノードは開始からのコストに従って順序付けられ、アルゴリズムの各反復で次の操作が実行されます。

  1. 開始から最低コストのノードNをキューから抽出します
  2. 近隣（N '）および関連コストを取得します。これは、cost（N）+ cost（N、N'）です。
  3. 隣接ノードN 'をキューに挿入します。優先度はコストで指定されます

アルゴリズムが開始点（この場合はA）と残りのすべてのノードとの間のパスのコストを計算するのは事実ですが、目標（この例ではZ）に達すると、アルゴリズムの探索を停止できます。この時点で、AとZの間のコストと、それらを接続するパスがわかります。

独自にコーディングする代わりに、このアルゴリズムを実装するライブラリを使用することをお勧めします。 Javaでは、グラフを生成し、検索アルゴリズムの使用を開始する非常に友好的な方法を持つ Hipsterライブラリ を見ることができます。

ここでは、グラフを定義し、DijstraをHipsterで使用する方法の例を示します。

// Create a simple weighted directed graph with Hipster where
// vertices are Strings and Edge values are just doubles
HipsterDirectedGraph<String,Double> graph = GraphBuilder.create()
  .connect("A").to("B").withEdge(4d)
  .connect("A").to("C").withEdge(2d)
  .connect("B").to("C").withEdge(5d)
  .connect("B").to("D").withEdge(10d)
  .connect("C").to("E").withEdge(3d)
  .connect("D").to("F").withEdge(11d)
  .connect("E").to("D").withEdge(4d)
  .buildDirectedGraph();

// Create the search problem. For graph problems, just use
// the GraphSearchProblem util class to generate the problem with ease.
SearchProblem p = GraphSearchProblem
  .startingFrom("A")
  .in(graph)
  .takeCostsFromEdges()
  .build();

// Search the shortest path from "A" to "F"
System.out.println(Hipster.createDijkstra(p).search("F"));

グラフの定義を独自のものに置き換えてから、例のようにアルゴリズムをインスタンス化するだけです。

これがお役に立てば幸いです！

5
Adrián González

これは遅すぎるかもしれませんが、アルゴリズムがどのように機能するかについての明確な説明はありませんでした

ダイクストラのアイデアは単純です。次の擬似コードでこれを示しましょう。

ダイクストラは、すべてのノードを2つの異なるセットに分割します。不安定で落ち着いた。最初は、すべてのノードが未設定のセットにあります。それでも評価する必要があります。

最初は、ソースノードのみがsettledNodeのセットに配置されます。特定のノードは、ソースから特定のノードまでの最短パスが見つかった場合、解決済みセットに移動します。

アルゴリズムは、unsettledNodesセットが空になるまで実行されます。各反復で、unsettledNodesセットからソースノードまでの距離が最も短いノードを選択します。例えば。ソースから発信されるすべてのエッジを読み取り、まだ解決されていないこれらのエッジから各宛先ノードを評価します。

選択したエッジを使用するときに、ソースからこのノードまでの既知の距離を短縮できる場合、距離が更新され、評価が必要なノードにノードが追加されます。

ダイクストラは、ソースに向かう途中で各ノードの先行バージョンも決定することに注意してください。それを単純化するために、擬似コードから除外しました。

クレジットへのクレジット Lars Vogel

3
user3829791

移動できるノードのリストを、開始ノードからの距離でソートして維持します。最初は、開始ノードのみがリストに含まれます。

目的地に到達していない場合：開始ノードに最も近いノードにアクセスします。これは、ソートされたリストの最初のノードになります。ノードにアクセスするとき、既にアクセスしたノードを除くすべての隣接ノードをリストに追加します。繰り返す！

1
Akinakes

Java 8、再帰とストリーム-> Javaのダイクストラアルゴリズム を使用して完全な例を見ることができます。

0
Jesus Dana