弗罗莱（Fleury）算法 欧拉（Euler）通路/回路

转载地址：http://blog.csdn.net/zyy617532750/article/details/50981888

1、基本概念：

（1）欧拉图的基本概念：

欧拉通路 (欧拉迹)：通过图中每条边一次且仅一次，并且过每一顶点的通路。

欧拉回路 (欧拉闭迹)：通过图中每条边一次且仅一次，并且过每一顶点的回路。

欧拉图：存在欧拉回路的图。欧拉图就是从一顶点出发每条边恰通过一次又能回到出发顶点的那种图，即不重复的行遍所有的边再回到出发点。

通路和回路：称v_ie₁e₂…e_nv_j为一条从 v_i到 v_j且长度为n的通路，其中长度是指通路中边的条数．称起点和终点相同的通路为一条回路。

简单图:不含平行边和自回路的图。

混合图：既有有向边，也有无向边的图

平凡图：仅有一个结点的图

完全图:有n个结点的且每对结点都有边相连的无向简单图，称为无向完全图；有n个结点的且每对结点之间都有两条方向相反的边相连的有向简单图为有向完全图。

（2）欧拉图的特征：
 无向图

a）G有欧拉通路的充分必要条件为：G 连通，G中只有两个奇度顶点(它们分别是欧拉通路的两个端点)。

b）G有欧拉回路(G为欧拉图)：G连通，G中均为偶度顶点。 
 有向图

a）D有欧拉通路：D连通，除两个顶点外，其余顶点的入度均等于出度，这两个特殊的顶点中，一个顶点的入度比出度大1，另一个顶点的入度比出度小1。

b）D有欧拉回路(D为欧拉图)：D连通，D中所有顶点的入度等于出度。一个有向图是欧拉图，当且仅当该图所有顶点度数都是0。

2 、弗罗莱（Fleury ）算法思想－解决欧拉回路

    Fleury算法：
   任取v0∈V(G)，令P0=v0；

设Pi=v0e1v1e2…ei vi已经行遍，按下面方法从中选取ei+1：

（a）ei+1与vi相关联；

（b）除非无别的边可供行遍，否则ei+1不应该为Gi=G-{e1,e2, …, ei}中的桥（所谓桥是一条删除后使连通图不再连通的边）；

（c）当（b）不能再进行时，算法停止。

可以证明,当算法停止时所得的简单回路Wm=v0e1v1e2….emvm(vm=v0)为G中的一条欧拉回路，复杂度为O(e*e)。

3 、欧拉算法C 语言描述

[cpp]  view plain  copy

 print ?

1. void DFS(Graph &G,SqStack &S,int x,int t)  
2. {  
3.        k=0;//一个标志,来标记当前访问的节点是否还有邻接边可供访问  
4.        Push(S,x); //将本次遍历边所经由的点入栈  
5.        for(i=t;i<v;i++) //v是顶点数,e是边数  
6.         if(G[i][x]>0)    
7.          {  
8.           k=1;  
9.           G[i][x]=0; G[x][i]=0; //此边已访问,删除此边  
10.           DFS(G,S,i,0);//寻找下一条关联的边,本次找到的是与x关联的i,在  
11.                         //下一层中将寻找与i关联的边  
12.           break;  
13.          }//if,for  
14.        if(k==0)       //如果k=0,说明与当前顶点关联的边已穷尽  
15.        {  
16.               Pop(S);  
17.               GetTop(S,m);  
18.               G[x][m]=1;G[m][x]=1;//恢复在上一层中被删除的边  
19.               a=x+1;//如果可能的话,从当前节点的下一条关联边开始搜寻  
20.               if(StackLength(S)!=e)//继续搜寻,边还没有全部遍历完  
21.               {  
22.                      Pop(S); //还原到上一步去  
23.                      DFS(G,S,m,a);//  
24.               }//if  
25.               else   //搜寻完毕,将最后节点也入栈  
26.                      Push(S,x);  
27.        }//if  
28. }//DFS  
29.    
30. void Euler(Graph &G,int x)  
31. {  
32. //G是存储图的邻接矩阵,都处理成无向图形式,值为1代表有边,0代表无边,不包括自回路,x是出发点  
33. InitStack(S);//用来存放遍历边时依次走过的顶点  
34. DFS(G,S,x,0);//深度优先遍历查找,0是指查询的起点  
35. //输出  
36.  while(!StackEmpty(S))  
37.  {  
38.   GetTop(S,m);  
39.   printf("->v%d",m);  
40.   Pop(S);  
41.  }//while  
42. }//Euler</span>  

如下为算法的图示动态过程：

4、欧拉算法的C实现

[cpp]  view plain  copy

 print ?

