(107)685. 冗余连接 II(leetcode)

题目链接：
https://leetcode-cn.com/problems/redundant-connection-ii/submissions/
难度：困难
685. 冗余连接 II
	在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。
	输入一个有向图，该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
	结果图是一个以边组成的二维数组。 每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u 和顶点 v 的边，其中 u 是 v 的一个父节点。
	返回一条能删除的边，使得剩下的图是有N个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。
示例 1:
	输入: [[1,2], [1,3], [2,3]]
	输出: [2,3]
	解释: 给定的有向图如下:
	  1
	 / \
	v   v
	2-->3
示例 2:
	输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
	输出: [4,1]
	解释: 给定的有向图如下:
	5 <- 1 -> 2
	     ^    |
	     |    v
	     4 <- 3
	注意:
	二维数组大小的在3到1000范围内。
	二维数组中的每个整数在1到N之间，其中 N 是二维数组的大小。

今天 10.3 今天发每日一题 很久很久之前做过 就不写了。。。 然后补上这个拉下一个多星期的题 嗯 有点难啊。。。。

并查集：查询是否有环 (查看是否有环)
vector：确定每个节点的父节点是什么 (确认是否有冲突)
然后最重要的是：
若有冲突：分为包含环与不包含环 （冲突的边为 当前的u，v和paents[v]，v）
      1. 无环 返回（u，v）
      2. 有环 返回（parents[v],v）
若没有冲突只有环 那么输出多余的环即可 （枚举所有edges后 保证所选中的边是最后一个）
记录个坐标题解

// 并查集
class Unionfind{
public:
    vector<int> unionvec;
    Unionfind(int n){
        unionvec.resize(n);
        for(int i=0;i<n;++i){
            unionvec[i]=i;
        }
    }
    int find(int id){
        if(unionvec[id]==id){
            return id;
        }else{
            unionvec[id]=find(unionvec[id]);
            return unionvec[id];
        }
    }

    void merge(int u,int v){
        unionvec[find(u)]=find(v);
    }
};
class Solution {
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int eagenums=edges.size();
        Unionfind unionfind(eagenums+1);
        vector<int> parents(eagenums+1);
        for(int i=1;i<=eagenums;++i){
            parents[i]=i;
        }
        int conflict =-1;
        int cycle=-1;
        for(int i=0;i<eagenums;++i){
            int u=edges[i][0];
            int v=edges[i][1];
            if(parents[v]!=v){
                conflict=i;
            }else{
                parents[v]=u;
                if(unionfind.find(u)==unionfind.find(v)){
                    cycle=i;
                }else{
                    unionfind.merge(u,v);
                }
            }
        }
        // 没有冲突 有环
        if(conflict<0){
            auto redundant = vector<int> {edges[cycle][0], edges[cycle][1]};
            return redundant;
        }else{
            // 有冲突的情况下 分为有环无环
            // 有环
            auto t=edges[conflict];
            if(cycle>=0){
                auto redundant = vector<int> {parents[t[1]],t[1]};
                return redundant;
            }else{
                auto redundant = vector<int> {t[0],t[1]};
                return redundant;
            }
        }
    }
};