欧拉回路-

最新推荐文章于 2023-02-11 15:26:24 发布

卷心菜不卷Iris

最新推荐文章于 2023-02-11 15:26:24 发布

阅读量276

点赞数

分类专栏： AcWing算法提高课文章标签：欧拉回路

本文链接：https://blog.csdn.net/qq_45832461/article/details/119354193

版权

AcWing算法提高课专栏收录该内容

146 篇文章 9 订阅

订阅专栏

欧拉回路

题目描述

核心思路

如何判断欧拉回路：

对于无向图，如果所有边连通，且所有点的度数都是偶数则是欧拉回路
对于有向图，如果所有边连通，且所有点的入度等于出度即可

打印欧拉回路时，是逆序输出得到的序列，而不是正序输出。

这个题是求欧拉回路。在求欧拉回路时，我们判重是对边进行判重而不是对点进行判重，而且必须是用过一条边就必须把它删除了。对于有向图来说很好做，但是对于无向图，它可以看作两条相反的有向边，因此我们删除一条边的时候，还要考虑到它的反向边，所以就显得有些ex。

下面解释一下，为什么代码中使用的是引用：

假设只有一个点，但是有 $m$ 个自环，即 $m$ 条边都是指向了这个节点，然后使用bool数组存储每条边有没有被遍历过。根据上面伪码描述，第一次运行到dfs中会遍历 $m$ 条边，递归进入dfs后还需要遍历 $m$ 条边，一共需要遍历 $m$ 次，因此 $m$ 个 $m$ 相加等于 $m\times m=m^2$ ，会超时。因此需要进行优化：

优化的方式是每次遍历过这条边后将其从邻接表中删除，保证之后不会再遍历到这条边。这样就可以保证每条边只会被遍历一次，时间复杂度变为线性。

参考如下图解释：

或者：

边的转化：

我们在建图时，无向图中边的编号是 $0$ 到 $2 m - 1$ ，但是题目中的编号是 $1$ 到 $m$ ，因此需要转化一下：

对于无向图， $(0, 1)$ 对应的是第一条边， $(2, 3)$ 对应的是第二条边。设我们建图时某条边的编号为 $x$ ，则转成题目中边的编号为 $x / 2 + 1$ 。比如有三个节点 $A - B - C$ ，那么 $A\to B$ 这条边就是0号边， $B\to A$ 这条边就是1号边； $B\to C$ 这条边就是2号边， $C\to B$ 这条边就是3号边。所以当 $x = 0$ 或者 $x = 1$ 时，转成题目中边的编号就是 $0 / 2 + 1 = 1$ 或者 $1 / 2 + 1 = 1$ 。从这里我们可以看出，如果 $x$ 是偶数，则表示正向边，如果 $x$ 是奇数，则表示反向边
对于有向图，则比较简单，如果我们建图时某条边的编号为 $x$ ，那么转成题目中边的编号就是 $x + 1$ 即可

这里还需要处理入度和出度，我们设立了din[]和dout[]分别表示入度和出度：

对于无向图，假设 $a - b$ ，那么应该计算 $a$ 有一个出度，计算 $b$ 有一个入度，即 $d [a] + 1$ ， $d [b] + 1$ 。注意这里不要被一条无向边是两条相反的有向边迷惑了，统计度时，是不需要考虑的。
对于有向图，假设 $a\to b$ ，那么应该计算 $a$ 有一个出度，计算 $b$ 有一个入度，即 $d [a] + 1$ ， $d [b] + 1$

因此，可以发现，无向图和有向图处理入度和出度的方式都是一样的。

第一次错误的修改：

void dfs(int u)
{
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        if(used[i])
        {
            h[u] = ne[i];
            continue;
        }

        used[i] = true;
        if(type == 1)used[i ^ 1] = true;

        int t;
        if(type == 1)
        {
            t = i / 2 + 1;
            if(i & 1)t = -t;
        }
        else t = i + 1;

        int j = e[i];
        h[u] = ne[i];
        dfs(j);

        res[++ cnt] = t;
    }
}

正确修改后的代码一：不使用引用的写法

