684. Redundant Connection-冗余连接

原题：

In this problem, a tree is an undirected graph that is connected and has no cycles.

The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, ..., N), with one additional edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.

The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] with u < v, that represents an undirected edge connecting nodes u and v.

Return an edge that can be removed so that the resulting graph is a tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array. The answer edge [u, v] should be in the same format, with u < v.

Example 1:

Input: [[1,2], [1,3], [2,3]]
Output: [2,3]
Explanation: The given undirected graph will be like this:
  1
 / \
2 - 3

Example 2:

Input: [[1,2], [2,3], [3,4], [1,4], [1,5]]
Output: [1,4]
Explanation: The given undirected graph will be like this:
5 - 1 - 2
    |   |
    4 - 3

Note:
The size of the input 2D-array will be between 3 and 1000.
Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.

题目剖析：无向图连接，有的连接可以通过多条连接实现同样的效果，题目要求将这种冗余的连接找出来。

题目本质：将冗余连接视为聚类问题，相关节点聚到一个簇，即可求出

题目过程：并查集思想，动态查找算法，每次都假设一条边可以找到冗余边，据此进行查找计算。 坐标代表每个数值，以最小最开始的数作为每一簇的标志，进行标记，递归查找，最终所有簇归拢到一个标记。两点找到的标记相同则认为是冗余边。

存在问题：如果环嵌套，也无妨，因为最终要确认的两个点是否冗余连接，是直接联系的两点，如果是则有直接的连接，这两个点所在的路是通畅的。

应用：确定两点之间是否有直接的关系，如果有则会将路径找出来。

 

java版本解决代码

package com.jd.jr.nlp;

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

public class Solution684Diy {

    private void union(int[] parent,int start,int end){
//        parent[start]=find(parent,start);
        parent[find(parent,end)]=find(parent,start);
    }

    private int find(int[] parent,int x){
        return parent[x]==0? (parent[x]=x): parent[x]==x ? x: find(parent,parent[x]);
    }

    public int[] findRedundantConnection(int[][] edges) {
        int[] parent=new int[1095];
        int[] res=new int[0];

        for(int i=0;i<edges.length;i++){
            if(find(parent,edges[i][0])==find(parent,edges[i][1])){
                res=edges[i];

            }else {
                union(parent,edges[i][0],edges[i][1]);
            }
        }
        return res;
    }

    public static void main(String[] args){
//        List<List<Integer>> lists=new ArrayList<>();
//        lists.add(Arrays.asList(1,2));
//        lists.add(Arrays.asList(1,3));
//        lists.add(Arrays.asList(2,3));

//        int[][] lists=new int[3][2];
//        lists[0][0]=1;
//        lists[0][1]=2;
//        lists[1][0]=1;
//        lists[1][1]=3;
//        lists[2][0]=2;
//        lists[2][1]=3;


//        [[1,2], [2,3], [3,4], [1,4], [1,5]]
//        int[][] lists=new int[5][2];
//        lists[0][0]=1;
//        lists[0][1]=2;
//
//        lists[1][0]=2;
//        lists[1][1]=3;
//
//        lists[2][0]=3;
//        lists[2][1]=4;
//
//        lists[3][0]=1;
//        lists[3][1]=4;
//
//        lists[4][0]=1;
//        lists[4][1]=5;

//        [[1,4],[3,4],[1,3],[1,2],[4,5]]

        int[][] lists=new int[5][2];
        lists[0][0]=1;
        lists[0][1]=4;

        lists[1][0]=3;
        lists[1][1]=4;

        lists[2][0]=1;
        lists[2][1]=3;

        lists[3][0]=1;
        lists[3][1]=2;

        lists[4][0]=4;
        lists[4][1]=5;

        Solution684Diy solution684Std=new Solution684Diy();
        int[] result=solution684Std.findRedundantConnection(lists);
        System.out.println(result);
    }


}