单源最短路径问题1 (Bellman-Ford算法)

最新推荐文章于 2026-03-08 00:05:55 发布

转载最新推荐文章于 2026-03-08 00:05:55 发布 · 315 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：http://www.cnblogs.com/Alpharun/p/8658054.html

标签

#java

本文详细介绍了一种解决单源最短路径问题的算法——Bellman-Ford算法，并通过Java代码实现了该算法。示例中，算法应用于一个具有57条边的图，通过迭代更新顶点的距离，最终输出了从起点到所有其他顶点的最短距离。

/*
单源最短路径问题1 (Bellman-Ford算法)
样例：
    5 7
    0 1 3
    0 3 7
    1 2 4
    1 3 2
    2 3 5
    2 4 6
    3 4 4
输出：
    [0, 3, 7, 5, 9]
*/


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Test {
    //图的顶点数,总边数
    static int V, E;
    //存储所有的边,大小为顶点数
    static ArrayList<Edge>[] Edges;
    static int[] d;

    public static void main(String[] args) {
        creatGraph();
        shortPath(0);
        System.out.println(Arrays.toString(d));
    }

    static void shortPath(int start) {
        d=new int[V];
        Arrays.fill(d,999999);
        d[start]=0;
        for (int v = 0; v < V; v++) {
            for (int i = 0; i < Edges[v].size(); i++) {
                Edge next = Edges[v].get(i);
                d[next.v] = Math.min(d[v] + next.weight, d[next.v]);
            }
        }
    }

    static void creatGraph() {
        Scanner sc = new Scanner(System.in);
        V = sc.nextInt();
        E = sc.nextInt();
        Edges = new ArrayList[V];
        for (int i = 0; i < V; i++) {
            Edges[i] = new ArrayList<Edge>();
        }
        for (int i = 0; i < E; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            int w = sc.nextInt();
            Edges[u].add(new Edge(v, w));
            Edges[v].add(new Edge(u, w));
        }
        for (ArrayList<Edge> i : Edges) {
            System.out.println(i);
        }
    }
}

class Edge {
    int v;
    int weight;

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

    @Override
    public String toString() {
        return "Edge{" +
                "v=" + v +
                ", weight=" + weight +
                '}';
    }
}