【图论】欧拉回路

概念

HDU 1878 欧拉回路

题意：判断无向图是否有欧拉回路。

#include <bits/stdc++.h>
using namespace std;
const int N=1e3+10,M=1e5+10; // 注意边数大小M
bool vis[N];
int n,m,cnt,sum,head[N],d[N];
struct node
{
    int to,next;
}e[M<<1];
void add(int x,int y)
{
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}
void add_edge(int x,int y)
{
    add(x,y);
    add(y,x);
}
bool dfs(int u) // dfs判断是否连通
{
    vis[u]=1;
    sum++; // 搜索到的点的个数
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(vis[v])continue;
        dfs(v);
    }
}
bool judge()
{
    for(int i=1;i<=n;i++)
        if(d[i]%2!=0)return 0; // 所有点的度数都必须为偶数
    dfs(1); // 搜索
    return sum==n; //搜索到的点必须是n个才是连通图
}
void init()
{
    sum=0;cnt=0;
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(d,0,sizeof(d));
}
int main()
{
    ios::sync_with_stdio(false);
    while(cin>>n&&n)
    {
        init(); // 记得初始化！
        cin>>m;
        int x,y;
        for(int i=1;i<=m;i++)
        {
            cin>>x>>y;
            d[x]++;
            d[y]++;
            add_edge(x,y);
        }
        printf("%d\n",judge());
    }
    return 0;
}

HDU 1116 Play on Words

题意：判断有向图是否有欧拉回路或欧拉通路。

思路：并查集判连通块个数为1即为连通图，统计出度入度判欧拉回路/通路，unordered_set去重出现的点。

#include <bits/stdc++.h>
using namespace std;
const int N=30;
int T,n,fa[N],in[N],out[N];
unordered_set<int>g;
int find(int x) // 并查集
{
    return x==fa[x]?x:find(fa[x]);
}
void join(int x,int y) // 并查集
{
    fa[find(x)]=find(y);
}
bool judge()
{
    int st=-1,ed=-1,even=0,tot=0;
    for(auto i:g)
    {
        if(i==fa[i])tot++; // 连通分量个数
        if(tot>1)return 0; // tot=1时才是连通图
        if(out[i]==in[i]+1)st=i;
        else if(out[i]+1==in[i])ed=i;
        else if(out[i]==in[i])even++; // 出度=入度
    }
    int sz=g.size() // 点的个数
    if(even==sz)return 1; // 欧拉回路
    if(st!=-1&&ed!=-1&&even+2==sz)return 1; // 欧拉通路
    return 0;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>T;
    while(T--)
    {
        cin>>n;
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        for(int i=0;i<26;i++) // 并查集初始化
            fa[i]=i;
        g.clear();
        string s;
        for(int i=1;i<=n;i++)
        {
            cin>>s;
            int x=s[0]-'a';
            int y=s[s.length()-1]-'a';
            out[x]++; // 出度
            in[y]++; // 入度
            g.insert(x);
            g.insert(y);
            join(x,y);
        }
        if(judge())printf("Ordering is possible.\n");
        else printf("The door cannot be opened.\n");
    }
    return 0;
}

HDU 3018 Ant Trip

对于欧拉回路问题，就是问你一笔能不能画完整个图然后回到源点(每条边只能被走一次)。

现在这题是问你最少几笔能画完整个图，不一定要形成回路，通路也行，也就是问你有几个欧拉通路。

DFS搜索连通分量，按照每个连通分量中所有点的度数分类，有三种情况：

1. 只有一个孤立点(度为0)，直接跳过它。
2. 不存在奇数度的点，即所有的点全部为偶数度，说明有一条欧拉通路，ans++。
3. 存在奇数度的点，假设度数为奇数的点有n个，则有欧拉通路n/2个， ans+=n/2。

解释一下第3点，对于每个连通分量，因为每两个奇度点需要一个人走，所以有n个奇度点就需要n/2个人走。

有意思的是，n/2向下取整，或者(n+1)/2向上取整，都能AC，是不是数据有问题？其实不是数据的问题。分析一下，初始没有连边的时候，所有点度数都为0，大家都是偶度点，然后开始连边，偶与偶连边<->奇与奇，偶与奇<->奇与偶，可以看到奇度点的个数n要么加减2，要么不变，说明度数为奇数的点一定是偶数个， 即n一定是偶数，n除以2也就不存在上下取整的问题。

