OpenAI最新モデル「GPT-4.1」完全ガイド｜業務活用・性能進化・料金まで解説

重み付きグラフにおける最短経路を見つけるダイクストラ法をJavaで実装してください。主要なステップを説明するコメントを含めてください。

import java.util.*;

// Graphのエッジを表現するクラス
class Edge {
    int targetVertex;
    int weight;

    public Edge(int targetVertex, int weight) {
        this.targetVertex = targetVertex;
        this.weight = weight;
    }
}

// ダイクストラ法を実装するクラス
class Dijkstra {
    // グラフの全頂点数
    private int vertices;
    // 隣接リストでグラフを表現
    private List<List<Edge>> adjList;

    public Dijkstra(int vertices) {
        this.vertices = vertices;
        // 初期化
        adjList = new ArrayList<>();
        for (int i = 0; i < vertices; i++) {
            adjList.add(new ArrayList<>());
        }
    }

    // グラフにエッジを追加するメソッド
    public void addEdge(int source, int target, int weight) {
        adjList.get(source).add(new Edge(target, weight));
    }

    // ダイクストラのアルゴリズム
    public void dijkstra(int startVertex) {
        // 各頂点への最短距離を格納する配列
        int[] distances = new int[vertices];
        // 全ての距離を無限大（もしくは十分大きな数）で初期化
        Arrays.fill(distances, Integer.MAX_VALUE);
        // 始点の距離は0
        distances[startVertex] = 0;

        // 最小ヒープを使用して次に処理する頂点を決定
        PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(e -> e.weight));
        // 始点をキューに追加
        priorityQueue.add(new Edge(startVertex, 0));

        while (!priorityQueue.isEmpty()) {
            // 最小距離の頂点を取り出す
            Edge currentEdge = priorityQueue.poll();
            int currentVertex = currentEdge.targetVertex;

            // 現在の頂点に接続された辺をすべて探索
            for (Edge edge : adjList.get(currentVertex)) {
                int neighborVertex = edge.targetVertex;
                int newDist = distances[currentVertex] + edge.weight;

                // より短いパスが見つかった場合
                if (newDist < distances[neighborVertex]) {
                    distances[neighborVertex] = newDist;
                    priorityQueue.add(new Edge(neighborVertex, newDist));
                }
            }
        }

        // 最短経路の結果を出力
        printShortestPaths(startVertex, distances);
    }

    // 最短距離を出力
    private void printShortestPaths(int startVertex, int[] distances) {
        System.out.println("Vertex\t\tDistance from Source " + startVertex);
        for (int i = 0; i < vertices; i++) {
            System.out.println(i + "\t\t" + distances[i]);
        }
    }

    // メインメソッド
    public static void main(String[] args) {
        int vertices = 5;
        Dijkstra graph = new Dijkstra(vertices);
        // エッジを追加
        graph.addEdge(0, 1, 9);
        graph.addEdge(0, 2, 6);
        graph.addEdge(0, 3, 5);
        graph.addEdge(0, 4, 3);
        graph.addEdge(2, 1, 2);
        graph.addEdge(2, 3, 4);

        // ダイクストラ法を実行
        graph.dijkstra(0);
    }
}

import java.util.*;

public class DijkstraAlgorithm {
    // 辺を表すクラス
    static class Edge {
        int to, weight;
        Edge(int to, int weight) {
            this.to = to;
            this.weight = weight;
        }
    }

    // ダイクストラ法を実行するメソッド
    public static int[] dijkstra(List<List<Edge>> graph, int start) {
        int n = graph.size();
        int[] dist = new int[n]; // 各頂点への最短距離
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
        pq.add(new int[]{0, start}); // {現在の距離, 頂点}

        while (!pq.isEmpty()) {
            int[] current = pq.poll();
            int curDist = current[0], u = current[1];

            // より短い経路がすでに見つかっている場合はスキップ
            if (curDist > dist[u])
                continue;

            // 隣接する頂点をすべて確認
            for (Edge edge : graph.get(u)) {
                int v = edge.to;
                int weight = edge.weight;

                // より短い経路が見つかった場合は更新
                if (dist[v] > dist[u] + weight) {
                    dist[v] = dist[u] + weight;
                    pq.add(new int[]{dist[v], v});
                }
            }
        }
        return dist;
    }