1. #include "SqStack.h" //堆栈的常见操作  
2. #include "Queue.h"//队列的常见操作  
3.    
4. typedef int Graph[200][200];  
5. int v,e;  
6.    
7. void DFS(Graph &G,SqStack &S,int x,int t)  
8. {  
9.        int k=0,i,m,a;  
10.        Push(S,x);  
11.        for(i=t;i<v;i++)  
12.               if(G[i][x]>0)  
13.               {  
14.                      k=1;  
15.                      G[i][x]=0; //删除此边  
16.                      G[x][i]=0;  
17.                      DFS(G,S,i,0);  
18.                      break;  
19.               }//if,for  
20.        if(k==0)  
21.        {  
22.               Pop(S);  
23.               GetTop(S,m);  
24.               G[x][m]=1;//恢复刚刚删除的边  
25.               G[m][x]=1;  
26.               a=x+1;//从下一条边开始搜寻  
27.               if(StackLength(S)!=e)  
28.               {  
29.                      Pop(S);  
30.                      DFS(G,S,m,a);  
31.               }//if  
32.               else  
33.                      Push(S,x);  
34.        }//if  
35. }//DFS  
36.    
37. int BFSTest(Graph G)  
38. {  
39.        int a[200],x,i,k=0;  
40.        LinkQueue Q;  
41.        InitQueue(Q);  
42.        EnQueue(Q,0);  
43.        for(i=0;i<v;i++)  
44.               a[i]=0;  
45.        a[0]=1;  
46.        while(!QueueEmpty(Q))  
47.        {  
48.               DeQueue(Q,x);  
49.               for(i=0;i<v;i++)  
50.                      if(G[x][i]>0)  
51.                             if(a[i]!=1)  
52.                             {  
53.                                    a[i]=1;  
54.                                    EnQueue(Q,i);  
55.                             }//if  
56.        }//while  
57.        for(i=0;i<v;i++)  
58.               if(a[i]==0)  
59.               {  
60.                      k=1;  
61.                      break;  
62.               }  
63.        if(k==1)  
64.               return 0;  
65.        else  
66.               return 1;  
67. }  
68.    
69. void Euler(Graph &G,int x)  
70. {  
71.        int m;  
72.        SqStack S;  
73.        InitStack(S);  
74.        DFS(G,S,x,0);  
75.        printf("该图的一个欧拉回路为：");  
76.        while(!StackEmpty(S))  
77.        {  
78.               GetTop(S,m);  
79.               printf("->v%d",m);  
80.               Pop(S);  
81.        }//while  
82. }  
83.    
84. void InputM1(Graph &G)  
85. {  
86.    
87. int h,z;  
88. printf("Please input 顶点数和边数\n");  
89. scanf("%d",&v);  
90. scanf("%d",&e);  
91. for(int i=0;i<v;i++)  
92.        for(int j=0;j<v;j++)  
93.               G[i][j]=0;  
94.    
95. printf("please int the 邻接矩阵的值(起点(数字) 终点(数字))：\n");  
96. for(int i=0;i<e;i++)  
97.   {  
98.        scanf("%d",&h);  
99.        scanf("%d",&z);  
100.        G[h-1][z-1]=1;  
101.           G[z-1][h-1]=1;  
102.   }//for  
103. }//InputM1  
104.    
105. int main()  
106. {  
107.        int i,j,sum,k=0;  
108.        Graph G;  
109.        InputM1(G);  
110.        if(BFSTest(G)==0)  
111.        {  
112.               printf("该图不是连通图!\n");  
113.               exit(0);  
114.        }//if  
115.        for(i=0;i<v;i++)  
116.        {  
117.               sum=0;  
118.               for(j=0;j<v;j++)  
119.                      sum+=G[i][j];  
120.               if(sum%2==1)  
121.               {     k=1;  
122.                      break;  
123.               }//if  
124.        }//for  
125.        if(k==1) printf("该图不存在欧拉回路！\n");  
126.        else  
127.               Euler(G,0); //从那个点出发  
128. return 1;  
129. }  

[cpp]  view plain  copy

 print ?

1. 顶点数5，边数为6  
2. 相关联的点1 2  
3.           1 3  
4.           2 5  
5.           4 2  
6.           3 2  
7.           4 5  

5、小常识：欧拉算法的起由及一笔画问题

七桥问题：18世纪著名古典数学问题之一。在哥尼斯堡的一个公园里，有七座桥将普雷格尔河中两个岛及岛与河岸连接起来(如图)。问是否可能从这四块陆地中任一块出发，恰好通过每座桥一次，再回到起点？欧拉于1736年研究并解决了此问题，他把问题归结为如下右图的“一笔画”问题，证明上述走法是不可能的。

一笔划：

⒈凡是由偶点组成的连通图，一定可以一笔画成。画时可以把任一偶点为起点，最后一定能以这个点为终点画完此图。

⒉凡是只有两个奇点的连通图（其余都为偶点），一定可以一笔画成。画时必须把一个奇点为起点，另一个奇点终点。

⒊其他情况的图都不能一笔画出。（奇点数除以二便可算出此图需几笔画成。）