欧拉回路

1.无向图的欧拉回路判断:

如果一个无向图是连通的,并且每个点的度是偶数,那么这个无向图具有欧拉回路,所以

无向图的欧拉回路判断是非常简单的,只需要一次BFS就可以搞定了。

练习:Hdu 1878 欧拉回路 

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1878

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define Maxn 1005
int n,m;
int g[Maxn][Maxn];
int deg[Maxn];
int vis[Maxn];

bool progress()
{
    for(int i=1;i<=n;i++)
    {
        if(deg[i]&1) return false;
    }
    return true;
}
bool bfs(int s)
{
    queue q;
    memset(vis,0,sizeof(vis));
    q.push(s);
    vis[s] = 1;
    while(!q.empty())
    {
        int temp = q.front();
        q.pop();
        for(int i=1;i<=n;i++)
        {
            if(g[temp][i] && !vis[i]) vis[i] = 1,q.push(i);
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(vis[i] == 0) return false;
    }
    return true;
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
    #endif
    int a,b;
    while(scanf(" %d",&n)!=EOF)
    {
        if(n==0) break;
        memset(g,0,sizeof(g));
        memset(deg,0,sizeof(deg));
        scanf(" %d",&m);
        for(int i=0;i

2.无向图的欧拉回路求法:

题目:Poj 1041 John's trip

题解:用并查集判断连通性(也可以用搜索)。然后用DFS求欧拉路径即可。欧拉回路有一个这样的性质,我们从图G中去掉一个圈得到新图G‘有欧拉回路,那么G也有欧拉回路,基于这个性质,一旦找到一个圈就消去,从图中拿出,直到图为空。另一种算法Fleury可以放下吧。。。

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define Maxn 100
#define Maxm (2000<<2)

vector  > g[Maxn];
int vis[Maxm];

int father[Maxn];
int deg[Maxn];
int path[Maxm];
int top = 0;

void init()
{
	for(int i=0;i a,pair b)
{
	return a.second < b.second;
}
bool judge()
{
	//是否连通
	for(int i=0;i=0;i--)
	{
		if(i == top-1) printf("%d",path[i]);
		else printf(" %d",path[i]);
	}
	puts("");
}
int main()
{
	#ifndef ONLINE_JUDGE
		freopen("in.txt","r",stdin);
	#endif
	int a,b,z;
	int s;
	while(scanf(" %d %d",&a,&b)!=EOF)
	{
		if(a == 0 && b==0) break;
		init();
		s = min(a,b);
		scanf(" %d",&z);
		addEdge(a,b,z);
		merge(a,b);
		deg[a]++,deg[b]++;
		while(scanf(" %d %d",&a,&b)!=EOF)
		{
			if(a == 0 && b==0) break;
			scanf(" %d",&z);
			addEdge(a,b,z);
			merge(a,b);
			deg[a]++,deg[b]++;
		}
		if(judge())
		{
			memset(vis,0,sizeof(vis));
			top = 0;
			euler(s);
			output();
		}
		else printf("Round trip does not exist.\n");
	}
	return 0;
}

练习无向图欧拉回路的建模:

Uva 10054 The Necklace

题目链接:http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=995

题解:每个颜色当作一个节点,每个珠子当作一条边。然后求此无向图的欧拉回路。


#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define Maxn 60
#define Maxm 2000


struct Edge
{
	int u,v;
	int id;
};
vector g[Maxn];
int edge_num,top;
int father[Maxn],deg[Maxn],used[Maxn];
Edge path[Maxm];
bool vis[Maxm];

void init()
{
	for(int i=0;i=0;i--)
	{
		printf("%d %d\n",path[i].u,path[i].v);
	}
}
void euler(int s)
{
	for(int i=0;i


3.有向图的欧拉回路判断:

如果一个有向图具有欧拉回路,充要条件是这个图是连通图,并且每个点的入度等于出度。

如果一个有向图具有欧拉路径(此图成为半欧拉图),充要条件是这个图是连通图,并且有一个点的入度-出度=1,另一个点的出度-入度=1,其余点的入度等于出度。

那么,如何判断一个有向图是否是连通图呢?

首先,我们需要明确一个概念:什么是连通图。

其实我们说有向图是连通图,指的是有向图是弱连通图

有向图的连通性是一个大概念,包括强连通(任意两点都相互可达)、单向连通(任意两点至少可以有其中一点到达另一点)、弱连通(将有向图转换为无向图后是连通的)。

其中,强连通和弱连通都十分好判定(前者用Tarjan,后者直接用BFS即可)。

我们稍微来练习一下单向连通的判定:

题目:Poj 2762 Going from u to v or from v to u?

题目链接:http://poj.org/problem?id=2762

题意是判断一个有向图图是否能任取两点u,v都能够使得从u能够到达v,或者使得从v能够到达u。那么其实本题就是判断单连通性。

针对本题而言,首先我们使用Tarjan算法求出强连通分量,然后在缩点求出对应的Dag图,然后我们对此Dag进行拓扑排序,确定此Dag是否具有唯一的拓扑排序,如果不是,说明此图不存在欧拉回路。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define Maxn 1005
#define Maxm 10005

int first[Maxn],next[Maxm];
int tot,tot2;

struct Edge
{
    int a,b;
}edge[Maxm],edge2[Maxm];

//scc相关
int dfn[Maxn],low[Maxn],scccno[Maxn],dfs_clock,scc_cnt;
bool instack[Maxn];
stack st;

//缩点相关
int first2[Maxn],next2[Maxm],indeg[Maxn];

void init()
{
    memset(first,-1,sizeof(first));
    tot = 0;
}
void addEdge(int a,int b)
{
    edge[tot].a = a,edge[tot].b = b;
    next[tot] = first[a];
    first[a] = tot++;
}
void addEdge2(int a,int b)
{
    edge2[tot2].a = a,edge2[tot2].b = b;
    next2[tot2] = first2[a];
    first2[a] = tot2++; 
}
void tarjan(int u)
{
    dfn[u] = low[u] = ++dfs_clock;
    st.push(u);
    instack[u] = true;
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v = edge[i].b;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u] = min(low[u],dfn[v]); 
        }
    }
    if(low[u] == dfn[u])
    {
        scc_cnt++;
        while(1)
        {
            int v = st.top();
            st.pop();
            instack[v] = false;
            scccno[v] = scc_cnt;
            if(u == v) break;
        }
    }
}
void find_scc(int n)
{
    dfs_clock = scc_cnt = 0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(instack,false,sizeof(instack));
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i]) tarjan(i);
    }
}
void getDag(int n)
{
    memset(first2,-1,sizeof(first2));
    memset(indeg,0,sizeof(indeg));
    tot2 = 0;
    for(int i=1;i<=n;i++)
    {
        for(int v=first[i];v!=-1;v=next[v])
        {
            int j = edge[v].b;
            if(scccno[i]!=scccno[j])
            {
                addEdge2(scccno[i],scccno[j]);
                indeg[scccno[j]]++;
            }
        }
    }
}

bool toposort(int n)
{
    queue q;
    for(int i=1;i<=n;i++)
    {
        if(indeg[i] == 0) q.push(i);
    }
    while(!q.empty())
    {
        int temp = q.front();
        q.pop();
        if(!q.empty()) return false;
        for(int i=first2[temp];i!=-1;i=next2[i])
        {
            int v = edge2[i].b;
            indeg[v]--;
            if(indeg[v] == 0) q.push(v);
        }
    }
    return true;
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
    #endif
    int n,m;
    int t;
    int a,b;
    scanf(" %d",&t);
    while(t--)
    {
        init();
        scanf(" %d %d",&n,&m);
        for(int i=0;i

4.有向图的欧拉回路求法:

其实做法是和无向图类似的,直接用DFS 即可解决。

判断入度和出度的关系,以及连通性(并查集可以判断弱连通性)

下面一道题练习欧拉路径:

Poj 2337 Catenyms

题目连接:http://poj.org/problem?id=2337

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define Maxn 30
#define Maxm 2000

struct Edge
{
	int vis,v;
	char str[30];
	bool operator < (const Edge a) const
	{
		return strcmp(str,a.str)<0;
	}
};

vector g[Maxn];
int in[Maxn],out[Maxn];
int father[Maxn];
int used[Maxn];
int s;
Edge path[Maxm];
int top;

void init()
{
	for(int i=0;i=0;i--)
	{
		if(i == top-1) printf("%s",path[i].str);
		else printf(".%s",path[i].str);
	}
	puts("");
}
int main()
{
	#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	#endif
	int t;
	int n;
	int x,y;
	char str[30]; 
	scanf(" %d",&t);
	while(t--)
	{
		init();
		scanf(" %d",&n);
		s = 100000;
		for(int i=0;i




你可能感兴趣的:(Algorithm_图论)