void dfs(int u)
{
    for(int i = h[u] ; ~i ; i = h[u])//区别
    {
        if(used[i])
        {
            h[u] = ne[i];//区别
            continue;
        }

        used[i] = true;
        if(type == 1)used[i ^ 1] = true;

        int t;
        if(type == 1)
        {
            t = i / 2 + 1;
            if(i & 1)t = -t;
        }
        else t = i + 1;

        int j = e[i];
        h[u] = ne[i];//区别
        dfs(j);

        res[++ cnt] = t;
    }
}

使用引用的写法：

void dfs(int u)
{
    for (int &i = h[u]; ~i;)//区别
    {
        if (used[i])
        {
            i = ne[i];//区别
            continue;
        }

        used[i] = true;
        if (type == 1) used[i ^ 1] = true;

        int t;

        if (type == 1)
        {
            t = i / 2 + 1;
            if (i & 1) t = -t;
        }
        else t = i + 1;

        int j = e[i];
        i = ne[i];//区别
        dfs(j);

        ans[ ++ cnt] = t;
    }
}

代码

写法1

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5+10, M = 4e5+10;
int type;
int n, m;
int h[N], e[M], ne[M], idx;
//used[i]=true表示i这条边已经被用过了
bool used[M];   
//ans表示欧拉路径,cnt表示路径上边的数量
int ans[M], cnt;
//点的出度与入度;
int din[N], dout[N];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u)
{
    for(int &i=h[u];~i;)
    {
        if(used[i])//如果边i已经被用过了 则直接去下一条边看
        {
            i = ne[i];
            continue;
        }
        //标记i这条边已经被用过了
        used[i]=true;
        int t;//点的编号  无向图时点编号=边编号/2+1 有向图时点编号=便编号+1
        if(type==1)
        {
            used[i^1]=true;//如果无向边 则把反向边也标记
            t=i/2+1;
            if(i&1)t=-t;//奇数边为反向边 如果 pi 为正数表示从 ve 走到 ue，否则表示从 ue 走到 ve
        }
        else 
            t=i+1;
        int j = e[i];//边上连接的邻点  即节点u的邻接点j
        i = ne[i];  //边用过之后直接删了
        dfs(j);// 一直走到底 把终点先压进栈 然后回溯往回走把中间及起点加进栈 最终输出结果 ans[cnt]为起点
        ans[++cnt] = t;//从下往上将点输入到路径中,因为从上往下的过程中,可能边路有些环并没有被顾虑到
    }
}

int main()
{
    scanf("%d",&type);
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        if(type==1) 
            add(b,a);//无向图 双向边
        din[b]++,dout[a]++; //记录入度和出度
    }

    if(type==1)//无向图
    {
        for(int i = 1;i<=n;i++)
        {
            int d=din[i]+dout[i];
            if(d&1)//度数为奇数 无解
            {
                puts("NO");
                return 0;
            }
        }
    }
    else//有向图
    {
        for (int i = 1; i <= n; i ++ )
            if (din[i] != dout[i])
            {
                puts("NO");
                return 0;
            }   
    }
    // 遍历时可能有孤立点--找一个包含边的起点
    for (int i = 1; i <= n; i ++ )
    {
        if (h[i] != -1) //有邻边
        {
            dfs(i);
            break;
        }
    }
    //如果回路中的边数小于总边数,则不构成欧拉回路
    if(cnt<m)
    {
        puts("NO");
        return 0;
    }
    puts("YES");
    //因为是逆序将点存储的的,所以要逆序将点打出来;
    for(int i = cnt;i;i--) 
        printf("%d ",ans[i]);
    printf("\n");
    return 0;
}

写法2：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5+10, M = 4e5+10;
int type;
int n, m;
int h[N], e[M], ne[M], idx;
//used[i]=true表示i这条边已经被用过了
bool used[M];   
//ans表示欧拉路径,cnt表示路径上边的数量
int ans[M], cnt;
//点的出度与入度;
int din[N], dout[N];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u)
{
    for(int i = h[u] ; ~i ; i = h[u])//区别
    {
        if(used[i])
        {
            h[u] = ne[i];//区别
            continue;
        }

        used[i] = true;
        if(type == 1)used[i ^ 1] = true;

        int t;
        if(type == 1)
        {
            t = i / 2 + 1;
            if(i & 1)t = -t;
        }
        else t = i + 1;

        int j = e[i];
        h[u] = ne[i];//区别
        dfs(j);

        ans[++ cnt] = t;
    }
}

