sgu 101 无向图有双重边的欧拉路径

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
const int MAXN = 400 + 10;
struct Edge
{
    int to, next;
}edge[MAXN];
int tot, head[MAXN];
int vis[MAXN], degree[MAXN];
int N;
void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
    memset(degree, 0, sizeof(degree));
    memset(vis, 0, sizeof(vis));
}
void dfs1(int u)
{
    vis[u] = 1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].to;
        if(!vis[v]) dfs1(v);
    }
}
int cc;
int ans[MAXN][2];
void dfs2(int u)
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        if(!vis[i])
        {
            vis[i] = 1;
            vis[i^1] = 1;
            int v = edge[i].to;
            dfs2(v);
            if(i %2 == 0) ans[cc++][0] = i / 2 + 1;
            else ans[cc++][1] = i / 2 + 1;
        }
    }
}
int main()
{
    while(scanf("%d", &N)!=EOF)
    {
        int u, v;
        init();
        int root;
        for(int i=1;i<=N;i++)
        {
            scanf("%d%d", &u, &v);
            root = u;
            addedge(u, v); addedge(v, u);
            degree[u]++; degree[v]++;
        }
        int count = 0; int flag = 1;
        int st;
        for(int i=0;i<=6;i++) if(degree[i] & 1)
        {
            count++;
            st = i;
        }
        if(!(count == 0 || count == 2)) flag = 0;
        else
        {
            dfs1(root);
            for(int i=0;i<=6;i++) if(degree[i] > 0 && !vis[i])
            {
                flag = 0;
                break;
            }
        }
        if(!flag)
        {
            printf("No solution\n");
            continue;
        }
        memset(vis, 0, sizeof(vis));
        if(count == 0)
        {
            dfs2(root);
        }
        else dfs2(st);
        for(int i=cc-1;i>=0;i--)
        {
            if(ans[i][0])
            {
                printf("%d +\n", ans[i][0]);
            }
            else printf("%d -\n", ans[i][1]);
        }
    }
    return 0;
}
时间: 2024-12-30 05:13:36

sgu 101 无向图有双重边的欧拉路径的相关文章

SGU 101 题解

#include<iostream> #include<algorithm> using namespace std; struct sticktype { int l; int r; bool vis; }stick[101]; struct pointtype { int amount; int next[7]; bool vis; }point[7]; int tail=0; int queue[201]; void dfs(int p); int main() { int

HDU 4738 --Caocao&#39;s Bridges 【无向图边双联通 &amp;&amp; 求权值最小的桥 &amp;&amp; 模板】

Caocao's Bridges Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2641    Accepted Submission(s): 855 Problem Description Caocao was defeated by Zhuge Liang and Zhou Yu in the battle of Chibi. B

poj2942 Knights of the Round Table,无向图点双联通,二分图判定

点击打开链接 无向图点双联通,二分图判定 <span style="font-size:18px;">#include <cstdio> #include <stack> #include <vector> #include <algorithm> #include <cstring> using namespace std; struct Edge{ int u, v; }; const int maxn = 1

hdu Caocao&#39;s Bridges(无向图边双连通分量,找出权值最小的桥)

1 /* 2 题意:给出一个无向图,去掉一条权值最小边,使这个无向图不再连同! 3 4 tm太坑了... 5 1,如果这个无向图开始就是一个非连通图,直接输出0 6 2,重边(两个节点存在多条边, 权值不一样) 7 3,如果找到了桥的最小权值为0,也就是桥上的士兵数为0,那么还是要最少派一个 8 士兵过去炸掉桥! 9 10 思路:假设每两个节点最多只有一条边进行相连! 11 进行tarjan算法,如果该算法调用了超过2次,说明这个原图就是不连通的! 12 否则在tarjan算法中将桥存起来!然后

HDU - 6311 Cover(无向图的最少路径边覆盖 欧拉路径)

题意 给个无向图,无重边和自环,问最少需要多少路径把边覆盖了.并输出相应路径 分析 首先联通块之间是独立的,对于一个联通块内,最少路径覆盖就是  max(1,度数为奇数点的个数/2).然后就是求欧拉路径了,先将块内度数为奇数的点找出来,留下两个点,其余两两连上虚边,这样我们选择从一个奇数点出发到另一个奇数点,求出一条欧拉路径,统计总路径数.接着就dfs,注意一些细节. 附赠一个求欧拉回路的fleury算法:https://blog.csdn.net/u011466175/article/deta

ACM: SGU 101 Domino- 欧拉回路-并查集

sgu 101 - Domino Time Limit:250MS     Memory Limit:4096KB     64bit IO Format:%I64d & %I64u Description Dominoes – game played with small, rectangular blocks of wood or other material, each identified by a number of dots, or pips, on its face. The bl

hdu3844 Mining Your Own Business,无向图的双连通分量

点击打开链接 无向图的双连通分量 #include<cstdio> #include<stack> #include<vector> #include<map> #include<algorithm> #include<cstring> #pragma comment(linker, "/STACK:102400000,102400000") using namespace std; typedef long lo

连通分量 无向图的割顶和桥 无向图的双连通分量 有向图的强连通分量

时间戳 dfs_clock :说白了就是记录下访问每个结点的次序.假设我们用 pre 保存,那么如果 pre[u] > pre[v], 那么就可以知道先访问的 v ,后访问的 u . 现在给定一条边, (u, v), 且 u 的祖先为 fa, 如果有 pre[v] < pre[u] && v != fa, 那么 (u, v) 为一条反向边. 1 求连通分量: 相互可达的节点称为一个连通分量: #include <iostream> #include <cstd

SGU 101.Domino( 欧拉路径 )

求欧拉路径...直接dfs即可,时间复杂度O(N) --------------------------------------------------------------------------- #include<cstdio> #include<cstring> #include<algorithm> #include<stack> using namespace std; #define X(i) Edge[i].first #define Y(