首先我们来百度一下，欧拉路径以及回路的定义：
若图G中存在这样一条路径，使得它恰通过G中每条边一次,则称该路径为欧拉路径。若该路径是一个圈，则称为欧拉(Euler)回路。
具有欧拉回路的图称为欧拉图(简称E图)。具有欧拉路径但不具有欧拉回路的图称为半欧拉图。
通俗来说,就是欧拉路径就是图中的每条边经过却只经过一次的路径，而最后回到起点的路径就是欧拉回路。
那给你一个图怎么判断存不存在，欧拉路径或者欧拉回路呢
首先，判断图是不是连通的，这个就很简单了，dfs或者并查集都可以。
然后就是根据定理
欧拉路径的定理
连通的无向图有欧拉路径的充要条件是：
G中奇顶点（连接的边数量为奇数的顶点）的数目等于0或者2。
连通的无向图是欧拉环（存在欧拉回路）的充要条件是：
G中每个顶点的度都是偶数。
欧拉回路的定理
无向图存在欧拉回路的充要条件
一个无向图存在欧拉回路，当且仅当该图所有顶点度数都为偶数,且该图是连通图。
有向图存在欧拉回路的充要条件
一个有向图存在欧拉回路，所有顶点的入度等于出度且该图是连通图。
这四个定理很好理解，无向图的话，因为要把所有边走一遍且只走一边，那对于每个点来说，如果不是起点或者终点的话，那么度数应该是偶数，有一条进边就有一条对于的出边，然后是起点，出边应该多一条，终点应该入边多一条，所以度数是奇数。然后如果没有奇数点的话，那就是任意点都可以作为起点并且能走回它，那就是存在一个回路了，否则就是得两个奇数点，一个起点和一个终点。
有向图的话，就是分为入度出度，道理是一样的，然后我们就可以来做题了
欧拉回路
中文题，真模板题，给一个无向图，问存不在在欧拉回路，存在扣1，不存在扣0.
直接并查集判断连通性，只能有一个连通集，然后判断度数，不存在奇数度的点，就ok了。
1 #include<cstdio>
2 const int N=1108;
3 int fa[N],in[N];
4 int find(int x){
5 return fa[x]==x ? x : fa[x]=find(fa[x]);
6 }
7 void bing(int x,int y){
8 int fx=find(x),fy=find(y);
9 if(fx!=fy) fa[fx]=fy;
10 return ;
11 }
12 int main(){
13 int n,m,u,v;
14 while(scanf("%d%d",&n,&m)&&n){
15 for(int i=0;i<=n;i++){
16 fa[i]=i;
17 in[i]=0;
18 }
19 while(m--){
20 scanf("%d%d",&u,&v);
21 in[u]++;
22 in[v]++;
23 bing(u,v);
24 }
25 int flag=1,num=0;
26 for(int i=1;i<=n;i++){
27 fa[i]=find(fa[i]);
28 if(fa[i]==i) num++;
29 if(num>1) flag=0;
30 if(in[i]&1) flag=0;
31 if(!flag) break;
32 }
33 printf("%d\n",flag);
34 }
35 return 0;
36 }
板子敲敲
Ant Trip HDU - 3018
题意：给一个无向图问，最少分几组能够把所有边走且走一遍？
要把所有边走且只走一遍，其实就是在求一个欧拉路径，但一条路径不一定能把所有边走完，这里要求的就是最少分出多少条欧拉路径。
我们从无向图的欧拉路径定理下手，图中奇顶点（连接的边数量为奇数的顶点）的数目等于0或者2。
那我们先用并查集判断有多少个连通集，然后对于每个连通集，如果它没有奇度点的话，那么一条欧拉路径就能把它的边走完，那如果它的奇度点的个数为x的话，每2个奇度点就能走一条欧拉路径，所以最少就需要（x+1）/2条。
1 #include<cstdio>
2 const int N=100118;
3 int fa[N],in[N],num[N];
4 int find(int x){
5 return fa[x]==x ? x : fa[x]=find(fa[x]);
6 }
7 void bing(int x,int y){
8 int fx=find(x),fy=find(y);
9 if(fx!=fy) fa[fx]=fy;
10 return ;
11 }
12 int main(){
13 int n,m,u,v;
14 while(~scanf("%d%d",&n,&m)){
15 for(int i=0;i<=n;i++){
16 fa[i]=i;
17 in[i]=0;
18 num[i]=0;
19 }
20 while(m--){
21 scanf("%d%d",&u,&v);
22 in[u]++;
23 in[v]++;
24 bing(u,v);
25 }
26 for(int i=1;i<=n;i++){
27 fa[i]=find(fa[i]);
28 if(in[i]&1) num[fa[i]]++;
29 }
30 int ans=0;
31 for(int i=1;i<=n;i++){
32 if(fa[i]!=i) continue;
33 if(!num[i]&&in[i]) ans++;
34 else if(num[i]) ans+=(num[i]+1)/2;
35 }
36 printf("%d\n",ans);
37 }
38 return 0;
39 }
几笔画
Play on Words UVA - 10129
题意：给两个单词，如果其中一个的最后一个单词等于另外一个的第一个单词的话，那就可以把它们串起来，问能不能把所有单词串起来。
单纯看每个单词的话，那就是得在每两个能串的单词之间连一条边，1e5个单词，这样很明显直接会T，我们想一下，如果一个单词能和其他单词串起来，那不就是它首字母的入度+1或者尾字母的出度+1,然后每个单词其实就是它首字母和尾字母的一条有向边。
这样把所有单词串起来，就是问有向图有没有欧拉路径，我们根据定理判断就ok了。
1 #include<cstdio>
2 #include<cstring>
3 int in[28],out[28],fa[28];
4 int find(int x){
5 return fa[x]==x ? x : fa[x]=find(fa[x]);
6 }
7 void bing(int x,int y){
8 int fx=find(x),fy=find(y);
9 if(fx!=fy) fa[fx]=fy;
10 return ;
11 }
12 char s[1010];
13 int main(){
14 int t,n,lens;
15 scanf("%d",&t);
16 while(t--){
17 scanf("%d",&n);
18 for(int i=0;i<=26;i++){
19 fa[i]=i;
20 in[i]=out[i]=0;
21 }
22 for(int i=0;i<n;i++){
23 scanf("%s",s);
24 lens=strlen(s);
25 in[s[0]-‘a‘]++;
26 out[s[lens-1]-‘a‘]++;
27 bing(s[0]-‘a‘,s[lens-1]-‘a‘);
28 }
29 int flag=1,num1=0,num2=0,num3=0;
30 for(int i=0;i<26;i++){
31 if(in[i]-out[i]==1) num1++;
32 else if(out[i]-in[i]==1) num2++;
33 else if(in[i]!=out[i]) flag=0;
34 if(find(fa[i])==i&&(in[i]||out[i])) num3++;
35 if(num1>1||num2>1||num3>1) flag=0;
36 if(!flag) break;
37 }
38 // printf("%d %d %d %d\n",flag,num1,num2,num3);
39 if(flag&&num1==num2) printf("Ordering is possible.\n");
40 else printf("The door cannot be opened.\n");
41 }
42 return 0;
43 }
有向的哦
知道怎么判定有没有欧拉路径或者欧拉回路了，那怎么求欧拉路径或者欧拉回路呢？
两个方法，套圈（暴搜）法或者fleury算法。
首先是套圈法，先上代码。
1 void dfs(int u){
2 for(int i=1;i<=n;i++){
3 if(ok[u][i]){
4 ok[u][i]--;
5 ok[i][u]--;
6 dfs(i);
7 }
8 }
9 ans[cnt++]=u;
10 }
欧拉魔力套圈圈
什么意思呢，从一个点出发，能走到哪个点我们就走到哪个点，并且把这条边删除掉，直到这个点走不到其他点了，我们就把它记录下来，然后再把记录点逆序输出。
为什么呢？首先我们先判断有没有欧拉路径或者欧拉回路，有的话那肯定是能走出来的。
然后起点，对于欧拉回路的话，任意点可以作为起点，而欧拉路径的话我们以一个奇度点为起点。从起点出发走，当一个点已经无边可走了，那说明它是当前一个终点或是一个圈的起点。
我们来模拟一下。
第一个图这个1到2到3没路了，这时候很明显3是终点了，开始回溯。
第二图的话，3到2到1到3到4到6到5到4，这样的话4是终点，开始回溯是能走出一条欧拉路径，但我们不可能限定3一定先走到2，可能的是3先走到4。
这时候就是，3走到4,4到6,6到5,5到4，没有路了，把4记录下来，然后回到5，也没路了，再记录下来，接下来6,4，也是一样，直到3,3还能到1，那我们继续走3,1,2,到3没路了，回溯。
欧拉路径我们把逆序把记录的点输出就是3,2,1,3,4,6,5,4，也就是3,2,1,3这个圈再套上了4,6,5,4这个圈。
套圈法的意思其实就是，因为欧拉路径要么一个点同时做起点和终点（回路），或者一个做起点，一个做终点，那么当走到一个点不能再走时，很明显它就是当前的一个终点了，我们就开始回溯，但有可能的就是我们中途走了‘’桥”,如上面的3-4，所以回溯时有点还能继续往下走我们就让它先走，然后再走“桥”。
这样其实就是如果只有一个圈，那就是直接走到终点回溯，多个圈的话，就是先走了圈，然后再走“桥”，把它跟其他桥套起来。
实现上其实就是像上面代码写的，一个点能走到那个点就走，同时把走的这条边删除（注意无向边和有向边），直到一个点无边可走，记录下来，回溯，也就是个dfs过程。
然后fleury算法的话，直接引用guomutian911的博客Fleury (弗罗莱) 算法通俗解释
网上也很多这个算法的代码以及解释，我就不多重复了，从代码量和运行时间来说，我觉得套圈法是更优的，然后直接来上题。
中文题，意思就是给定了连通并且保证能有解的无向图，要按字典序最小输出无向图的欧拉路径。
就先判断有没有奇度点，有的话以最小那个为起点，否则以1为起点，然后就是直接dfs了。cur的话是类似最大流里面的一个当前弧优化，不懂没关系。
1 #include<cstdio>
2 const int N=520;
3 int n,cnt,in[N],cur[N],ok[N][N],ans[N*10];
4 void dfs(int u){
5 for(int &i=cur[u];i<=500;i++){
6 if(ok[u][i]){
7 ok[u][i]--;
8 ok[i][u]--;
9 dfs(i);
10 }
11 }
12 ans[cnt++]=u;
13 }
14 int main(){
15 int u,v;
16 while(~scanf("%d",&n)){
17 for(int i=1;i<=500;i++){
18 in[i]=0;
19 cur[i]=1;
20 for(int j=1;j<=500;j++)
21 ok[i][j]=0;
22 }
23 for(int i=0;i<n;i++){
24 scanf("%d%d",&u,&v);
25 in[u]++;
26 in[v]++;
27 ok[u][v]++;
28 ok[v][u]++;
29 }
30 int beg=1;
31 for(int i=1;i<=500;i++) if(in[i]&1){
32 beg=i;
33 break;
34 }
35 cnt=0;
36 dfs(beg);
37 for(int i=cnt-1;i>=0;i--) printf("%d\n",ans[i]);
38 }
39 return 0;
40 }
模板模板
1 #include<cstdio>
2 const int N=520;
3 int n,cnt,sn,in[N],ok[N][N],sta[N*10],ans[N*10],cur[N];
4 void dfs(int u){
5 sta[++sn]=u;
6 for(int &i=cur[u];i<=500;i++){
7 if(ok[u][i]){
8 ok[u][i]--;
9 ok[i][u]--;
10 dfs(i);
11 break;
12 }
13 }
14 }
15 void fleury(int beg){
16 sn=cnt=0;
17 sta[++sn]=beg;
18 int u,flag;
19 while(sn){
20 flag=0;
21 u=sta[sn];
22 for(int &i=cur[u];i<=500;i++){
23 if(ok[u][i]){
24 flag=1;
25 break;
26 }
27 }
28 if(!flag) ans[cnt++]=sta[sn--];
29 else dfs(sta[sn--]);
30 }
31 return ;
32 }
33 int main(){
34 int u,v;
35 while(~scanf("%d",&n)){
36 for(int i=1;i<=500;i++){
37 in[i]=0;
38 for(int j=1;j<=500;j++)
39 ok[i][j]=0;
40 }
41 for(int i=0;i<n;i++){
42 scanf("%d%d",&u,&v);
43 in[u]++;
44 in[v]++;
45 ok[u][v]++;
46 ok[v][u]++;
47 }
48 int beg=1;
49 for(int i=1;i<=500;i++) if(in[i]&1){
50 beg=i;
51 break;
52 }
53 fleury(beg);
54 for(int i=cnt-1;i>=0;i--) printf("%d\n",ans[i]);
55 }
56 return 0;
57 }
fleury模板
HZNUOJ Little Sub and Traveling
题意: 一个数x，下一步可以走到，x*2%n或者(x*2+1)%n，给你一个n，要你找一条从0开始，然后0~n-1的数走且只走过一次最终回到0的字典序最大的路径。
看似是每个点只走过一次，是找一个哈密顿回路，其实要找的还是一个欧拉回路。
首先n是奇数，没有答案输出-1，这个暴力打表也可以看出来，那为什么呢，因为可以到0的点只有n/2这个数，这个数还有n是奇数的话，n-1这个数也是只能由n/2这个数走到，那n/2不可能走到其中一个之后又回到它走到另外一个，所以无解。
然后n是偶数的话，我们看x(<=n/2)可以走到，x*2%n以及(x*2+1)%n，而x+n/2可以走到 (x*2+n)%n (x*2+n+1)%n，也就是x跟x+n/2的下一步是一样的话，如果我们把它们两个看成一个整体的话，也就是剩下n/2个点，然后每个点两个入度，两个出度，也就是求一个欧拉回路了。
比如n等于8的时候就像下图这样，所以直接套圈走起。
1 #include<cstdio>
2 int n,cnt,vis[10118],ans[10118];
3 void dfs(int x){
4 int x1=(x*2+1)%n,x2=x*2%n;
5 if(!vis[x1]){
6 vis[x1]=1;
7 dfs(x1);
8 }
9 if(!vis[x2]){
10 vis[x2]=1;
11 dfs(x2);
12 }
13 ans[cnt++]=x;
14 return ;
15 }
16 int main(){
17 while(~scanf("%d",&n)){
18 if(n&1) printf("-1\n");
19 else{
20 for(int i=0;i<n;i++) vis[i]=0;
21 cnt=0;
22 dfs(0);
23 for(int i=cnt-1;i>=0;i--) printf("%d%c",ans[i]," \n"[i==0]);
24 }
25 }
26 return 0;
27 }
投入欧拉的怀抱
中文题，无敌大整合，给你无向或者有向边，问有没有欧拉回路，没有就NO,有的话就YES然后输出任意答案。
判断连通，然后用定理判断，最后套圈法，就这样一气呵成，注意的是这里要输出的是边的编号，所以记录的是边不是点，还有就是这题不用当前弧优化会超时，不知道是什么的，可以去了解一下。
1 #include<cstdio>
2 const int N=101108,M=201108;
3 struct Side{
4 int v,ne,ok,id;
5 }S[M<<1];
6 int t,n,m,sn,cnt,head[N],cur[N],in[N],out[N],fa[N],ans[M<<1];
7 void init(){
8 sn=0;
9 for(int i=1;i<=n;i++){
10 fa[i]=i;
11 head[i]=-1;
12 in[i]=out[i]=0;
13 }
14 }
15 void add(int u,int v,int id){
16 S[sn].ok=1;
17 S[sn].id=id;
18 S[sn].v=v;
19 S[sn].ne=head[u];
20 head[u]=sn++;
21 }
22 int find(int x){
23 return fa[x]==x ? x : fa[x]=find(fa[x]);
24 }
25 void bing(int x,int y){
26 int fx=find(x),fy=find(y);
27 if(fx!=fy) fa[fx]=fy;
28 return ;
29 }
30 void dfs(int u){
31 for(int &i=cur[u];~i;i=S[i].ne){
32 if(S[i].ok){
33 S[i].ok=0;
34 int temp=i;
35 if(t==1) S[i^1].ok=0;
36 dfs(S[i].v);
37 ans[cnt++]=S[temp].id;
38 if(i==-1) break;
39 }
40 }
41 }
42 int main(){
43 int u,v;
44 while(~scanf("%d",&t)){
45 scanf("%d%d",&n,&m);
46 init();
47 for(int i=1;i<=m;i++){
48 scanf("%d%d",&u,&v);
49 bing(u,v);
50 if(t==1){
51 in[u]++;
52 in[v]++;
53 add(u,v,i);
54 add(v,u,-i);
55 }else{
56 in[v]++;
57 out[u]++;
58 add(u,v,i);
59 }
60 }
61 int beg=1,flag=1,num=0;
62 for(int i=1;i<=n;i++){
63 cur[i]=head[i];
64 if(fa[i]==i&&in[i]) num++;
65 if(t==1){
66 if(in[i]&1) flag=0;
67 else if(in[i]) beg=i;
68 }else{
69 if(in[i]!=out[i]) flag=0;
70 else if(in[i]) beg=i;
71 }
72 if(!flag||num>1) break;
73 }
74 if(flag&&num<=1){
75 printf("YES\n");
76 if(num){
77 cnt=0;
78 dfs(beg);
79 for(int i=cnt-1;i>=0;i--) printf("%d%c",ans[i]," \n"[i==0]);
80 }
81 }else printf("NO\n");
82 }
83 return 0;
84 }
学会这题就完全OK了
那如果是一个混合图的话，我们怎么办呢？
这涉及到最大流，不会最大流的可以去学一下。
具体步骤的话，直接引用Adela的混合图中欧拉回路，我就不重复了，直接说为什么。
想法其实就是，因为有向边的方向已经固定了，这没法更改，我们这样就是看能不能给无向边定一个方向，然后把整个图成为有向图，然后就是有向图的判定了。
而这个给定方向就是就是通过最大流的调整了，有向边就是统计入度出度，对于每条a与b之间无向边，我们先假定一个a->b的方向，然后统计出度入度，以及建一条流量为1从a到b的边，说明a到b之间有一条可以反向的无向边。
如果存在出度与入度奇偶性不同的点的话，肯定就不存在欧拉回路了，因为改变一条无向边的方向，对于两边的点来说，也就是出度-1，入度+1,或者出度+1,入度-1，奇偶性变化是一样的，如果一开始奇偶性就不同的话，肯定没法使得出度等于入度。
然后对于每个出度大于入度的点，我们把它与源点连一条流量为（出度-入度）/2的边,（出度-入度）/2其实就是需要改变多少条连到它上面的无向边，使得它出度等于入度。而对于入度大于出度的点，则是与汇点连一条流量为（入度-出度）/2的边。
所以最终能不能有欧拉回路，也就是看能不能满流，让每个点都满足出度等于入度的要求。
而欧拉路径的话，就是最多只能有两个出度与入度奇偶性不同的点，也就是终点和起点，然后我们找到这两个点，给它们连一条无向边，那处理就跟欧拉回路的一样了。
至于路径的输出，我们就看之前流量为1的那些边，如果流量变为0了，说明反向了，否则就是我们原定的方向，就用这些新的有向边和原来的有向边，然后有向图的欧拉回路就ok了。
直接挂三道题，题意就不说了，练一下英语吧~~~~~~~~
1 #include<cstdio>
2 #include<cstring>
3 #include<queue>
4 #include<algorithm>
5 using namespace std;
6 const int N=36,M=2118,inf=1e9+7;
7 struct Node{
8 int v,ne,w;
9 }S[M<<1];
10 char s[N];
11 int sn,sb,se,head[N],cur[N],dep[N];
12 int n,in[N],out[N],fa[N];
13 void init(){
14 sn=0;
15 sb=26,se=27;
16 for(int i=0;i<=se;i++){
17 fa[i]=i;
18 head[i]=-1;
19 in[i]=out[i]=0;
20 }
21 }
22 int find(int x){
23 return fa[x]==x ? x : fa[x]=find(fa[x]);
24 }
25 void bing(int x,int y){
26 int fx=find(x),fy=find(y);
27 if(fx!=fy) fa[fx]=fy;
28 return ;
29 }
30 void add(int u,int v,int w){
31 S[sn].w=w;
32 S[sn].v=v;
33 S[sn].ne=head[u];
34 head[u]=sn++;
35 }
36 void addE(int u,int v,int w){
37 add(u,v,w);
38 add(v,u,0);
39 }
40 bool bfs(){
41 for(int i=0;i<=se;i++) dep[i]=0;
42 dep[sb]=1;
43 queue<int> q;
44 q.push(sb);
45 int u,v;
46 while(!q.empty()){
47 u=q.front();
48 q.pop();
49 for(int i=head[u];~i;i=S[i].ne){
50 v=S[i].v;
51 if(S[i].w>0&&!dep[v]){
52 dep[v]=dep[u]+1;
53 if(v==se) return true;
54 q.push(v);
55 }
56 }
57 }
58 return false;
59 }
60 int dfs(int u,int minf){
61 if(u==se||!minf) return minf;
62 int v,flow;
63 for(int &i=cur[u];~i;i=S[i].ne){
64 v=S[i].v;
65 if(S[i].w>0&&dep[v]==dep[u]+1){
66 flow=dfs(v,min(minf,S[i].w));
67 if(flow){
68 S[i].w-=flow;
69 S[i^1].w+=flow;
70 return flow;
71 }
72 }
73 }
74 return 0;
75 }
76 int dinic(){
77 int maxf=0,flow;
78 while(bfs()){
79 for(int i=0;i<=se;i++) cur[i]=head[i];
80 while(flow=dfs(sb,inf)) maxf+=flow;
81 }
82 return maxf;
83 }
84 int main(){
85 int t=1,T,u,v,op,lens;
86 scanf("%d",&T);
87 while(t<=T){
88 init();
89 scanf("%d",&n);
90 for(int i=0;i<n;i++){
91 scanf("%s%d",s,&op);
92 lens=strlen(s);
93 u=s[0]-‘a‘;
94 v=s[lens-1]-‘a‘;
95 in[v]++;
96 out[u]++;
97 bing(u,v);
98 if(op) addE(u,v,1);
99 }
100 int num1=0,num2=0,x1=-1,x2=-1;
101 for(int i=0;i<26;i++){
102 if(fa[i]==i&&(in[i]||out[i])) num1++;
103 if((in[i]-out[i])&1){
104 num2++;
105 if(x1==-1) x1=i;
106 else x2=i;
107 }
108 if(num1>1||num2>2) break;
109 }
110 printf("Case %d: ",t++);
111 if(num1!=1||num2>2||num2==1){
112 printf("Poor boy!\n");
113 continue;
114 }
115 if(num2==2){
116 in[x1]++;
117 out[x2]++;
118 addE(x2,x1,1);
119 }
120 int sum1=0,sum2=0;
121 for(int i=0;i<26;i++){
122 if(in[i]==out[i]) continue;
123 if(in[i]>out[i]){
124 sum1+=(in[i]-out[i])/2;
125 addE(i,se,(in[i]-out[i])/2);
126 }
127 else{
128 sum2+=(out[i]-in[i])/2;
129 addE(sb,i,(out[i]-in[i])/2);
130 }
131 }
132 // printf("%d %d %d\n",sum1,sum2,dinic());
133 if(sum1!=sum2||dinic()!=sum1) printf("Poor boy!\n");
134 else printf("Well done!\n");
135 }
136 return 0;
137 }
hdu
1 #include<cstdio>
2 #include<algorithm>
3 using namespace std;
4 const int N=218,M=2108,inf=1e9+7;
5 struct Node{
6 int v,ne,w;
7 }S[M<<1];
8 int sn,sb,se,head[N],cur[N],dep[N];
9 int n,m,in[N],out[N],q[201108];
10 void init(){
11 sn=0;
12 sb=0,se=n+1;
13 for(int i=sb;i<=se;i++){
14 head[i]=-1;
15 in[i]=out[i]=0;
16 }
17 }
18 void add(int u,int v,int w){
19 S[sn].w=w;
20 S[sn].v=v;
21 S[sn].ne=head[u];
22 head[u]=sn++;
23 }
24 void addE(int u,int v,int w){
25 add(u,v,w);
26 add(v,u,0);
27 }
28 bool bfs(){
29 for(int i=sb;i<=se;i++) dep[i]=0;
30 dep[sb]=1;
31 int u,v,qn=0;
32 q[++qn]=sb;
33 while(qn>0){
34 u=q[qn];
35 qn--;
36 for(int i=head[u];~i;i=S[i].ne){
37 v=S[i].v;
38 if(S[i].w>0&&!dep[v]){
39 dep[v]=dep[u]+1;
40 if(v==se) return true;
41 q[++qn]=v;
42 }
43 }
44 }
45 return false;
46 }
47 int dfs(int u,int minf){
48 if(u==se||!minf) return minf;
49 int v,flow;
50 for(int &i=cur[u];~i;i=S[i].ne){
51 v=S[i].v;
52 if(S[i].w>0&&dep[v]==dep[u]+1){
53 flow=dfs(v,min(minf,S[i].w));
54 if(flow){
55 S[i].w-=flow;
56 S[i^1].w+=flow;
57 return flow;
58 }
59 }
60 }
61 return 0;
62 }
63 int dinic(){
64 int maxf=0,flow;
65 while(bfs()){
66 for(int i=sb;i<=se;i++) cur[i]=head[i];
67 while(flow=dfs(sb,inf)) maxf+=flow;
68 }
69 return maxf;
70 }
71 int main(){
72 int t,u,v,d;
73 scanf("%d",&t);
74 while(t--){
75 scanf("%d%d",&n,&m);
76 init();
77 for(int i=0;i<m;i++){
78 scanf("%d%d%d",&u,&v,&d);
79 in[v]++,out[u]++;
80 if(!d) addE(u,v,1);
81 }
82 int flag=1,sum1=0,sum2=0;
83 for(int i=1;i<=n;i++){
84 if(in[i]==out[i]) continue;
85 if((in[i]-out[i])&1){
86 flag=0;
87 break;
88 }
89 else if(out[i]>in[i]){
90 sum1+=(out[i]-in[i])/2;
91 addE(sb,i,(out[i]-in[i])/2);
92 }
93 else{
94 sum2+=(in[i]-out[i])/2;
95 addE(i,se,(in[i]-out[i])/2);
96 }
97 }
98 if(!flag||sum1!=sum2||dinic()!=sum1) printf("impossible\n");
99 else printf("possible\n");
100 }
101 return 0;
102 }
poj
1 #include<cstdio>
2 #include<queue>
3 #include<algorithm>
4 using namespace std;
5 const int N=118,M=1108,inf=1e9+7;
6 struct Node{
7 int v,ne,w;
8 }S[M<<1],U[M<<1];
9 char s[5];
10 int sn,sb,se,head[N],cur[N],dep[N];
11 int n,m,in[N],out[N],ok[N][N];
12 int un,headu[N],cnt,ans[M<<1];
13 void init(){
14 sn=un=0;
15 sb=0,se=n+1;
16 for(int i=sb;i<=se;i++){
17 head[i]=headu[i]=-1;
18 in[i]=out[i]=0;
19 for(int j=sb;j<=se;j++) ok[i][j]=0;
20 }
21 }
22 void add(int u,int v,int w){
23 S[sn].w=w;
24 S[sn].v=v;
25 S[sn].ne=head[u];
26 head[u]=sn++;
27 }
28 void addE(int u,int v,int w){
29 add(u,v,w);
30 add(v,u,0);
31 }
32 void addu(int u,int v,int w){
33 U[un].w=w;
34 U[un].v=v;
35 U[un].ne=headu[u];
36 headu[u]=un++;
37 }
38 bool bfs(){
39 for(int i=sb;i<=se;i++) dep[i]=0;
40 dep[sb]=1;
41 queue<int> q;
42 q.push(sb);
43 int u,v;
44 while(!q.empty()){
45 u=q.front();
46 q.pop();
47 for(int i=head[u];~i;i=S[i].ne){
48 v=S[i].v;
49 if(S[i].w>0&&!dep[v]){
50 dep[v]=dep[u]+1;
51 if(v==se) return true;
52 q.push(v);
53 }
54 }
55 }
56 return false;
57 }
58 int dfs(int u,int minf){
59 if(u==se||!minf) return minf;
60 int v,flow;
61 for(int &i=cur[u];~i;i=S[i].ne){
62 v=S[i].v;
63 if(S[i].w>0&&dep[v]==dep[u]+1){
64 flow=dfs(v,min(minf,S[i].w));
65 if(flow){
66 S[i].w-=flow;
67 S[i^1].w+=flow;
68 return flow;
69 }
70 }
71 }
72 return 0;
73 }
74 int dinic(){
75 int maxf=0,flow;
76 while(bfs()){
77 for(int i=sb;i<=se;i++) cur[i]=head[i];
78 while(flow=dfs(sb,inf)) maxf+=flow;
79 }
80 return maxf;
81 }
82 void dfs2(int u){
83 for(int &i=cur[u];i<=n;i++)
84 if(ok[u][i]){
85 ok[u][i]--;
86 dfs2(i);
87 }
88 ans[cnt++]=u;
89 }
90 int main(){
91 int t,u,v,d;
92 scanf("%d",&t);
93 while(t--){
94 scanf("%d%d",&n,&m);
95 init();
96 for(int i=0;i<m;i++){
97 scanf("%d%d%s",&u,&v,s);
98 in[v]++,out[u]++;
99 if(s[0]==‘U‘){
100 addu(u,v,sn);
101 addE(u,v,1);
102 }
103 else ok[u][v]++;
104 }
105 int flag=1,sum1=0,sum2=0;
106 for(int i=1;i<=n;i++){
107 if(in[i]==out[i]) continue;
108 if((in[i]-out[i])&1){
109 flag=0;
110 break;
111 }
112 else if(out[i]>in[i]){
113 sum1+=(out[i]-in[i])/2;
114 addE(sb,i,(out[i]-in[i])/2);
115 }
116 else{
117 sum2+=(in[i]-out[i])/2;
118 addE(i,se,(in[i]-out[i])/2);
119 }
120 }
121 if(!flag||sum1!=sum2||dinic()!=sum1) printf("No euler circuit exist\n");
122 else{
123 for(int i=1;i<=n;i++){
124 cur[i]=1;
125 for(int j=headu[i];~j;j=U[j].ne){
126 if(S[U[j].w].w>0) ok[i][U[j].v]++;
127 else ok[U[j].v][i]++;
128 }
129 }
130 cnt=0;
131 dfs2(1);
132 for(int i=cnt-1;i>=0;i--) printf("%d%c",ans[i]," \n"[i==0]);
133 }
134 printf("\n");
135 }
136 return 0;
137 }
uva
原文地址：https://www.cnblogs.com/LMCC1108/p/11306297.html