图算法

最新推荐文章于 2025-09-07 20:32:33 发布

转载最新推荐文章于 2025-09-07 20:32:33 发布 · 58 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/xinyi-blog/p/9240541.html

文章标签：

#java

本文详细介绍了两种经典的最短路径算法——Dijkstra算法和弗洛伊德算法。通过具体的Java代码实现，展示了如何求解节点之间的最短路径问题。Dijkstra算法适用于没有负权边的情况，而弗洛伊德算法则可以处理任意权值的边。

1.Dijkstra

import java.util.*;
 
public class Main{
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int s = sc.nextInt();
            int t = sc.nextInt();
            List<List<Node>> list = new ArrayList<List<Node>>();
            for(int i=0;i<=n;i++){
                list.add(new ArrayList<Node>());
            }
            for (int i = 1; i <= m; i++) {
                int start = sc.nextInt();
                int end = sc.nextInt();
                int len = sc.nextInt();
                list.get(start).add(new Node(end,len));
            }
            int distance1 = getDistance(list, s, t, n);
            int distance2 = getDistance(list, t, s, n);
            System.out.println(distance1 + distance2);
        }
    }
    private static int getDistance(List<List<Node>> list,int s,int t,int n){
        PriorityQueue<Node> nodes = new PriorityQueue<>(n, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o1.length-o2.length;
            }
        });
        nodes.add(new Node(s,0));
        boolean[] used = new boolean[n+1];
        int[] dis = new int[n+1];
        Arrays.fill(dis,Integer.MAX_VALUE);
        dis[s] = 0;
        while(!nodes.isEmpty()){
            Node node = nodes.poll();
            if(used[node.end]){
                continue;
            }
            used[node.end]=true;
            if(node.end==t){
                return node.length;
            }
            List<Node> subList = list.get(node.end);
            for(Node tempNode : subList){
                if(used[tempNode.end]){
                    continue;
                }
                if(dis[tempNode.end]>node.length+tempNode.length){
                    dis[tempNode.end]=node.length+tempNode.length;
                    nodes.add(new Node(tempNode.end,dis[tempNode.end]));
                }
            }
        }
        return 0;
    }
}
class Node{
    int end;
    int length;
    public Node(int end,int length){
        this.end=end;
        this.length=length;
    }
}

2.弗洛伊德

import java.util.*;

public class Main{
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[][] dis = new int[n+1][n+1];
            for(int i=1;i<=n;i++){
                Arrays.fill(dis[i],Integer.MAX_VALUE);
                dis[i][i]=0;
            }
            for(int i=0;i<m;i++){
                int x = sc.nextInt();
                int y = sc.nextInt();
                int len = sc.nextInt();
                dis[x][y] = len;
                dis[y][x] = len;
            }
            for(int k=1;k<=n;k++){
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        int length = (dis[i][k]==Integer.MAX_VALUE||dis[k][j]==Integer.MAX_VALUE)?Integer.MAX_VALUE:dis[i][k]+dis[k][j];
                        if(length<dis[i][j]){
                            dis[i][j]=length;
                        }
                    }
                }
            }
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    System.out.print(dis[i][j]+" ");
                }
                System.out.println();
            }
        }
    }
}