图相关算法-CSDN博客

本文链接：https://blog.csdn.net/qq_40728028/article/details/108290248

Dijkstra：

package path;

import java.util.PriorityQueue;
import java.util.Scanner;

/**
 *  Dijkstra算法：一张图中，选定一个原点，求剩余点中，任意一点到该原点的最短距离。
 */
public class DijkstraPath {
    static class DataNode implements Comparable<DataNode>{
        int v;
        int distance;
        DataNode(int v,int distance){
            this.v=v;
            this.distance=distance;
        }

        @Override
        public int compareTo(DataNode o) {
            return this.distance-o.distance;
        }
    }

    private static int [][] matrix;
    //  distance[i]对象中的distance属性表示：i点与原点之间的最短距离
    private static DataNode [] distance;
    private static PriorityQueue<DataNode> priority=new PriorityQueue<>();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        matrix=new int[n+1][n+1];

        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            matrix[a][b]=matrix[b][a]=c;
        }
        distance=new DataNode[n+1];
        distance[1]=new DataNode(1,0);
        priority.add(distance[1]);
        for (int i=2;i<=n;i++){
            distance[i]=new DataNode(i,Integer.MAX_VALUE);
            priority.add(distance[i]);
        }

        while (!priority.isEmpty()){
            //  取出当前距离原点最小的点
            DataNode cur=priority.poll();
            //  以当前点为基准，计算与当前邻接点与原点的最小值,此次只计算，取出最小的在下一次循环
            int curV=cur.v;
            int curDistance=cur.distance;
            for (int j=1;j<=n;j++){
                if (matrix[curV][j]!=0){
                    if (distance[j].distance>curDistance+matrix[curV][j]){
                        //  distance[j]与priority引用的是同一个对象，但是直接修改distance[j]的
                        //  distance属性值（在priority中比较的属性），在priority中不会进行优先级
                        //  调整，原因是，调整优先级只会发生在添加添加元素时。
                        priority.remove(distance[j]);
                        distance[j].distance=curDistance+matrix[curV][j];
                        //  在遍历与i相邻的点j时，下一次遍历j时可能又会访问到i,所以需要进行处理
                        priority.add(distance[j]);
                    }
                    //  没有必要一定要置为0，但置为0，可以避免下一次j找相邻点时再次访问到curV
                    matrix[j][curV]=0;
                }
            }
        }

        for (int i=1;i<=n;i++){
            System.out.println(distance[i].distance);
        }
    }

}
/*
5 8
1 2 10
1 3 5
1 5 8
2 3 3
2 4 1
3 4 9
3 5 2
4 5 6

0 8 5 9 7
 */
/*
    算法解析：
        用v表示点集合，u表示已经计算过的点的集合,dist[i]表示点i到原点的最小距离。
        初始时：u为空，dist[i]=int的最大值，dist[原点]=0。
        计算过程：在v-u中取dist最小的点i，以点i为中心，计算邻接点j，通过经过i点的最短路径，
        即（原dist[j]的值与当前点dist[i]+i与j之间路径的最小值），最后将i点加入到u中。
        依次执行上述操作，直至v与u相同。

    注意：Dijkstra只能处理边全为正数的情况，这也是上面可以把 从当前的curV去找完相邻的j后，把
            j到curV的路径进行销毁掉，即matrix[j][curV]=0的原因，是为了防止在访问j时，再次去判断
            j到curV的情况。之所以断定本次从curV到j的路径一定小于下次j到curV的路径短，
            就是因为路径全是正数，每往前走一步路径就加长。

     具体实现：
        用优先级队列来作为 v-u（未操作的点集），同时还便于从中取出dist最小的点。
        另外，由于dist的值在计算中要发生变化，而且优先级中的点也是根据dist来进行排序，
        所以让优先级队列引用dist[i]，以便才队列中移除dist[i]，修改值后再次加入队列，进行
        优先级排列。
 */

Dijkstra2：

package path;

import java.util.PriorityQueue;
import java.util.Scanner;

public class DijkstraPath_Instance01 {
    static class DataNode implements Comparable<DataNode>{
        int v;
        int distance;
        DataNode(int v,int distance){
            this.v=v;
            this.distance=distance;
        }

        @Override
        public int compareTo(DataNode o) {
            return this.distance-o.distance;
        }
    }