这个结论很重要，之前离散数学推导过，我现在才发现原来自己忘记这个结论了，又重新推导了一遍。

证明度数为奇数的点一定是偶数个：给定一个无向图图G=(V,E),其中V表示顶点集合,E表示边集合.则有握手定理成立,即图中所有顶点的度数之和等于两倍的边数,换句话来说,所有顶点的度数之和一定是偶数.所以如果图中存在度数是奇数的顶点,那么为了保证所有点的度数之和为偶数,只能让这样的奇数度的点为偶数个.

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,M=2e5+10;
bool vis[N];
int n,m,cnt,num1,head[N],d[N];
struct node
{
    int to,next;
}e[M<<1];
void add(int x,int y)
{
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}
void add_edge(int x,int y)
{
    add(x,y);
    add(y,x);
}
bool dfs(int u)
{
    vis[u]=1;
    if(d[u]%2!=0)num1++;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(vis[v])continue;
        dfs(v);
    }
}
int get_ans()
{
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        num1=0;//在当前搜索的连通块中度为奇数的点的个数
        if(!vis[i]&&d[i]!=0)//度数为0的孤立点或已被访问过的点不搜索
        {
            dfs(i);
            if(num1==0)ans++;//所有点的度数均为偶数
            else ans+=num1/2;//度数为奇数的点有num1个，则有欧拉通路num1/2个
        }
    }
    return ans;
}
void init()
{
    cnt=0;
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(d,0,sizeof(d));//记得初始化！
}
int main()
{
    ios::sync_with_stdio(false);
    while(cin>>n>>m)
    {
        init();
        int x,y;
        for(int i=1;i<=m;i++)
        {
            cin>>x>>y;
            d[x]++;
            d[y]++;
            add_edge(x,y);
        }
        printf("%d\n",get_ans());
    }
    return 0;
}

POJ 1041 John’s trip

题意：无向图求欧拉回路的边序号的最小字典序。

思路：先将每个点连的边序号排序，再直接dfs，回溯后的边序号存入vector，逆序输出即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int N=2000,M=45*N;
bool vis[M];
vector<int>ans;
vector<pair<int,int> >g[N]; // pair进行sort自动按第一、第二关键字排序
int m,d[N];
void add(int x,int y,int z) // 点x,y之间通过边z连接
{
    g[x].push_back(make_pair(z,y));
    g[y].push_back(make_pair(z,x));
}
void dfs(int u) // 点u
{
    for(int i=0;i<g[u].size();i++)
    {
        int id=g[u][i].first; // 边id
        if(vis[id])continue;
        vis[id]=1;
        int v=g[u][i].second; // 下一个点v
        dfs(v);
        ans.push_back(id);
    }
}
bool judge()
{
    for(int i=1;i<N;i++)
    {
        if(g[i].size())
        {
            if(d[i]%2!=0)return 0; // 所有点的度数都必须为偶数
            sort(g[i].begin(),g[i].end()); // 把每个点连的边的序号排序(pair第一关键字)
        }
    }
    dfs(1);
    return ans.size()==m;
}
int main()
{
    ios::sync_with_stdio(false);
    int x,y,z;
    while(cin>>x>>y&&(x||y))
    {
        cin>>z;
        memset(vis,0,sizeof(vis));
        memset(d,0,sizeof(d));
        ans.clear();
        for(int i=1;i<N;i++)
            g[i].clear();
        m=1;d[x]++;d[y]++;
        add(x,y,z);
        while(cin>>x>>y&&(x||y))
        {
            cin>>z;
            m++;d[x]++;d[y]++;
            add(x,y,z);
        }
        if(!judge())printf("Round trip does not exist.\n");
        else
        {
            reverse(ans.begin(),ans.end());
            int sz=ans.size();
            for(int i=0;i<sz;i++)
                i==sz-1?printf("%d\n",ans[i]):printf("%d ",ans[i]);
        }
    }
    return 0;
}