欧拉回路算法学习

欧拉回路

定义： 给定无孤立结点图G，若存在一条路，经过G中每条边有且仅有一次，称这条路为欧拉路，如果存在一条回路经过G每条边有且仅有一次，称这条回路为欧拉回路。具有欧拉回路的图成为欧拉图。

无向图: 图连通，所有点都是偶数度，或者只有两个点是奇数度。当所有点是偶数度时欧拉路起点可以是任意 点；当有两个奇数度点时起点必须是奇数度点。

有向图: 图连通，所有点出度=入度，或者有一个点入度-出度=1，有一个点出度-入度=1。同样，当所有点出度=入度时任意点可作为起点；而后者必须以出度-入度=1的点做起点，入度-出度=1的点做终点。

POJ 2330 Watchcow

本题求欧拉回路并且输出路径，其实到现在只知道一些定理，但是自己并不知道如何证明欧拉回路相关定理的正确性。

#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 1e4+100;
#define pb push_back

int n, m;

struct Edge{
    int v;
    bool flag;  //判断这条边是否走过
};

vector <Edge> vec[maxn];

void dfs(int x){
    for(int i = 0; i < vec[x].size(); i++){
        if(!vec[x][i].flag){
            vec[x][i].flag = true; //走过进行标记
            dfs(vec[x][i].v);
        }
    }
    printf("%d\n", x);
}

int main(){
    int u, v;
    Edge temp;
    while(scanf("%d%d", &n, &m) != EOF){
        for(int i = 0; i < m; i++){
            scanf("%d%d", &u, &v);
            temp.v = v;
            temp.flag = false;
            vec[u].pb(temp);
            temp.v = u;
            vec[v].pb(temp);
        }
        dfs(1);
    }
    return 0;
}

codeforce 723 E One-Way Reform

n点m边无向图，给边定向，使入度等于出度的点尽量多。输出点数最大值，以及定向后的有向边。
有个结论：只要是度为偶数的点，一定可以构造出入度等于出度。奇度点一定不可能。
因此我们可以将奇数度数的节点两两相连，因为奇数节点的个数为偶数，想一想为什么。
如何确定方向呢？如果图的所有点的度都是偶数的，那么可以从任一点出发，得到一个欧拉回路，这样就能定向了。所以要想办法使得所有点都是偶数。
这样就满足欧拉路的条件了。我们只需要跑欧拉路并且将走过的路径保留下来即可。

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 205;
// 邻接表，      度数       并查集找父亲节点
int head[maxn], degree[maxn], fa[maxn], tot, old;

struct Edge{
    int to, next;
}e[maxn*maxn];

vector <int> vec[maxn], ret[maxn];
bool vis[maxn*maxn];  //判断边是否走过

void addedge(int from, int to){
    e[tot].to = to;
    e[tot].next = head[from];
    head[from] = tot++;
}

int Find(int x){
    return fa[x] == x?x:fa[x] = Find(fa[x]);
}

void Merge(int x,int y){  //合并
    int fx = Find(x);
    int fy = Find(y);
    fa[fx] = fy;
}

void dfs(int u){  //dfs走欧拉回路
    for(int i = head[u]; i != -1; i = e[i].next){
        if(!vis[i]){
            vis[i] = vis[i^1] = 1;  //将走过的边进行标记
            dfs(e[i].to);
            if(i < old) ret[u].push_back(e[i].to);  //注意后面加了新边，只有老边可以进入计数
        }
    }
}

void init(){
    tot = 0;
    memset(head, -1, sizeof(head));
    memset(degree, 0, sizeof(degree));
    memset(vis, 0, sizeof(vis));
    for(int i = 0; i < maxn; i++){
        fa[i] = i;
        vec[i].clear();
        ret[i].clear();
    }
}

int main(){
    int T, n, m, from, to;
    scanf("%d", &T);
    while(T--){
        init();
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= m; i++){
            scanf("%d%d", &from, &to);
            addedge(from, to);
            addedge(to, from);
            degree[from]++;
            degree[to]++;
            Merge(from, to);
        }
        old = tot;
        int ans = 0;
        for(int i = 1; i <= n; i++){
            if(degree[i]%2 == 0) ans++;
            else vec[Find(i)].push_back(i);
        }
        for(int i = 1; i <= n; i++){
            int len = vec[i].size();
            for(int j = 0; j < len; j += 2){
                addedge(vec[i][j], vec[i][j+1]);
                addedge(vec[i][j+1], vec[i][j]);
            }
        }
        for(int i = 1; i <= n; i++)
            if(fa[i] == i) dfs(i);
        printf("%d\n", ans);
        for(int i = 1; i <= n; i++){
            for(int j = 0; j < ret[i].size(); j++){
                printf("%d %d\n", i, ret[i][j]);
            }
        }
    }
    return 0;
}