    private static int [][] matrix;
    private static DataNode [] distance;
    private static PriorityQueue<DataNode> priority=new PriorityQueue<>();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        matrix=new int[n+1][n+1];

        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            matrix[a][b]=matrix[b][a]=c;
        }
        distance=new DataNode[n+1];
        distance[1]=new DataNode(1,0);
        priority.add(distance[1]);
        for (int i=2;i<=n;i++){
            distance[i]=new DataNode(i,Integer.MAX_VALUE);
            priority.add(distance[i]);
        }

        while (!priority.isEmpty()){
            DataNode cur=priority.poll();
            int curV=cur.v;
            int curDistance=cur.distance;
            if (curV==n){
                break;
            }
            for (int j=1;j<=n;j++){
                if (matrix[curV][j]!=0){
                    if (distance[j].distance>curDistance+matrix[curV][j]){
                        priority.remove(distance[j]);
                        distance[j].distance=curDistance+matrix[curV][j];
                        priority.add(distance[j]);
                    }
                    matrix[j][curV]=0;
                }
            }
        }

        System.out.println(distance[n].distance);
    }

}

Floyd

package path;

import java.util.Scanner;

public class Floyd {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int [][] matrix=new int[n+1][n+1];
        init(matrix);

        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            matrix[a][b]=matrix[b][a]=c;
        }

        for (int k=1;k<=n;k++){
            for (int i=1;i<=n;i++){
                for (int j=1;j<=n;j++){
                    if (matrix[i][k]+matrix[k][j]<matrix[i][j]){
                        matrix[i][j]=matrix[i][k]+matrix[k][j];
                    }
                }
            }
        }

        System.out.println(matrix[1][n]);
    }

    private static void init(int [][] a){
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a.length;j++){
                if (i!=j){
                    a[i][j]=Integer.MAX_VALUE;
                }
            }
        }
    }
}
/*
    Floyd算法的基本思想是，对于点i,j，开一通过在i,j之间加入一些中转站，来降低直接从i到j
    的路径。

    注意：
        1.Floyd使用于有向图；
        2.不适用于负环
 */

Kruskal

package path;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Kruskal_instance01 {

   static class Node implements Comparable<Node>{
       int v1;
       int v2;
       double e;
       Node(int v1,int v2,double e){
           this.v1=v1;
           this.v2=v2;
           this.e=e;
       }

       @Override
       public int compareTo(Node o) {
           return this.e<o.e?-1:1;
       }
   }

    private static int [] fa;
    private static int getFather(int x){
        if (fa[x]==x){return x;}
        return fa[x]=getFather(fa[x]);
    }

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        fa=new int[n];
        for (int i=0;i<n;i++){
            fa[i]=i;
        }

        int [][] vs=new int[n][2];
        for (int i=0;i<n;i++){
            vs[i][0]=in.nextInt();
            vs[i][1]=in.nextInt();
        }

        List<Node> list=new ArrayList<>();
        for (int i=0;i<n-1;i++){
            for (int j=i+1;j<n;j++){
                double e=Math.sqrt((vs[j][0]-vs[i][0])*(vs[j][0]-vs[i][0])+(vs[j][1]-vs[i][1])*(vs[j][1]-vs[i][1]));
                list.add(new Node(i,j,e));
            }
        }
        Collections.sort(list);

        int cnt=n-1;
        double res=0.0;
        for (int i=0;i<list.size()&&cnt>0;i++){
            Node edge=list.get(i);
            int fv1=getFather(edge.v1);
            int fv2=getFather(edge.v2);
            if (fv1!=fv2){
                cnt--;
                res+=edge.e;
                fa[fv1]=fv2;
            }
        }

        System.out.printf("%.2f",res);
    }


}

Kruskal2