int main()
{
    scanf("%d",&type);
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        if(type==1) 
            add(b,a);//无向图 双向边
        din[b]++,dout[a]++; //记录入度和出度
    }

    if(type==1)//无向图
    {
        for(int i = 1;i<=n;i++)
        {
            int d=din[i]+dout[i];
            if(d&1)//度数为奇数 无解
            {
                puts("NO");
                return 0;
            }
        }
    }
    else//有向图
    {
        for (int i = 1; i <= n; i ++ )
            if (din[i] != dout[i])
            {
                puts("NO");
                return 0;
            }   
    }
    // 遍历时可能有孤立点--找一个包含边的起点
    for (int i = 1; i <= n; i ++ )
    {
        if (h[i] != -1) //有邻边
        {
            dfs(i);
            break;
        }
    }
    //如果回路中的边数小于总边数,则不构成欧拉回路
    if(cnt<m)
    {
        puts("NO");
        return 0;
    }
    puts("YES");
    //因为是逆序将点存储的的,所以要逆序将点打出来;
    for(int i = cnt;i;i--) 
        printf("%d ",ans[i]);
    printf("\n");
    return 0;
}

写法3：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010, M = 400010;

int type;  // 1代表无向图，2代表有向图
int n, m;
int h[N], e[M], ne[M], idx;
bool used[M];  // 记录每条边是否被使用了
int ans[M / 2], cnt;  // 记录欧拉路径
int din[N], dout[N];  // 记录每个点的入度，出度，无向图的度等于入度和出度之和

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u) {

    while (~h[u]) {  // 这样写是为了跳过应遍历的边
        int i = h[u];  // 当前遍历第i条边

        if (used[i]) {  // 防止无向图的反向边被加入答案中
            h[u] = ne[i];
            continue;
        }

        h[u] = ne[i];  // 这里h[u]被更新，因为h是全局变量，下次dfs就不会遍历到当前考察的边
        used[i] = true;
        if (type == 1) used[i ^ 1] = true;

        dfs(e[i]);

        if (type == 1) {
            int t = i / 2 + 1;  // 无向图当前考察的是第t条边(从1开始)
            if (i & 1) t *= -1;
            ans[++cnt] = t;
        } else ans[++cnt] = i + 1;
    }
}

int main() {

    scanf("%d", &type);
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);

    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
        if (type == 1) add(b, a);
        dout[a]++, din[b]++;  // 一条边只会让两个点的度增加，因此对于无向图也是成立的
    }

    // 判断是否无解
    if (type == 1) {
        for (int i = 1; i <= n; i++)
            if (din[i] + dout[i] & 1) {  // 成立的话说明点i的度为奇数
                puts("NO");
                return 0;
            }
    } else {
        for (int i = 1; i <= n; i++)
            if (din[i] != dout[i]) {
                puts("NO");
                return 0;
            }
    }

    // 求解欧拉路径
    for (int i = 1; i <= n; i++)
        if (~h[i]) {  // 即h[i] != -1
            dfs(i);
            break;  // 只能执行一次dfs函数，否则说明其他边在其他连通分量中
        }

    if (cnt < m) {  // 说明所有边不连通
        puts("NO");
        return 0;
    }

    // 输出答案
    puts("YES");
    for (int i = cnt; i; i--) printf("%d ", ans[i]);
    puts("");

    return 0;
}

卷心菜不卷Iris

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
欧拉回路-

欧拉回路题目描述核心思路如何判断欧拉回路：对于无向图，如果所有边连通，且所有点的度数都是偶数则是欧拉回路对于有向图，如果所有边连通，且所有点的入度等于出度即可打印欧拉回路时，是逆序输出得到的序列，而不是正序输出。这个题是求欧拉回路。在求欧拉回路时，我们判重是对边进行判重而不是对点进行判重，而且必须是用过一条边就必须把它删除了。对于有向图来说很好做，但是对于无向图，它可以看作两条相反的有向边，因此我们删除一条边的时候，还要考虑到它的反向边，所以就显得有些ex。下面解释一下，为什么代码
复制链接

扫一扫