欧拉回路的路径输出——逆序输出 UVA 10054 The Necklace

先要保证图连通，并且每个点的度数为偶数。

然后从某一个点出发必然可以遍历完全图。

在每一个点处进行dfs。

若顺序输出，则:

void euler(int u)  （这两份代码借鉴别人的http://www.cnblogs.com/scau20110726/archive/2012/11/09/2762371.html）
{
    int v;
    for(v=1; v<=50; v++) 
        if(g[u][v])
        {
            g[u][v]--;
            g[v][u]--;

　　　　　　　printf("%d %d\n",u,v);

　　　　　　  euler(v);

    //这样相当于顺序输出
        }
}

逆序则：

void euler(int u)
{
    int v;
    for(v=1; v<=50; v++) 
        if(g[u][v])
        {
            g[u][v]--;
            g[v][u]--;
            euler(v);
            printf("%d %d\n",v,u);
            //一定要逆序输出，而且注意输出的边是(v,u)而不是(u,v)
        }
}

顺序输出有问题，问题在于最后输出的点可能连接不起来，

这种情况的出现是因为，每个点A从一条路到达之后，开始dfs，如果与到达A的路径形成一个环，那么会停住（停在相交点），回不到该点，回溯，再搜，然而起点还是A，从此断掉。(后面有图示说明)

逆序输出一定没有问题，顺序输出之所以会断掉就是点A出发的路径与之前到A的路径形成一个环，我们可以这样考虑：

到达点A后，最多就就有两条路：路径1.是与之前到A的路径形成一个环的路径

                                                     路径2.A出发，然后遍历完全图的路径（到A之前走过的路和路径1不算） 

首先逆序输出，如果B->A,那么A B在底行,

搜索的顺序无非两种，假设最开始都从X出发。

a.先1后2（路径1和2）

情形：     
             /* X  .    路径1 
                .  .    
                .  A   */
            /*  A  .
                .  .    路径2 ，因为(之前没有走过的路+路径1所)剩余的路，一定可以从A出发然后回到A点
                .  A   */从这里开始拓展点A，进行搜索
            /*  A  B     初到A
                B  .
                .  .       之前的路
                .  X    */

b.先2后1

情形：       这里路径1和2的意义有所变化
            /*  X  .
                .  .    路径2 ，因为最开始从X出发，又不走回X路径1，所以一定可以从A出发然后回到X点
                .  A   */
             /* A  .    路径1 ，因为先走了路径2（回到了X），如果A还有路，一定可以从A点出发回到A
                .  .    
                .  A   */
            /*  A  B
                B  .
                .  .       之前的路
                .  X    */
               

 至此首尾无缝衔接，逆序输出一切正常。

   我们再来看看顺序输出断掉的情形：

情形：        
     /*     X .   从X出发，到A
            . B
            B A        */
      /*    A .     先走路径1回到X
            . .
            . X  */
       /*   A .     回溯，再走路径2，从此断掉，wa!
            . . 
            . A  */

代码：

#include<cstdio>
#include<cstring>
#include<iostream>

using namespace std;
const int maxn= 52  ;
const int maxm= maxn*maxn   ;
int u[maxm],v[maxm];
 int in[maxn],fir[maxn],nex[maxm];
 bool vis[maxm];
 int pre[maxn];
int e_max,n;
int find(int x)
{
    return x==pre[x]?x:pre[x]=find(pre[x]);
}

void merge(int u ,int v)
{
    int x=find(u);
    int y=find(v);
    if(x!=y)
    pre[x]=y;
}
void init()
{
    memset(vis,0,sizeof vis);
    memset(fir,-1,sizeof fir);
    e_max=0;
    for(int i=1;i<=50;i++)
        pre[i]=i,in[i]=0;
}
inline void add_edge(int s,int t)
{
    int e=e_max++;
    u[e]=s;
    v[e]=t;
    nex[e]=fir[s];
    fir[s]=e;
}

void dfsprint(int x)
{
    for(int &e=fir[x];~e;)
    {
        if(vis[e])  {e=nex[e];continue;}
        int y=v[e];
        vis[e]=1;
        vis[1^e]=1;
        e=nex[e];
        dfsprint(y);
        printf("%d %d\n",y,x);
     }

}

int main()
{
  int T,x,y,kase=0;scanf("%d",&T);
  while(T--)
  {
      if(kase>0)   putchar('\n');
      init();
      scanf("%d",&n);
      while(n--)
      {
          scanf("%d%d",&x,&y);
          merge(x,y);
          in[x]++,in[y]++;
          add_edge(x,y);
          add_edge(y,x);

      }
      bool ok=1;
      bool vis=0;int prin,st;
      for(int i=1;i<=50;i++)
      {
          if(!in[i])  continue;
          if(in[i]%2   )  {ok=0;break;}
          if(  !vis  )  { prin=find(i),vis=1,st=i;continue;}
          if(prin!=find(i)) {ok=0; break;   }



      }
      printf("Case #%d\n",++kase);
      if( !ok )   {puts("some beads may be lost");continue;}
//    cout<<st<<endl;
  dfsprint(st);
/*for(int i=1;i<=50;i++)
{
    dfsprint(i);
}*/


  }

    return 0;
}

具体的可以看：http://www.cnblogs.com/scau20110726/archive/2012/11/09/2762371.html