Leetcode 1584. 连接所有点的最小费用 Prim算法+Kruskal算法实现

一、问题描述

Leetcode 1584. 连接所有点的最小费用

题目的👍数：303
题目的👎数：24

给你一个points 数组，表示 2D 平面上的一些点，其中 points[i] = [xi, yi] 。

连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 ：|xi - xj| + |yi - yj| ，其中 |val| 表示 val 的绝对值。

请你返回将所有点连接的最小总费用。只有任意两点之间 有且仅有 一条简单路径时，才认为所有点都已连接。

输入：points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
输出：20
解释：

我们可以按照上图所示连接所有点得到最小总费用，总费用为 20 。
注意到任意两个点之间只有唯一一条路径互相到达。

二、解题思路

一个典型的最小生成树问题
prim算法的关键在于利用min数组动态记录每个节点与树之间的最小距离
kruskal算法的关键在于利用并查集记录连通的元素

三、代码

class Solution { //prim算法实现
    public int minCostConnectPoints(int[][] points) {
        //最小生成树？XX 整个拓扑图的长度最短
        //最短路径？XX 两个点之间的路径最短
        return prim(points);
    }

    public int prim(int[][] points) {//普利姆算法：加点法，复杂度和点有关，适合于稠密图
        //1、更新所有未选择的点到已选择的点的最小距离
        //2、选择最小距离的点加入
        int number = points.length;//number代表有多少个点
        int[] min = new int[number];//min数组保存未加入的点到树的最短距离，每次我们根据这个数组来选择应该加入哪个点
        int[] flag = new int[number];//flag数组记录点是否已经加入，也可以直接用min数组来记录，访问到即记为-1
        int[][] dis = new int[number][number];//dis数组保存点与点之间的距离

        for(int i = 0;i<number;++i) {
            for(int j = 0;j<number;++j) {
                if(i == j) dis[i][j] = Integer.MAX_VALUE;
                else dis[i][j] = Math.abs(points[i][0]-points[j][0]) + Math.abs(points[i][1]-points[j][1]);
            }
            min[i] = dis[i][0];
        }

        int cost = 0;
        flag[0] = 1;
        for(int i = 1;i<number;++i) {
            int next = -1;
            int curMinDis = Integer.MAX_VALUE;
            for(int j = 0;j<number;++j) { //找到下一个插入的点,即是min数组的最小值，初始化数组全为dis[i][0]，因为我们从0点开始出发
                if(flag[j] == 0 && min[j] < curMinDis) {
                    next = j;
                    curMinDis = min[j];
                }
            }
            flag[next] = 1;
            cost += curMinDis;
            for(int j = 0;j<number;++j) { //更新数组，保证每一步我们取的都是最小值
                min[j] = Math.min(min[j],dis[next][j]);
            }
        }
        return cost;
    }
}

class Solution {//Kruskal算法实现
    public int minCostConnectPoints(int[][] points) {
        //最小生成树？XX 整个拓扑图的长度最短
        //最短路径？XX 两个点之间的路径最短
        return kruskal(points);
    }

    class Edge { //使用这个类是因为我们需要不断加入边，并且对边进行排序
        int p1;
        int p2;
        int distance;
        public Edge(int p1,int p2,int distance) {
            this.p1 = p1;
            this.p2 = p2;
            this.distance = distance;
        }
    }

    //并查集，UF，对于每个点都记录其的root节点
    public boolean union(int p1,int p2,int[] rec) {//false代表没有两个点的根不同，即没有连在树内
        int rootP1 = find(p1,rec);
        int rootP2 = find(p2,rec);
        rec[rootP1] = rootP2; //两个根节点指向一起
        if(rootP1 != rootP2) return false;
        else return true;
    }

    public int find(int target,int[] rec) {
        int root = target;
        while(root != rec[root]) {
            root = rec[root];
        }
        int cur = target;
        while(cur != root) {
            rec[cur] = root;
            cur = rec[cur];
        }
        return root;
    }

    public int kruskal(int[][] points) {//克鲁斯卡尔算法:加边法，复杂度和边有关，适合于稀疏图
        //1、对所有的边进行排序，时间复杂度？
        //2、选择最小的边，并用并查集判断该边对应的两个点是否已经加入到树中
        int length = points.length;
        Edge[] edges = new Edge[length*length];

        for(int i = 0;i<length;++i) {//初始化距离数组
            for(int j = 0;j<length;++j) {
                int distance = i == j ? Integer.MAX_VALUE:Math.abs(points[i][0]-points[j][0]) + Math.abs(points[i][1]-points[j][1]);
                edges[i*length+j] = new Edge(i,j,distance);
            }
        }

        Arrays.sort(edges,new Comparator<Edge>() { //排序
            @Override
            public int compare(Edge e1,Edge e2) {
                return e1.distance-e2.distance;
            }
        });

        int[] rec = new int[length];//初始化并查集数组
        for(int i = 0;i<length;++i) rec[i] = i;
        int count = 0;
        int cost = 0;
        for(int i = 0;i<edges.length && count<length-1;++i) {
            Edge edge = edges[i];
            int p1 = edge.p1;
            int p2 = edge.p2;
            if(union(p1,p2,rec) == false) {
                ++count;
                cost+=edge.distance;
            }
        }
        return cost;
    }
}