欧拉图【模板+例题】

例题：UOJ 117 欧拉回路

参考博客：https://www.cnblogs.com/Ash-ly/p/5397702.html （其中有向图的入度和出度好像写反了）
                  https://blog.csdn.net/yzyyylx/article/details/80009572 (大佬的题解)

基本思想：
              首先从一个节点(v0)出发，随便往下走(走过的边需要标记一下，下次就别走了)，当走到不能再走的时候，所停止的点必然也是起点(因为所有的点的度数都是偶数，能进去肯定还会出来，再者中间有可能再次经过起点，但是如果起点还能继续走，那么就要继续往下搜索，直到再次回来时不能往下搜索为止)，然后停止时，走过的路径形成了一个圈，但因为是随便走的，所以可能有些边还没走就回来了，那些剩下的边肯定也会形成一个或者多个环，然后可以从刚才终止的节点往前回溯，找到第一个可以向其他方向搜索的节点(vi)，然后再以这个点继续往下搜索，同理还会继续回到该点(vi)，于是这个环加上上次那个环就构成了一个更大的环，即可以想象成形成了一条从 v0 到 vi的路径，再由 vi 走了一个环回到 vi，然后到达v0 的一条更长的路径，如果当前的路径还不是最长的，那么继续按照上面的方法扩展。只需要在回溯时记录下每次回溯的边，最后形成的边的序列就是一条欧拉回路。如果要记录点的顺序的话，那么每访问一个点，就把这个点压入栈中，当某个点不能继续搜索时，即在标记不能走的边是，这个点成为了某种意义上的孤点，然后把这个点输出最后得到的就是一条欧拉回路路径的点的轨迹。

               总之，求欧拉回路的方法是，使用深度优先搜索，如果某条边被搜索到，则标记这条边为已选择，并且即使回溯也不能将当前边的状态改回未选择，每次回溯时，记录回溯路径。深度优先搜索结束后，记录的路径就是欧拉回路。

重点：利用回溯来存储答案，并且每一条边只会遍历一次，路径储存下来。如果是双向边，点和边的顺序都无所所谓（题上如果没规定的话）。如果是单向边，回溯时储存的答案，那么一定得逆序输出。

附上例题代码（含有注释）：

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<bitset>
#include<set>
#include<stack>
#include<map>
#include<list>
#include<new>
#include<vector>
#include<cctype>///isdigit头文件
#define MT(a,b) memset(a,b,sizeof(a));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pi=acos(-1.0);
const double E=2.718281828459;

inline int read()   ///快速读入
{
    int X=0,w=0;
    char ch=0;
    while(!isdigit(ch))
    {
        w|=ch=='-';
        ch=getchar();
    }
    while(isdigit(ch))
        X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
    return w?-X:X;
}

int op,n,m;

struct node
{
    int e;
    int p;
    int vis;    ///标记这条边是否被访问过
} load[400005];
int head[100005],sign,cnt;

void add_edge(int s,int e)
{
    load[++sign]=node{e,head[s],0};
    head[s]=sign;
}

void init()
{
    cnt=sign=0;
    memset(head,-1,sizeof(head));
}

int ans[200005];///答案数组

void dfs_unedge(int s)
{
    for(int i=head[s]; i!=-1; i=head[s])
    {
        ///目的是为了优化，因为每一条边只访问一次/
        ///可以将这条边删除掉，降低时间复杂度（否则会T）
        head[s]=load[i].p;
        
        int e=load[i].e;
        if(load[i].vis)     ///访问过的边不会再次访问
            continue;
        ///因为储存的双向边，两条边都需要标记
        load[i].vis=1;
        (i&1)?load[i+1].vis=1:load[i-1].vis=1;
        dfs_unedge(e);
        ans[++cnt]=(i+1)/2; ///回溯后储存答案
        if((i&1)==0)        ///反向走的边变为负值
            ans[cnt]*=-1;
    }
}

void solve_unedge()   ///无向边欧拉回路
{
    int de[100005],s,e;
    memset(de,0,sizeof(de));
    n=read();
    m=read();
    for(int i=1; i<=m; i++)
    {
        s=read();
        e=read();
        de[s]++;
        de[e]++;
        ///建立双向边
        add_edge(s,e);
        add_edge(e,s);
    }
    ///对于无向图来说度数为奇数的点个数为0
    for(int i=1; i<=n; i++)
    {
        if(de[i]&1)
        {
            printf("NO\n");
            return ;
        }
    }
    for(int i=1; i<=n; i++)
    {
        if(de[i])
        {
            dfs_unedge(i);
            break;
        }
    }
    if(cnt!=m)
    {
        printf("NO\n");
        return ;
    }
    printf("YES\n");
    ///逆序输出，因为方向正负已经决定了
    for(int i=cnt; i>=1; i--)
        printf("%d ",ans[i]);
}

void dfs_diredge(int s)
{
    for(int i=head[s]; i!=-1; i=head[s])
    {
        head[s]=load[i].p;
        int e=load[i].e;
        if(load[i].vis)
            continue;
        load[i].vis=1;
        dfs_diredge(e);
        ans[++cnt]=i;
    }
}

void solve_diredge()   ///有向边欧拉回路
{
    int in[100005],out[100005];
    n=read();
    m=read();
    for(int i=1; i<=n; i++)
        in[i]=out[i]=0;
    int s,e;
    for(int i=1; i<=m; i++)
    {
        s=read();
        e=read();
        out[s]++;
        in[e]++;
        add_edge(s,e);
    }
    ///对于有向图来说每个点的入度必须等于出度。
    for(int i=1; i<=n; i++)
    {
        if(in[i]-out[i])
        {
            printf("NO\n");
            return ;
        }
    }
    for(int i=1; i<=n; i++)
    {
        if(head[i]!=-1)
        {
            dfs_diredge(i);
            break;
        }
    }
    if(cnt!=m)
    {
        printf("NO\n");
        return ;
    }
    printf("YES\n");
    for(int i=cnt; i>=1; i--)
        printf("%d ",ans[i]);
}

int main()
{
    init();///初始化
    op=read();
    op==1?solve_unedge():solve_diredge();
    return 0;
}