CCF送货(欧拉图)

问题描述

　　为了增加公司收入，F公司新开设了物流业务。由于F公司在业界的良好口碑，物流业务一开通即受到了消费者的欢迎，物流业务马上遍及了城市的每条街道。然而，F公司现在只安排了小明一个人负责所有街道的服务。
　　任务虽然繁重，但是小明有足够的信心，他拿到了城市的地图，准备研究最好的方案。城市中有n个交叉路口，m条街道连接在这些交叉路口之间，每条街道的首尾都正好连接着一个交叉路口。除开街道的首尾端点，街道不会在其他位置与其他街道相交。每个交叉路口都至少连接着一条街道，有的交叉路口可能只连接着一条或两条街道。
　　小明希望设计一个方案，从编号为1的交叉路口出发，每次必须沿街道去往街道另一端的路口，再从新的路口出发去往下一个路口，直到所有的街道都经过了正好一次。
输入格式
　　输入的第一行包含两个整数n, m，表示交叉路口的数量和街道的数量，交叉路口从1到n标号。
　　接下来m行，每行两个整数a, b，表示和标号为a的交叉路口和标号为b的交叉路口之间有一条街道，街道是双向的，小明可以从任意一端走向另一端。两个路口之间最多有一条街道。
输出格式
　　如果小明可以经过每条街道正好一次，则输出一行包含m+1个整数p1, p2, p3, …, pm+1，表示小明经过的路口的顺序，相邻两个整数之间用一个空格分隔。如果有多种方案满足条件，则输出字典序最小的一种方案，即首先保证p1最小，p1最小的前提下再保证p2最小，依此类推。
　　如果不存在方案使得小明经过每条街道正好一次，则输出一个整数-1。
样例输入
4 5
1 2
1 3
1 4
2 4
3 4
样例输出
1 2 4 1 3 4
样例说明
　　城市的地图和小明的路径如下图所示。

样例输入
4 6
1 2
1 3
1 4
2 4
3 4
2 3
样例输出
-1
样例说明
　　城市的地图如下图所示，不存在满足条件的路径。

评测用例规模与约定
　　前30%的评测用例满足：1 ≤ n ≤ 10, n-1 ≤ m ≤ 20。
　　前50%的评测用例满足：1 ≤ n ≤ 100, n-1 ≤ m ≤ 10000。
　　所有评测用例满足：1 ≤ n ≤ 10000，n-1 ≤ m ≤ 100000。

题解

很容易看出来这是一个一笔画问题，能够一笔画的图叫做欧拉图

理论

1. 一个连通无向图，每个点的度都是偶数，那么存在从任意点开始的欧拉闭迹
2. 一个连通无向图，只有两个点a,b的度是奇数，那么存在从a或b开始以b或a结束的欧拉开迹

算法

可以参考组合数学里面的图论，其中上面理论证明过程就显示了以下构造欧拉迹的算法：

理论中的第一种情况：

1. 设起点为a,令u=a,end=a;
2. 从源点u出发，任意选择一条未走过的边(u,v),加入到路径当中
3. 若v=end(回到源点，可以保证一定可以回到源点)，跳到步骤4，否则，令u=v，返回步骤2
4. 若路径中存在点p，其连接的边没有走完,令u=p，end=p,返回步骤2，并将新产生的路劲合并到原路径当中
   这样就可以生成一条欧拉迹

理论中的第二种情况

1. 设起点为a，终点为b，首先用和第一种情况一样的办法构造一条a到a的迹（这时还有一条a到b的简单路径没有走）
2. 将这条简单路径加入先前的迹，就构造出一条欧拉迹

考虑字典序

可以证明，按照下面两个规则，可以保证字典序最小：
1. 每次选择边(u,v)加入到路径中时，选择v最小的边
2. 当前迹存在多个点有没走的边的，选择迹经过的最后一个点扩充迹，依然按照1中的规则
举例来说：

迹扩展的顺序为：

图中由上面一行的一个点指向下面一行的圈起来的点表示扩充
简单证明如下：
1:假设按照上述规则生成的路径为a1,a2,a3…ak..a1,字典序最小的是a1,a2,a3…bk…b1（也就是说，两条路径从k开始不一样）,那么ak

实现

1. 由于原输入没有排序，边数又比较多，点的序号还是连续的，可以选择稳定快速的计数排序，先对v排序，再对u排序
2. dfs过程中，根据点的度数和已经访问点的次数来判断点又没有没走的边，如果有，加入到一个栈中，dfs直到回到源点
3. 从栈中弹出一个元素，以改点作为源点继续dfs
   想到这里就复杂，不敢撸代码了…上一个初始过程参考一下
   这里我们要知道x^(x^y)=x,这是个很有用的公式

#include<stdio.h>
#include<stdlib.h>
typedef struct node node;
typedef struct edge{
    node *p;//这里存的是两端点指针的异或值，方便得出另一端的指针
    int visited;//判断边是否走过
}edge;
typedef struct le{//link_edge,挂在node上，便于访问
    edge *pe;//指向的边
    struct le *next;
}le;
typedef struct node{
    le *head,*tail,*now;//因为要从小到大插入，用head和tail指向链表的开头和结尾更方便
    int ok,i;//ok表示是否有未走的边
}node;
typedef struct gve{
    int vn,en;
    node *v;
    le *e;
}gve;
node *pxor(node *p1,node *p2)//指针异或,c语言不支持指针的直接异或
{
    return (node *)((long)p1^(long)p2);
}
int in_edge(node *pnode,edge *New)
{
    le *newle;
    newle=(le *)malloc(sizeof(le));
    newle->pe=New;
    newle->next=NULL;
    if (pnode->tail==NULL)
    {
        pnode->head=newle;
        pnode->tail=newle;
    }
    else
    {
        pnode->tail->next=newle;
        pnode->tail=newle;
    }
    return 0;
}
int init(gve *G)
{
    scanf("%d%d",&G->vn,&G->en);
    G->v=(node *)malloc(sizeof(node)*(G->vn+1));
    G->e=(le *)malloc(sizeof(le)*(G->en+1));
    int i;
    for (i=1;i<=G->vn;i++)
    {
        G->v[i].head=NULL;
        G->v[i].tail=NULL;
        G->v[i].ok=0;
        G->v[i].i=i;
    }
    int a,b;
    edge *New;
    for (i=1;i<=G->en;i++)
    {
        scanf("%d%d",&a,&b);
        New=(edge *)malloc(sizeof(edge));
        New->p=pxor(G->v+a,G->v+b);
        New->visited=0;
        in_edge(G->v+a,New);
        in_edge(G->v+b,New);
    }
    for (i=1;i<=G->vn;i++)
        G->v[i].now=G->v[i].head;
    return 0;
}
//int print(gve G)
//{
//  int i;
//  printf("v:%d e:%d\n",G.vn,G.en);
//  for (i=1;i<=G.vn;i++)
//  {
//      
//      printf("%d: ",G.v[i].i);
//      le *tmp=G.v[i].head;
//      while (tmp!=NULL)
//      {
//          node *pnode=pxor(G.v+i,tmp->pe->p);
//          printf("%d ",pnode->i);
//          tmp=tmp->next;
//      }
//      printf("\n");
//  }
//  return 0;
//}

int main(void)
{
    gve G;
    init(&G);
    //print(G);
}

就这样了，以后慢慢写完这个代码吧，还没排序呢。。。