一本通1527欧拉回路

1527：【例 1】欧拉回路

时间限制: 1000 ms         内存限制: 262144 KB

【题目描述】

原题来自：UOJ #117

有一天一位灵魂画师画了一张图，现在要你找出欧拉回路，即在图中找一个环使得每条边都在环上出现恰好一次。

一共两个子任务：

这张图是无向图。（50 分）

这张图是有向图。（50 分）

【输入】

第一行一个整数 t，表示子任务编号。t∈{1,2}，如果 t=1 则表示处理无向图的情况，如果 t=2 则表示处理有向图的情况。

第二行两个整数 n,m，表示图的结点数和边数。

接下来 m 行中，第 i 行两个整数 vi,ui ，表示第 i 条边（从 1 开始编号）。保证 1≤vi,ui≤n。

如果 t=1 则表示 vi 到 ui 有一条无向边。

如果 t=2 则表示 vi 到 ui 有一条有向边。

图中可能有重边也可能有自环。

【输出】

如果不可以一笔画，输出一行 NO。

否则，输出一行 YES，接下来一行输出一组方案。

如果 t=1，输出 m 个整数 p1,p2,…,pm 。令 e=|pi|，那么 e 表示经过的第 i 条边的编号。如果 pi为正数表示从 ve 走到 ue ，否则表示从 ue 走到 ve 。

如果 t=2，输出 m 个整数 p1,p2,…,pm 。其中 pi 表示经过的第 i 条边的编号。

【输入样例】

1
3 3
1 2
2 3
1 3

【输出样例】

YES
1 2 -3

【提示】

样例输入 2

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

样例输出 2

YES
4 1 3 5 2 6

数据范围与提示：

1≤n≤10^5,0≤m≤2×10^5

 

 

--------------------------放了一大坨概念在下面--------------------------

欧拉回路和欧拉路径的几个概念:

欧拉环：图中经过每条边一次且仅一次的环；

欧拉路径：图中经过每条边一次且仅一次的路径；
欧拉图：有至少一个欧拉环的图；
半欧拉图：没有欧拉环，但有至少一条欧拉路径的图。

【无向图】
一个无向图是欧拉图当且仅当该图是连通的（注意，不考虑图中度为0的点，因为它们的存在对于图中是否存在欧拉环、欧拉路径没有影响）且所有点的度数都是偶数；一个无向图是半欧拉图当且仅当该图是连通的且有且只有2个点的度数是奇数（此时这两个点只能作为欧拉路径的起点和终点）；

证明：因为任意一个点，欧拉环（或欧拉路径）从它这里进去多少次就要出来多少次，故(进去的次数+出来的次数)为偶数，又因为(进去的次数+出来的次数)=该点的度数（根据定义），所以该点的度数为偶数。

【有向图】
一个有向图是欧拉图当且仅当该图的基图（将所有有向边变为无向边后形成的无向图，这里同样不考虑度数为0的点）是连通的且所有点的入度等于出度；一个有向图是半欧拉图当且仅当该图的基图是连通的且有且只有一个点的入度比出度少1（作为欧拉路径的起点），有且只有一个点的入度比出度多1（作为终点），其余点的入度等于出度。

证明：与无向图证明类似，一个点进去多少次就要出来多少次。

 

模板嘛。。。

 

/*
    不懂为什么dfs里的i加个&可以快这么多 
*/
#pragma comment(linker, "/STACK:102400000,102400000")
#include <bits/stdc++.h>
using namespace std;
const int N=100005,M=500005;
inline int read()
{
    int s=0,f=0;
    char ch=' ';
    while(!isdigit(ch))
    {
        f|=(ch=='-');
        ch=getchar();
    }
    while(isdigit(ch))
    {
        s=(s<<3)+(s<<1)+(ch^48);
        ch=getchar();
    }
    return (f)?(-s):(s);
}
#define R(x) x=read()
inline void write(int x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x<10)
    {
        putchar(x+'0');
        return;
    }
    write(x/10);
    putchar((x%10)+'0');
    return;
}
inline void writeln(int x)
{
    write(x);
    putchar('\n');
    return;
}
#define W(x) write(x),putchar(' ')
#define Wl(x) writeln(x)
int n,m,T;
int Indeg[N],Outdeg[N],Deg[N];
namespace Oulahuilu
{
    int tot=0,Next[M],to[M],head[N];
    bool Arr[M];
    inline void add(int x,int y)
    {
        Next[++tot]=head[x];
        to[tot]=y;
        head[x]=tot;
        return;
    }
    int Huilu[M],Huilu_cnt=0;
    inline void Run(int x)
    {
        for(int &i=head[x];i;i=Next[i]) if(!Arr[i])
        {
            int oo=i;
            Arr[i]=1;
            if(T==1)
            {
                (i&1)?(Arr[i+1]=1):(Arr[i-1]=1);
            }
            Run(to[i]);
            Huilu[++Huilu_cnt]=oo;
        }
        return;
    }
    inline void Output() 
    {
        int i;
        for(i=Huilu_cnt;i>=1;i--)
        {
            if(T==1)
            {
                W(((Huilu[i]&1)?1:-1)*((Huilu[i]+1)/2));
            }
            else
            {
                W(Huilu[i]);
            }
        }
        return;
    }
}
int main()
{
//    freopen("tour14.in","r",stdin);
//    freopen("my.out","w",stdout);
    int i;
    R(T);
    R(n);
    R(m);
    if(T==1)
    {
        
        for(i=1;i<=m;i++)
        {
            int x,y;
            R(x);
            R(y);
            Deg[x]++;
            Deg[y]++;
            Oulahuilu::add(x,y);
            Oulahuilu::add(y,x);
        }
        for(i=1;i<=n;i++) if(Deg[i]&1)
        {
            return 0*puts("NO");
        }
        for(i=1;i<=n;i++) if(Oulahuilu::head[i])
        {
            Oulahuilu::Run(i);
            break;
        }
        if(Oulahuilu::Huilu_cnt!=m)
        {
            puts("NO");
        }
        else
        {
            puts("YES");
            Oulahuilu::Output();
        }
    }
    else
    {
        for(i=1;i<=m;i++)
        {
            int x,y;
            R(x);
            R(y);
            Outdeg[x]++;
            Indeg[y]++;
            Oulahuilu::add(x,y);
        }
        for(i=1;i<=n;i++) if(Indeg[i]!=Outdeg[i])
        {
            return 0*puts("NO");
        }
        for(i=1;i<=n;i++) if(Oulahuilu::head[i])
        {
            Oulahuilu::Run(i);
            break;
        }
        if(Oulahuilu::Huilu_cnt!=m)
        {
            puts("NO");
        }
        else
        {
            puts("YES");
            Oulahuilu::Output();
        }
    }
    return 0;
}
/*
input
1
3 3
1 2
2 3
1 3
output
YES
1 2 -3

input
2
5 6
2 3
2 5
3 4
1 2
4 2
5 1
output
YES
4 1 3 5 2 6

input
2
100000 3
41700 41700
15415 31090
31090 15415
output
NO
*/