hdu6311 Cover(对多个联通块求欧拉回路，并打印路径)

题目： http://acm.hdu.edu.cn/showproblem.php?pid=6311

围观大神博客： http://www.cnblogs.com/stranger-/p/9379603.html

题意：有一个无向图，不连通，这个图有1~n条边，用编号标记某条边，用正负表示方向

比如输入3条边 1 2 ,1 3 , 2 3；输出 1 3 -1 表示 1->2->3->1

问一个士兵能够遍历完一条路径(包含多条边)，但不能重复走某一条边，最少需要多少个士兵才能走完这个图？

并输出这些士兵的行走路线。。

看起来很像欧拉通路，可以用欧拉通路求解。

.......一开始想把所有的联通块全部合并成一个连通图，结果发现自己搞得更麻烦了，唉

//对每一个 联通块(除了独立点)求 欧拉回路
//我们用dfs求出某一个联通块后 
//1.2如果联通块中的全部度数都是偶数，或者只有2个几度，直接 求欧拉回路 ，一笔就可以画完，所以 路径数目 c = c+1
//1.3如果联通块存在多个奇度点num个，那么我们自己加边，将num-2个奇度点两两相连，记得标记，再对这个图求欧拉回路，
//   求欧拉回路 的过程中 如果遇到我们自己加的边，则路径数目c++; 因为这个一笔画是我们加边形成的，所以应该根据这些我们自己加的边
//   把这个一笔画截断，才是该联通块的路径数。 
#include<stdio.h>
#include<memory.h>
#include<stack>
#include<queue>
using namespace std;
const int maxn = 100000+10;
struct Edge
{
    int to,next;
    int wi;//wi == 0表示这条边是我们自己加的 
};
Edge edge[maxn*10];//边太多了，开个10倍比较稳 
int cnt ;
int head[maxn];
void addEdge(int from,int to,int wi)
{
    edge[++cnt].to = to;
    edge[cnt].next = head[from];
    edge[cnt].wi = wi;
    head[from] = cnt;
}
int n,m;
int du[maxn];
int signal;
bool visit[maxn];
void init()
{
    memset(visit,false,sizeof(visit));
    cnt = 0;
    for(int i=1;i<=n;i++)
    {
        head[i] = 0;
        du[i] = 0;
    }
}
vector<int>ji;
void dfs1(int s)
{
    visit[s] = true;
    if(du[s]%2)ji.push_back(s);
    signal++;
//    printf("s==%d\n",s);
    for(int i=head[s];i;i=edge[i].next)
    {
        int to = edge[i].to;
        if(visit[to]) continue;
        dfs1(to);
    }
}
int main()
{
    vector<int>ans[100000+1];//路径 
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=1;i<=m;i++)
        {
            int from,to;
            scanf("%d%d",&from,&to);
            addEdge(from,to,i);
            addEdge(to,from,-i);
            du[from] ++;
            du[to] ++;
        } 
        int c = 0;
        for(int i=1;i<=n;i++)
        {
            if(visit[i]) continue;
            signal = 0;
            ji.clear();
            dfs1(i);
            if(signal<=1) continue;
            c++;
            for(int j=2;j<ji.size();j=j+2)
            {
                addEdge(ji[j],ji[j+1],0);
                addEdge(ji[j+1],ji[j],0);
//                printf("加边....%d %d\n",ji[j],ji[j+1]);
                du[ji[j]]++;
                du[ji[j+1]]++;
            }
            int s = ji.size()>0 ? ji[0]:i;
            int stk[maxn*10];
            int sktop = 0;
            
            int path[maxn*10];
            int phtop = 0;
            
            stk[++sktop] = s;
//            stk.push(s);
//            printf("s==%d\n",s);
            bool flag[maxn*10] = {false};//这条边是否还存在
            while(sktop>0)
            {
                int x = stk[sktop];
                int p ;
                while(head[x] && flag[head[x]])
                {
                    head[x] = edge[head[x]].next;
                }
                p = head[x];
                if(p==0)
                {
                    if(phtop>0)
                    {
                        int top = path[phtop--];
                        if(top==0)
                        {
                            c++;
                        }else{
                            ans[c].push_back(top);
                        }
                    }
                    sktop--;                    
                    continue;
                }
                head[x] = edge[p].next;
                stk[++sktop] = edge[p].to;
                path[++phtop] = edge[p].wi;
                int pp = (p&1)?p+1:p-1; 
//                printf("下来了p==%d,pp==%d\n",p,pp);
                flag[p] = flag[pp] = true;//遍历过了 
            }
        }
        printf("%d\n",c);
        for(int i=1;i<=c;i++)
        {
            printf("%d",ans[i].size());
            for(int j=ans[i].size()-1;j>=0;j--)
            {
                printf(" %d",ans[i][j]);
            }
            printf("\n");
            ans[i].clear();
        } 
    }
    return 0;
}//1466ms c++

还是继续加油吧，渣科