hdu 5348 MZL's endless loop（欧拉路径+欧拉环）

题意：

在图上有n个点（$1≤n≤10^5$），m条边（$1≤m≤3∗10^5$）现在给你这m条边的关系，但是没有给出方向。
现在请你构造出一个图，这个图满足每个点的$|出度-入度|≤1$
如果当前的方向不变就是0，方向改变就是1。

解析：

考虑一个环的情况，可以通过单向边顺次连接做到入度和出度相等。
定理<1>： 一个图，肯定存在偶数个奇度点。
通过<1>，我们可以找出若干条欧拉路径，直接按遍历的路径，定一个方向。
考虑一个环的情况，可以通过单向边顺次连接做到入度和出度相等。

欧拉路径，可以通过其定义找到，出度和入度都为奇数。可以dfs每个点，如果遇到当前的起点和终点都是奇数就定下，该路径上的方向。
然后把欧拉路径给剥离，如果所有的欧拉路径都剥离了，那么剩下的就是一个欧拉环了，然后再对欧拉环进行dfs，并确定方向就是最终答案了。

$my$ $code$

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 2e5 + 10;
const int M = 6e5 + 10;
struct Edge {
    int u, v, next, w;
    Edge() {}
    Edge(int u, int v, int w) : u(u), v(v), w(w) {}
} edge[M];

int head[N], tot;
int deg[N];
int n, m;

void init() {
    memset(deg, 0, sizeof(deg));
    memset(head, -1, sizeof(head));
    tot = 0;
}

void addEdge(int u, int v) {
    edge[tot] = Edge(u, v, 0);
    edge[tot].next = head[u];
    head[u] = tot++;
}

bool dfs(int u) {
    for(int& i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].v;
        int flag = edge[i].w ^ edge[i^1].w;
        if(flag) continue; //如果当前边已经访问过
        edge[i].w = 1;
        if(deg[v]) { //如果当前点是奇数度的话
            deg[v] = 0;
            return true;
        }
        if(dfs(v)) return true;
    }
    return false;
}

void solve() {
    //找到欧拉路径
    for(int i = 1; i <= n; i++) {
        if(deg[i]) {
            deg[i] = 0;
            dfs(i);
        }
    }
    //遍历欧拉环
    for(int i = 1; i <= n; i++) {
        while(~head[i]) {
            dfs(i);
        }
    }
}

int MAIN() {
    int T;
    scanf("%d", &T);
    while(T--) {
        init();
        scanf("%d%d", &n, &m);
        int u, v;
        for(int i = 0; i < m; i++) {
            scanf("%d%d", &u, &v);
            addEdge(u, v);
            addEdge(v, u);
            deg[u] ^= 1, deg[v] ^= 1;
        }
        solve();
        for(int i = 0; i < tot; i += 2) {
            printf("%d\n", edge[i].w);
        }
    }
    return 0;
}

const int main_stack = 16;
char my_stack[128<<20];

int main() {
    __asm__("movl %%esp, (%%eax);\n"::"a"(my_stack):"memory");
    __asm__("movl %%eax, %%esp;\n"::"a"(my_stack + sizeof(my_stack) - main_stack):"%esp");
    MAIN();
    __asm__("movl (%%eax), %%esp;\n"::"a"(my_stack):"%esp");
    return 0;
}