package path;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Kruskal_Instance02 {

    private static int [] fa;

    static class Node implements Comparable<Node>{
        int v1;
        int v2;
        int e;
        Node(int v1,int v2,int e){
            this.v1=v1;
            this.v2=v2;
            this.e=e;
        }

        @Override
        public int compareTo(Node o) {
            return this.e-o.e;
        }
    }

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        fa=new int[n+1];
        List<Node> list=new ArrayList<>();
        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            list.add(new Node(a,b,c));
        }

        Collections.sort(list);

        int res=Integer.MAX_VALUE;
        for (int i=0;i<=m-1-(n-1)+1;i++){
            res=Math.min(res,getMinTreeFromIndex(i,list));
        }
        if (res==Integer.MAX_VALUE){
            System.out.println(-1);
        }else{
            System.out.println(res);
        }
    }

    private static int getMinTreeFromIndex(int index,List<Node> list){
        int n=fa.length-1;
        for (int i=1;i<=n;i++){
            fa[i]=i;
        }
        int cnt=n-1;
        int min=Integer.MAX_VALUE;
        int max=Integer.MIN_VALUE;
        for (int i=index;i<list.size()&&cnt>0;i++){
            Node edge=list.get(i);
            int fv1=getFather(edge.v1);
            int fv2=getFather(edge.v2);
            if (fv1!=fv2){
                cnt--;
                fa[fv1]=fv2;
                if (edge.e<min){
                    min=edge.e;
                }
                if (edge.e>max){
                    max=edge.e;
                }
            }
        }
        if (cnt>0){
            return Integer.MAX_VALUE;
        }
        return max-min;
    }

    private static int getFather(int x){
        if (fa[x]==x){return x;}
        return fa[x]=getFather(fa[x]);
    }
}
/*
问题描述
蒜头君所在的国家有 n 个城市，现在需要在城市之间修高速公路，有 m 条修路的方案，每个方案表示 a, b 城市之间修一条限速为 c 的高速公路。蒜头君希望从这 m 个方案中选出若干方法试行，能够让 n 座城市联通，并且希望所有高速公路中最高限速和最低限速的差值最小。
输入格式
第一行输入两个整数 n,m（2≤n≤100，1<=m<=n(n-1)/2 ），表示有 n 个城市，m 条修路方案。两个城市之间可能会有多条修路方案。
接下来输入 m 行，每行输入三个整数 a，b，c（1≤a,b≤n，0≤c≤1,0000）。
输出格式
如果修路方案不能让 nn 个城市之间联通，输出 -1，否者输出最小的差值。
样例输入
4 4
1 2 2
2 3 4
1 4 1
3 4 2
样例输出
1


本题没有什么特殊的技巧，就是把边排序后，一次以edge[i]为最小边去构造最小生成树，然后求差值

 */

MinTree_Kruskal

package path;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 * Kruskal算法生成最小生成树
 */
public class MinTree_Kruskal {

    static class Node implements Comparable<Node>{
        int v1;
        int v2;
        int e;
        Node(int v1,int v2,int e){
            this.v1=v1;
            this.v2=v2;
            this.e=e;
        }

        @Override
        public int compareTo(Node o) {
            return this.e-o.e;
        }
    }

    private static int [] fa;


    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int [][] matrix=new int[n][n];
        List<Node> list=new ArrayList<>();
        for (int i=0;i<n;i++){
            for (int j=0;j<n;j++){
                matrix[i][j]=in.nextInt();
                if (j>i){
                    list.add(new Node(i,j,matrix[i][j]));
                }
            }
        }
        fa=new int[n];
        for (int i=0;i<n;i++){
            fa[i]=i;
        }

        Collections.sort(list);
        int res=0;
        int cnt=n;
        for (int i=0;i<list.size()&&cnt>1;i++){
            Node edge = list.get(i);
            int fv1=getFather(edge.v1);
            int fv2=getFather(edge.v2);
            if (fv1!=fv2){
                cnt--;
                res += edge.e;
                fa[fv1]=fa[fv2];
            }
        }

        System.out.println(res);
    }

    private static int getFather(int x){
        if (x==fa[x]){return x;}
        return fa[x]=getFather(fa[x]);
    }

}
/*

    Kruskal算法用来求解一个图中，生成的最小生成树（生成树的N-1条边，他们的和最小）

    分析：
        对于有n个顶点的一个图，他的最小生成树边数一定为n-1。因为要生成最小生成树，
        所以可以对边进行升序排序。依次取出边来构造一个最小生成树，在构造的过程中，
        要保证不能形成环（如果又环，那么n个点不可能是n-1条边）。其保证的方式就是：
        一开始让每个点都是一颗单独的树，合并边时，让边上的点所代表的树进行合并。
        当从小到大合并n-1条边后，最小生成树也就形成了。

    特性：
        1. 一个图的多个生成树中，构成每棵树的最大边的最小值，存在于最小生成树中。
        2. 求次小生成树：先求出最小生成树，。然后一次去掉最小生成树中的边，再求剩余边构成的
            最小生成树，最后取其中的最小值。
        3.
 */

拓扑排序

package path;

import java.util.*;


/*
    座山雕要为手下的n个兄弟分钱，有m个人提出了建议（a分的钱应该比b多，多1即可）。
    试求能否同时满足这m个人的建议，若不能输出Unhappy!若能输出最少的分配钱的方案。
    其中每个人至少分得100。
 */

/**
 * @Description: 拓扑排序
 * @date: 2020/3/11/011-12:45
 * @author: xiqixing
 */
public class Sort_Instance01 {

    static class Node{
        int inNum;
        LinkedList<Integer> outEdge;
        int money;
        Node(int inNum,LinkedList<Integer> outEdge){
            this.inNum=inNum;
            this.outEdge=outEdge;
        }
    }

