【LeetCode每日一题】——684.冗余连接

一【题目类别】

• 图

二【题目难度】

• 中等

三【题目编号】

• 684.冗余连接

四【题目描述】

• 在本问题中, 树指的是一个连通且无环的无向图。
• 输入一个图，该图由一个有着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是输入数组的大小。

七【题目更新】

• 更新(2017-09-26):
• 我们已经重新检查了问题描述及测试用例，明确图是无向 图。对于有向图详见冗余连接II。对于造成任何不便，我们深感歉意。

八【解题思路】

• 是一个使用并查集通过加入边重新生成图的过程，每次更新当前节点的父节点，如果此时来了一条边，查询两个节点的父节点相同，说明已经联通了，那么加入的这个边就是冗余的边，返回即可

九【时间频度】

• 时间复杂度：$O(N)$

十【代码实现】

1. Java语言版

package Graph;

import java.util.Arrays;

public class p684_RedundantConnection {

    public static void main(String[] args) {
        int[][] edges = {
                {1, 2},
                {1, 3},
                {2, 3},
        };
        int[] res = findRedundantConnection(edges);
        System.out.println("res = " + Arrays.toString(res));
    }

    public static int[] findRedundantConnection(int[][] edges) {
        // 定义辅助数组，长度为结点个数 + 1
        int[] nums = new int[edges.length + 1];
        // 给数组赋初值，开始每个结点的父节点就是自己
        for (int k = 0; k < nums.length; k++) {
            nums[k] = k;
        }
        // 开始遍历每一条边
        for (int i = 0; i < edges.length; i++) {
            // 找到每一个边的第一个结点的父节点
            int f1 = findRoot(edges[i][0], nums);
            // 找到每一个边的第二个结点的父节点
            int f2 = findRoot(edges[i][1], nums);
            // 如果两个结点的父节点相等，说明这两个结点构成的边是重复的
            if (f1 == f2) {
                return edges[i];
            }
            // 如果不相等，那么连接这两个边
            else {
                nums[f1] = f2;
            }
        }
        return null;
    }

    public static int findRoot(int n, int[] nums) {
        // 当当前结点的父节点不是自己，将父节点赋值给当前结点，并返回
        while (nums[n] != n) {
            n = nums[n];
        }
        return n;
    }

}

2. C语言版

#include
#include
#include

#define MAX(a,b) ((a) > (b) ? (a) : (b))

bool is_same;

int findRoot(int *nums, int n)
{
	if (n == nums[n])
	{
		return n;
	}
	nums[n] = findRoot(nums, nums[n]);
	return nums[n];
}

void merge(int *nums, int r1, int r2)
{
	int f1 = findRoot(nums, r1);
	int f2 = findRoot(nums, r2);
	if (f1 == f2)
	{
		is_same = true;
		return f1;
	}
	if (f1 < f2)
	{
		nums[f2] = f1;
	}
	else {
		nums[f1] = f2;
	}
}

int res[2];

/*利用并查集的特点，当出现冗余连接时，连接的两个结点，其根结点相同*/
int* findRedundantConnection(int** edges, int edgesSize, int* edgesColSize, int* returnSize)
{
	int max = 0;
	for (int i = 0; i < edgesSize; i++)
	{
		max = MAX(max, edges[i][0]);
		max = MAX(max, edges[i][1]);
	}

	int *nums = (int *)malloc(max + 1, sizeof(int));

	for (int i = 0; i <= max; i++)
	{
		nums[i] = i;
	}

	is_same = false;

	for (int i = 0; i < edgesSize; i++)
	{
		int r1 = edges[i][0];
		int r2 = edges[i][1];
		merge(nums, r1, r2);
		if (is_same == true)
		{
			res[0] = r1;
			res[1] = r2;
			break;
		}
	}
	*returnSize = 2;
	return res;
}

/*主函数省略*/

十一【提交结果】

1. Java语言版
   
2. C语言版