发现环

问题描述

　　小明的实验室有N台电脑，编号1~N。原本这N台电脑之间有N-1条数据链接相连，恰好构成一个树形网络。在树形网络上，任意两台电脑之间有唯一的路径相连。


　　不过在最近一次维护网络时，管理员误操作使得某两台电脑之间增加了一条数据链接，于是网络中出现了环路。环路上的电脑由于两两之间不再是只有一条路径，使得这些电脑上的数据传输出现了BUG。


　　为了恢复正常传输。小明需要找到所有在环路上的电脑，你能帮助他吗？

输入格式

　　第一行包含一个整数N。
　　以下N行每行两个整数a和b，表示a和b之间有一条数据链接相连。


　　对于30%的数据，1 <= N <= 1000
　　对于100%的数据, 1 <= N <= 100000， 1 <= a, b <= N


　　输入保证合法。

输出格式

　　按从小到大的顺序输出在环路上的电脑的编号，中间由一个空格分隔。

样例输入

5
1 2
3 1
2 4
2 5
5 3

样例输出

1 2 3 5

---

Algorithm

这个题目做了很长时间了，因为之前学习了并查集寻找环，因此首先用并查集寻找是否有环（当然这里肯定是有的...）

我们主要目的是找到环上的两个点，从这两个点中的一个出发，回到另一个点，那么这就是我们想要找的环了。

虽说题目讲的是树状结构，但是也是图的一种特殊情况，我们可以直接用图的遍历来搜索这个环。

我不知道这两种方法那种更节约时间，直观看来应该相差不多。

无论怎样，我们都需要构图，这里用邻接表的数据结构好一点（稀疏图与稠密图），动态数组就可以完成。

备注：这串代码调试了很久，不知道为什么有时候会返回一个错误的返回值，应该是我哪里写错了，最有可能的就是在vector的使用的地方。

遗憾的是我没有找出来，只能得90分。但是算法本身并没错。

当我将上面的数据

输入时，正确输出！然后再输入，就会返回一个错误的value。

反之，先输入下面的数据，再输入上面的数据，那么下面的会正确输出。

---

 AC 

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>

using namespace std;

const int MAX_V = 100009;
int par[MAX_V] = {0};
int rank[MAX_V];     // 树的高度
vector<int> G[MAX_V];
vector<int> step, V;
bool flag[MAX_V];
int N = 0; 

// 初始化 
void Init(int n)
{
    memset(rank, 0, sizeof(rank));
    for(int i=0;i<MAX_V;i++)
        par[i] = i;
}

// 查找 
int find_root(int x)
{
    // 用了递归压缩之后通过了 90% 的数据...
    // while循环只通过了 30% ... 
    return par[x] == x?x:par[x] = find_root(par[x]);
}

// 合并 
bool merge(int x, int y)
{
    x = find_root(x);
    y = find_root(y);
    if(x == y) return false;
    if(rank[x] == rank[y]){
        par[x] = y;
    }
    else{
        par[y] = x;
        if(rank[x] == rank[y]) rank[x]++;
    }
    return true;
}

void print()
{
    for(int i=0;i<V.size();i++)
        cout<<V.at(i)<<" ";
    cout<<'
';
    vector<int>().swap(V);
    // V.swap(vector<int>());
    return;
 } 

void dfs(int a, int b)
{
    if(G[b].size() == 0) return;
    if(b == a){ // a, b是环上的两个点,从b出发回到a为一个环 
        sort(step.begin(), step.end());
        for(int i=0;i<step.size();i++)
            V.push_back(step.at(i));
        for(int i=1;i<N+1;i++)
            G[i].clear();
        step.clear();
        return;
    }
    for(int i=0;i<G[b].size();i++){
        if(!flag[G[b].at(i)])
            continue;
        step.push_back(G[b].at(i));
        flag[b] = false;
        dfs(a, G[b].at(i));
        flag[b] = true;
        step.pop_back();
    }
    return;
}

int main()
{
    int a, b;
    // while(cin>>N)
    cin>>N;
    {
        Init(N+1);
        memset(flag, true, sizeof(flag));
        while(N--)
        {
            cin>>a>>b;
            G[a].push_back(b);
            G[b].push_back(a);
            if(!merge(a, b)){
                // cout<<"Already find~"<<endl;
/* 找到环，此时开始搜索能避免多余的点和边，加快搜索速度 */
                G[b].pop_back();     // 终点 pop 掉 
                step.push_back(b);    // 起点压入路径 
                dfs(a, b);
            }
        }
        print();
    }
    
    return 0;
}

2019-02-12

15:29:55