    private static HashMap<Integer,Node> links;

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        links=new HashMap<>(n*4/3+1);
        for (int i=1;i<=n;i++){
            links.put(i,new Node(0,new LinkedList<>()));
        }
        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            links.get(b).outEdge.add(a);
            links.get(a).inNum++;
        }

        Deque<Integer> queue=new ArrayDeque<>();
        for (int i=1;i<=n;i++){
            Node node=links.get(i);
            if (node.inNum==0){
                node.money=100;
                queue.add(i);
            }
        }

        if (queue.size()==0){
            System.out.println("Unhappy!");
            return;
        }
        int res=0;
        int count=0;
        while (!queue.isEmpty()){
            int size=queue.size();
            for (int i=0;i<size;i++){
                int curV=queue.poll();
                Node curNode=links.get(curV);
                res+=curNode.money;
                count++;
                for (Integer nextV : curNode.outEdge){
                    Node nextNode=links.get(nextV);
                    nextNode.inNum--;
                    nextNode.money=curNode.money+1;
                    if (nextNode.inNum==0){
                        queue.add(nextV);
                    }
                }
            }
        }
        if (count<n){
            System.out.println("Unhappy!");
        }else{
            System.out.println(res);
        }
    }
}
/*
该题是提到拓扑排序的题目：
    所谓拓扑排序指的就是，对于一件事b，需要把它之前的前提工作a1,a2,a2...都完成了才可以做。

    排序思想：
        找出入度为0的点，将与它相邻的点的入度都减一，若相邻点减一后的入度为0，则下一次就可以
        处理该点。
        同时，若最后处理的点的总数小于点的总数，则表明该拓扑图中存在环，即无法进行拓扑排序。

 */

SPFA：

package path;

import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.Scanner;

public class SPFA {

    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        boolean [] inQueue=new boolean[n+1];
        int [] dist=new int[n+1];
        int [][] matrix=new int[n+1][n+1];

        for (int i=0;i<m;i++){
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            matrix[a][b]=matrix[b][a]=c;
        }

        Arrays.fill(dist,Integer.MAX_VALUE);
        dist[1]=0;
        Deque<Integer> queue=new ArrayDeque<>();
        queue.add(1);
        inQueue[1]=true;

        while (!queue.isEmpty()){
            int size=queue.size();
            for (int i=0;i<size;i++){
                int curV=queue.poll();
                inQueue[curV]=false;
                for (int j=1;j<=n;j++){
                    if (matrix[curV][j]!=0){
                        if (dist[curV]+matrix[curV][j]<dist[j]){
                            dist[j]=dist[curV]+matrix[curV][j];
                            if (!inQueue[j]){
                                //  此处的判断是一种优化，直接进行add操作不会出现错误。
                                if (!queue.isEmpty()&&dist[j]<dist[queue.peekFirst()]){
                                    queue.addFirst(j);
                                }else{
                                    queue.add(j);
                                }
                            }
                            //  SPFA可以处理存在负边的情况，所以计算完从curV到j后，就不能断定
                            // 后面从j到i再到时的值一定比现在大。
                            //matrix[curV][j]=matrix[j][curV]=0;
                        }
                    }
                }
            }
        }
        System.out.println(dist[n]);
    }
}
/*

    SPFA算法描述：首先他也是解决单源最短路问题，其思想与无向图的BFS类似。
    用一个队列来存储下一次将要处理的点，用inQueue来表示一个点是否现在在队列中，
    用dist来表示每一个点距离原点的最短距离。
    初始时，将原点加入队列；除了1外，其他点的dist为int的最大值。
    然后只要队列不空，依次取出队列中的值（当前要处理的点v）（这里因为存在着负边，
    所以要将inQueue[i]=false,因为可能会出现经过负边后，再次回到该点。），访问该点
    的邻接点，当从v到j的路径小于dist[j]（原来从原点到j的最短路径）时：
        更新dist[j]的值，同时如果j没有入队，则将j入队。

    SPFA算法相较于Dijkstra算法来说，可以进行负边的处理。
    对于稀疏图，SPFA有更快的性能，对于稠密图，Dijkstra有着更好的性能。

    同时还能进行负环（整个环综合加起来为一个负数）的判断，使用一个cnt[i]来记录每个点
    进入队列的次数，当任意一个点进入队列的次数超过点的总个数n（更准确地说是环的结点数,即<=n），
    此时就可以说该图存在负环。原因是，如果有一个负环，那么每绕环一圈，经过环中点的路径就是变小，
    所以就会进入死循环中。

 */