图论基础 无向图环的判定及删边操作

建图用vector，对于无向图，则两个点之间建立从x到y，跟从y到x的两条边，对于有向图则建立x到y的边即可。

对于图上点只要dfs标记即可。

对于无向图中环的问题，我们可以这样寻找，在vector中寻找所有的度为1的顶点，这些点肯定不在环中，对于这条边的标记变为1.从这些环开始遍历，对于新找到的点度数减1，如果这时候点的度数变为了1说明此点一定不在环上，加入队列即可。直到队列中全部的点都被弹出。

其中在环上的点都没有进入队列，因此其标记全部为0.因此只要遍历一遍所有的点的tag，只要为0，即说明这点是环上的边。

例题：

Description

小 Y 是一个爱好旅行的 OIer。她来到 X 国，打算将各个城市都玩一遍。
小Y了解到， X国的 nn 个城市之间有 mm 条双向道路。每条双向道路连接两个城市。 不存在两条连接同一对城市的道路，也不存在一条连接一个城市和它本身的道路。并且， 从任意一个城市出发，通过这些道路都可以到达任意一个其他城市。小 Y 只能通过这些 道路从一个城市前往另一个城市。
小 Y 的旅行方案是这样的：任意选定一个城市作为起点，然后从起点开始，每次可 以选择一条与当前城市相连的道路，走向一个没有去过的城市，或者沿着第一次访问该 城市时经过的道路后退到上一个城市。当小 Y 回到起点时，她可以选择结束这次旅行或 继续旅行。需要注意的是，小 Y 要求在旅行方案中，每个城市都被访问到。
为了让自己的旅行更有意义，小 Y 决定在每到达一个新的城市（包括起点）时，将 它的编号记录下来。她知道这样会形成一个长度为 nn 的序列。她希望这个序列的字典序 最小，你能帮帮她吗？ 对于两个长度均为n的序列A和B，当且仅当存在一个正整数x，满足以下条件时，我们说序列A的字典序小于 B。
​对于任意正整数1≤i<x，序列A的第i个元素Ai和序列B的第i个元素Bi相同。
​序列A的第x个元素的值小于序列B的第x个元素的值。

Input

输入文件共 m + 1 行。第一行包含两个整数 n,m(m ≤ n)，中间用一个空格分隔。
接下来 m 行，每行包含两个整数 u,v (1 ≤ u,v ≤ n) ，表示编号为 u 和 v 的城市之 间有一条道路，两个整数之间用一个空格分隔。

Output

输出文件包含一行，n 个整数，表示字典序最小的序列。相邻两个整数之间用一个 空格分隔。

Sample Input

6 5 
1 3 
2 3 
2 5 
3 4 
4 6

Sample Output

1 3 2 5 4 6

Hint

第2组数据：
6 6 
1 3 
2 3 
2 5 
3 4 
4 5 
4 6
输出：
1 3 2 4 5 6
1≤n≤5000 且 m = n − 1 或 m = n 。

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
const int M=5e3+10;
int cnt,ans[M],res[M];
struct node {
    int num,to;
};
bool operator < (node a,node b)
{
    return a.to<b.to;
}
vector<node>v[M];
int vis[M],teg[M],deg[M];
queue<int>q;
void find_cir(int n)//从度为1的点开始找，说明这些点是边上的点，你从这歌点开始遍历，会找个一个环上的点，这个点度为3（如果这个点有多个叶子则为叶子节点个数加2），在度数减1后，度还是2不会进入队列中，因此就可以标记全部环上的点，其tag为0，其他点tag为1
{
    for(int i=1;i<=n;i++)
    {
        if(deg[i]==1)
            q.push(i);
    }
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=1;
        for(int i=0;i<v[t].size();i++)
        {
            if(vis[v[t][i].to]==0)
            {
                teg[v[t][i].num]=1;
                deg[v[t][i].to]--;
                if(deg[v[t][i].to]==1)
                    q.push(v[t][i].to);
            }
        }
    }
}
void dfs(int x)
{
    res[++cnt]=x;
    vis[x]=1;
    for(int i=0;i<v[x].size();i++)
    {
        if(!vis[v[x][i].to]&&teg[v[x][i].num]!=-1)//如果是环中被减的边，则teg[i]等于-1
        dfs(v[x][i].to);
    }
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        node t1,t2;
        t1.num=i;
        t2.num=i;
        t1.to=x;
        t2.to=y;
        v[x].push_back(t2);
        v[y].push_back(t1);
        deg[x]++;
        deg[y]++;
    }
    for(int i=1;i<=n;i++)
        sort(v[i].begin(),v[i].end());//把每个连接排序
    if(n==m)
    {
        for(int i=0;i<=n;i++)
        vis[i]=0;
        cnt=0;
        find_cir(n);
        ans[1]=-1;
        for(int i=1;i<=m;i++)
        {
            if(!teg[i])
            {
                teg[i]=-1;
                for(int i=0;i<=n;i++)
        vis[i]=0;
        cnt=0;
        dfs(1);
        teg[i]=0;
        int flag=0;
        if(ans[1]==-1)
            flag=1;
        else
        {
            for(int i=1;i<=cnt;i++)
            {
                if(ans[i]>res[i])
                {
                    flag=1;
                    break;
                }
                else if(ans[i]<res[i])
                    break;
            }
        }
        if(flag==1)
        for(int i=1;i<=cnt;i++)
            ans[i]=res[i];
            }
        }
        for(int i=1;i<n;i++)
            printf("%d ",ans[i]);
        printf("%d\n",ans[n]);
    }
    else
    {
        for(int i=0;i<=n;i++)
        vis[i]=0;
        cnt=0;
    dfs(1);
        for(int i=1;i<n;i++)
            printf("%d ",res[i]);
        printf("%d\n",res[n]);

    }
    return 0;
}