leetcode 685. 冗余连接 II

分析

分为两种情况

1. [[1,2], [2,3], [3,4], [4,1], [1,5]] 只有一个闭环不符合要求
2. [[1,5],[3,2],[2,4],[4,5],[5,3]] 有一个节点入度为2。

定义两个数组 u,v分别表示每一个节点的入度和出度，当目前分析的边的两个节点都已经分析过了，即：((u[a] > 0 && v[b] > 0) || (u[b] > 0 && v[a] > 0) || (u[a] > 0 && u[b] > 0) || (v[a] > 0 && v[b] > 0))a,b为当前边的两个节点。记下这个边。

if((u[a] > 0 && v[b] > 0) || (u[b] > 0 && v[a] > 0) || (u[a] > 0 && u[b] > 0) || (v[a] > 0 && v[b] > 0)){
	k = i;
}

然后寻找入度为2的边，如果找到为第二种情况，没有找到为第一种情况。

1. 没有找到，那么就是记录的最后一条边。

re.push_back(edges[k][0]);
re.push_back(edges[k][1]);
return re;

2. 找到了。分别判断去除一条边是否符合要求。
   应该先判断第二条边，再判断第一条边，这样可以返回最后出现在给定二维数组的答案

if(pd(edges,m) == 0){
    re.push_back(edges[m][0]);
    re.push_back(edges[m][1]);
    return re;
}
else if(pd(edges,n) == 0) {
    re.push_back(edges[n][0]);
    re.push_back(edges[n][1]);
    return re;
}
else{
    re.push_back(edges[m][0]);
    re.push_back(edges[m][1]);
    return re;
}

完整代码如下：

在判断是否符合条件时要判断是否时连通图即可。代码中多写了判断是否有回路了

class Solution {
public:
    int pd(vector<vector<int>> edges,int e){
        int size = edges.size();  //顶点的个数
        edges.erase(edges.begin() + e);
        int u[1005] = {0};
        int v[1005] = {0};
        for(int i = 0;i < size-1;i++){
            int a = edges[i][0];
            int b = edges[i][1];
            u[a]++;
            v[b]++;
        }
        //判断是否是连通图
        bool fl[1005] = {false};
        fl[1] = true;
        queue<int> q;
        q.push(1);
        while(q.empty() == false){
            int now = q.front();
            q.pop();
            for(int i = 0;i < size-1;i++){
                if(edges[i][0] == now){
                    int n = edges[i][1];
                    if(fl[n] == false){
                        fl[n] = true;
                        q.push(n);
                    }
                }
                if (edges[i][1] == now){
                    int n = edges[i][0];
                    if(fl[n] == false){
                        fl[n] = true;
                        q.push(n);
                    }
                }
            }
        }
        for(int i = 1;i <= size;i++){
            if(fl[i] == false)
                return -1;
        }
        for(int i = 1;i <= size;i++){
            if((u[i] == 0 && v[i] > 0) || (u[i] > 0 && v[i] == 0)){
                return 0;
            }
        }
        return -1;
    }
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int size = edges.size(); //size也是点的个数
        int u[1005] = {0};  //出度
        int v[1005] = {0};  //入度
        vector<int> re;
        // u[1] = true;
        int k = -1;
        for(int i = 0;i < size; i++){
            int a = edges[i][0];
            int b = edges[i][1];
            if((u[a] > 0 && v[b] > 0) || (u[b] > 0 && v[a] > 0) || (u[a] > 0 && u[b] > 0) || (v[a] > 0 && v[b] > 0)){
                k = i;
            }
            u[a]++;
            v[b]++;
        }
        //找到有两个入度的点
        int x = -1;
        for(int j = 1;j <= size;j++){
            if(v[j] == 2){
                x = j;
                break;
            }
        }
        if(x == -1){   //这是只有一个闭环的情况
            re.push_back(edges[k][0]);
            re.push_back(edges[k][1]);
            return re;
        }
        int n = -1;
        int m = -1; //两条边
        for(int j = 0;j < size;j++){
            if(edges[j][1] == x){
                if(n == -1)
                    n = j;
                else 
                    m = j;
            }
        }
        //减去边判断是否是树
        if(pd(edges,m) == 0){
            re.push_back(edges[m][0]);
            re.push_back(edges[m][1]);
            return re;
        }
        else if(pd(edges,n) == 0) {
            re.push_back(edges[n][0]);
            re.push_back(edges[n][1]);
            return re;
        }
        else{
            re.push_back(edges[m][0]);
            re.push_back(edges[m][1]);
            return re;
        }
        return re;
    }
};