685. 冗余连接 II

 

判环我们常用的方法是并查集，但是这个题是有向图，然后寻找有根树，什么是有根树呢？

 

 

 根据题目大意，本题的有向图是在有根树的基础上形成了，也就是在有根树的基础上加了一条边，然后我们的任务就是要找出这条边，如果有多种情况，那么找到序号最大的边。

在我们添加完边后有2种情况，

1 第一种，图中不存在入度为2点的，即图中所有的点都是入度为1的，这样一定会存在一个环，我们只需要把图当成无向图来处理，然后通过并查集来判树就好了。

2 第二种，图中存在入度为2的点，也就是说这个点由两个父亲，那么我们只需要判断这两个父亲和这个点形成的边，然后删去其中一个，看能不能成一棵树就好了。

code:

class Solution {
public:
    int in[1000+3];
    int fa[1000+3];
    vector<int>v[1000+3];
    int cnt=0;
    bool mark[1000+3];
    bool istree(vector<vector<int>>&edges,int pos){
        memset(mark,0,sizeof mark);
        for(int i=0;i<edges.size();i++){
            if(i==pos) continue ;
            v[edges[i][0]].push_back(edges[i][1]);
        } 
        int n=edges.size();
        for(int i=1;i<=n;i++){
            if(in[i]==0){  
                dfs(i);
            }
        }
        return cnt==n;
    }
    void dfs(int x){
        if(mark[x]) return ;
        cnt++;
        for(int i=0;i<v[x].size();i++){
             dfs(v[x][i]);
        }
    }
    int find(int x){
        return fa[x]==x ? x:fa[x]=find(fa[x]);
    }
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int n=edges.size();
        vector<int >ve;
        int flag=-1;
        for(int i=0;i<n;i++){
            in[edges[i][1]]++;
            fa[i+1]=i+1;
            if(in[edges[i][1]]==2){
                flag=edges[i][1];  
            }
        }
        for(int i=0;i<n;i++){
            if(edges[i][1]==flag){
                ve.push_back(i);
            }
        }
        vector<int >ans;
        if(ve.size()==0){
            int x,y;
            for(int i=0;i<edges.size();i++){
                int u=find(edges[i][0]);
                int v=find(edges[i][1]);
                if(u!=v) {
                    fa[v]=u;
                }
                else {
                    x=edges[i][0];
                    y=edges[i][1];
                }
            }
            ans.push_back(x);
            ans.push_back(y);
            return ans;
        }
        else {
            if(istree(edges,ve[1])){
                ans.push_back(edges[ve[1]][0]);
                ans.push_back(edges[ve[1]][1]);
                return ans;
            }
            else {
                ans.push_back(edges[ve[0]][0]);
                ans.push_back(edges[ve[0]][1]);
                return ans;
            }
        }
        
    }
};