    // サンプルのメイン処理
    public static void main(String[] args) {
        int n = 5; // 頂点数
        List<List<Edge>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) graph.add(new ArrayList<>());

        // グラフ構築（例：双方向）
        graph.get(0).add(new Edge(1, 2));
        graph.get(0).add(new Edge(2, 4));
        graph.get(1).add(new Edge(2, 1));
        graph.get(1).add(new Edge(3, 7));
        graph.get(2).add(new Edge(4, 3));
        graph.get(3).add(new Edge(4, 1));
        // 必要なら逆方向も追加

        int start = 0;
        int[] dist = dijkstra(graph, start);

        // 結果を出力
        for (int i = 0; i < n; i++) {
            System.out.println("頂点 " + i + " までの最短距離: " + dist[i]);
        }
    }
}

午前8時にA駅を出発し、時速60マイルで300マイル離れたB駅に向かう列車があります。午前9時にB駅を出発し、時速75マイルで平行な線路をA駅に向かう別の列車があります。2つの列車は何時に出会いますか？ステップバイステップで推論を示してください。

列車Aと列車Bが出会う時間を求めるために、それぞれの列車が出発してからの距離を計算します。

列車Aの距離を式で表す。

出発時間: 午前8時
速度: 60マイル/時
距離（マイル） = 60 × 時間（時間）

列車Bの距離を式で表す。

出発時間: 午前9時
速度: 75マイル/時
距離（マイル） = 75 × (時間 - 1)
※午前9時に出発するので、A駅を出発してからの時間は1時間後になります。

出会う条件を設定する。

列車Aの距離 + 列車Bの距離 = 300マイル
60t + 75(t - 1) = 300

方程式を解く。

60t + 75t - 75 = 300

135t - 75 = 300

135t = 375

t = 375 / 135

t = 2.777... 時間

時間を分に変換。

0.777... × 60 ≈ 46.67分

列車が出会う時刻を求める。

午前8時から2時間46分後なので、午前10時46分に出会います。

したがって、2つの列車は午前10時46分に出会います。

この問題を順を追って解いていきましょう。

1. 移動する列車の出発時刻と速度
A駅発（A→B方向）：午前8時出発、時速60マイル
B駅発（B→A方向）：午前9時出発、時速75マイル
両駅の距離は 300マイル です。

2. 各列車の動きを整理
8時〜9時（A駅発の列車だけが進む）
8時から9時まで、A駅発の列車だけが進む。
その1時間で進む距離は： ( 60 \text{マイル/時} \times 1 \text{時間} = 60 \text{マイル} )
9時になった時点で、A駅発の列車はすでにA駅から60マイル進んでいる。
残りのA駅〜B駅間の距離は： ( 300 - 60 = 240 \text{マイル} )

3. 9時以降、2台の列車が向かい合って進む
両列車の合計接近速度： ( 60 \text{マイル/時} + 75 \text{マイル/時} = 135 \text{マイル/時} )
残り240マイルをこの速度で近づいていく。

4. 出会うまでの時間を計算
必要な時間：
( \frac{240 \text{マイル}}{135 \text{マイル/時}} = \frac{240}{135} = \frac{16}{9} \approx 1.78 \text{時間} )

1時間は60分なので
( 0.78 \times 60 \approx 47 )分

よって、9時から1時間47分後に出会う。

5. 出会う時刻
( 9:00 + 1:47 = 10:47 )
まとめ
2つの列車は午前10時47分に出会います。

【計算手順のまとめ】
8〜9時はA駅発のみが動き60マイル進む（残り240マイル）。
9時から合計135マイル/時で近づく。
240 ÷ 135 = 約1.78時間 ≒ 1時間47分
9:00 + 1:47 = 10:47