题目介绍

题目名称：GATE-CS-2015（套装1）第 30 题

该题目是关于计算机科学的算法和数据结构方面的问题。本题目需要掌握并实现贪心算法和最小生成树算法。

题目描述

在一个无向连通加权图中，假设有 $n$ 个顶点和 $m$ 条边。现在，要求从该图中选出一些边以获取利润，使得选出的边组成的子图仍然是连通的，并且边权之和最大。注意，选出的边必须恰好为 $n-1$ 条，即选出的边必须组成一棵生成树。

实现一个算法，在时间复杂度 $O(m\log n)$ 内求解该问题。

解题思路

本题目需要使用贪心算法和最小生成树算法。

首先，我们需要根据边的权重排序，然后从小到大选取 $n-1$ 条边，构成一棵生成树。在运用最小生成树算法时，我们可以使用 Prim 算法或者 Kruskal 算法。因为 Kruskal 算法的时间复杂度为 $O(m\log m)$，Prim 算法的时间复杂度为 $O(n^2)$，而 $m \gg n$，因此 Kruskal 算法更为适用。

要实现 $O(m\log n)$ 的时间复杂度，需要使用并查集对选取的边进行判断是否会造成环的形成。如果加入边的两个顶点已经属于同一个并查集，则说明加入这条边会形成环，不符合生成树的定义，不应该加入；如果不在同一个并查集，则说明这两个顶点之间的边可以被加入生成树中。

代码片段

以下是使用 Kruskal 算法实现的代码片段，其中使用了并查集，并对边的权重进行了排序。

class Graph {
    class Edge implements Comparable<Edge> {
        int src, dest, weight;
        
        public int compareTo(Edge compareEdge) {
            return this.weight - compareEdge.weight;
        }
    };
    
    class subset {
        int parent, rank;
    };
    
    int V, E;
    Edge edge[];
    
    Graph(int v, int e) {
        V = v;
        E = e;
        edge = new Edge[E];
        for (int i = 0; i < e; ++i)
            edge[i] = new Edge();
    }
    
    int find(subset subsets[], int i) {
        if (subsets[i].parent != i)
            subsets[i].parent = find(subsets, subsets[i].parent);
        return subsets[i].parent;
    }
    
    void Union(subset subsets[], int x, int y) {
        int xroot = find(subsets, x);
        int yroot = find(subsets, y);
        
        if (subsets[xroot].rank < subsets[yroot].rank)
            subsets[xroot].parent = yroot;
        else if (subsets[xroot].rank > subsets[yroot].rank)
            subsets[yroot].parent = xroot;
        else {
            subsets[yroot].parent = xroot;
            subsets[xroot].rank++;
        }
    }
    
    void KruskalMST() {
        Edge result[] = new Edge[V];
        int e = 0, i = 0;
        for (i = 0; i < V; ++i)
            result[i] = new Edge();
            
        Arrays.sort(edge);
        
        subset subsets[] = new subset[V];
        for (i = 0; i < V; ++i)
            subsets[i] = new subset();
            
        for (int v = 0; v < V; ++v) {
            subsets[v].parent = v;
            subsets[v].rank = 0;
        }
        
        i = 0;
        while (e < V - 1) {
            Edge next_edge = edge[i++];
            
            int x = find(subsets, next_edge.src);
            int y = find(subsets, next_edge.dest);
            
            if (x != y) {
                result[e++] = next_edge;
                Union(subsets, x, y);
            }
        }
        
        System.out.println("Following are the edges in " + 
                            "the constructed MST");
        int minimumCost = 0;
        for (i = 0; i < e; ++i) {
            System.out.println(result[i].src + " -- " + 
                               result[i].dest + " == " + 
                               result[i].weight);
            minimumCost += result[i].weight;
        }
        System.out.println("Minimum Cost Spanning Tree " +
                            minimumCost);
    }
}