LeetCode——冗余连接/以图判树

Q：在本问题中, 树指的是一个连通且无环的无向图。
输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。
返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。

示例 1：
输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
1
/
2 - 3
示例 2：
输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
      |    |
　　4 - 3
注意:
输入的二维数组大小在 3 到 1000。
二维数组中的整数在1到N之间，其中N是输入数组的大小。

A：

典型的并查集问题

并查集类：

public class Union {
    int count;//树的个数
    int[] root;//每个点的根节点
    int[] size;//一棵树的节点数

    Union(int m) {
        root = new int[m];
        size = new int[m];
        for (int i = 0; i < m; i++) {
            root[i] = i;//初始点，每个点的根节点都是自己
            size[i] = 1;//每棵树只有1个节点
        }
        count = m;//总共有m棵树
    }

    public void unionF(int i, int j) {
        int x = find(i);//i的根节点
        int y = find(j);//j的根节点
        if (x != y) {
            if (size[x] > size[y]) {//x树更大，把y接上去
                root[y] = x;
                size[y] += size[x];
            } else {//y树更大，把x接上去
                root[x] = y;
                size[x] += size[y];
            }
            count--;
        }
    }

    public int find(int j) {
        while (root[j] != j) {
            //这句是为了压缩路径，不要的话可以跑的通，但效率变低
            root[j] = root[root[j]];
            j = root[j];
        }
        return j;
    }

    public int count() {
        return count;
    }

    public boolean connected(int i, int j) {
        int x = find(i);
        int y = find(j);
        return x == y;
    }
}

代码：如果两个点曾经已经连接过了，再次连接说明是冗余连接

    public int[] findRedundantConnection(int[][] edges) {
        int num = edges.length;
        Union u = new Union(num);
        for (int[] edge : edges) {
            if (u.connected(edge[0] - 1, edge[1] - 1))
                return edge;
            u.unionF(edge[0] - 1, edge[1] - 1);
        }
        return new int[]{};
    }

Q：

给定从 0 到 n-1 标号的 n 个结点，和一个无向边列表（每条边以结点对来表示），请编写一个函数用来判断这些边是否能够形成一个合法有效的树结构。

示例 1：

输入: n = 5, 边列表 edges = [[0,1], [0,2], [0,3], [1,4]]
输出: true
示例 2:

输入: n = 5, 边列表 edges = [[0,1], [1,2], [2,3], [1,3], [1,4]]
输出: false
注意：你可以假定边列表 edges 中不会出现重复的边。由于所有的边是无向边，边 [0,1] 和边 [1,0] 是相同的，因此不会同时出现在边列表 edges 中。

A：

首先，如果形成了一棵树，那么边数量一定是点数量-1.

如果两个点曾经已经连接过了，再次连接说明是冗余连接，不为树。

然后同样用并查集解决：

    public boolean validTree(int n, int[][] edges) {
        if (edges.length != n - 1)
            return false;
        Union u = new Union(n);
        for (int i = 0; i < edges.length; i++) {
            if (u.connected(edges[i][0], edges[i][1]))
                return false;
            u.unionF(edges[i][0], edges[i][1]);
        }
        return true;
    }