欧拉回路与欧拉路径
定义：
欧拉回路：每条边恰好只走一次，并能回到出发点的路径
欧拉路径：经过每一条边一次，但是不要求回到起始点
①首先看欧拉回路存在性的判定：
一、无向图
每个顶点的度数都是偶数，则存在欧拉回路。
二、有向图（所有边都是单向的）
每个节顶点的入度都等于出度，则存在欧拉回路。
三.混合图欧拉回路
混合图欧拉回路用的是网络流。
把该图的无向边随便定向，计算每个点的入度和出度。如果有某个点出入度之差为奇数，那么肯定不存在欧拉回路。因为欧拉回路要求每点入度 = 出度，也就是总度数为偶数，存在奇数度点必不能有欧拉回路。
好了，现在每个点入度和出度之差均为偶数。那么将这个偶数除以2，得x。也就是说，对于每一个点，只要将x条边改变方向（入>出就是变入，出>入就是变出），就能保证出 = 入。如果每个点都是出 = 入，那么很明显，该图就存在欧拉回路。
现在的问题就变成了：我该改变哪些边，可以让每个点出 = 入？构造网络流模型。首先，有向边是不能改变方向的，要之无用，删。一开始不是把无向边定向了吗？定的是什么向，就把网络构建成什么样，边长容量上限1。另新建s和t。对于入 > 出的点u，连接边(u, t)、容量为x，对于出 > 入的点v，连接边(s, v)，容量为x（注意对不同的点x不同）。之后，察看是否有满流的分配。有就是能有欧拉回路，没有就是没有。欧拉回路是哪个？查看流值分配，将所有流量非 0（上限是1，流值不是0就是1）的边反向，就能得到每点入度 = 出度的欧拉图。
由于是满流，所以每个入 > 出的点，都有x条边进来，将这些进来的边反向，OK，入 = 出了。对于出 > 入的点亦然。那么，没和s、t连接的点怎么办？和s连接的条件是出 > 入，和t连接的条件是入 > 出，那么这个既没和s也没和t连接的点，自然早在开始就已经满足入 = 出了。那么在网络流过程中，这些点属于“中间点”。我们知道中间点流量不允许有累积的，这样，进去多少就出来多少，反向之后，自然仍保持平衡。
所以，就这样，混合图欧拉回路问题，解了。
②.欧拉路径存在性的判定
一。无向图
一个无向图存在欧拉路径，当且仅当 该图所有顶点的度数为偶数 或者 除了两个度数为奇数外其余的全是偶数。
二。有向图
一个有向图存在欧拉路径，当且仅当 该图所有顶点的度数为零 或者 一个顶点的度数为1，另一个度数为-1，其他顶点的度数为0。
三。混合图欧拉路径
其实整篇文章只有这部分是我写的哈，灰常不好意思，只是网上的同志们写的太好了，实在没有必要重复劳动，不知道大家有没有发现，求欧拉路径的第一步一定是求欧拉回路，在混合图上也不例外，如何判断混合图欧拉回路问题的存在性呢？首先，我们用上文所说的方法判断该图是否存在欧拉回路，如果存在，欧拉路径一定存在。如果欧拉回路不存在，那么我们枚举欧拉路径的起点和终点，连接一条无向边，然后再用最大流判断是否存在欧拉回路即可。
模板代码
欧拉回路
给定一张图，请你找出欧拉回路，即在图中找一个环使得每条边都在环上出现恰好一次。
输入格式
第一行包含一个整数 t，t∈{1,2}，如果 t=1，表示所给图为无向图，如果 t=2，表示所给图为有向图。
第二行包含两个整数 n,m，表示图的结点数和边数。
接下来 m 行中，第 i 行两个整数 vi,ui，表示第 i 条边（从 1 开始编号）。
如果 t=1 则表示 vi 到 ui 有一条无向边。
如果 t=2 则表示 vi 到 ui 有一条有向边。
图中可能有重边也可能有自环。
点的编号从 1 到 n。
输出格式
如果无法一笔画出欧拉回路，则输出一行：NO。
否则，输出一行：YES，接下来一行输出 任意一组 合法方案即可。
如果 t=1，输出 m 个整数 p1,p2,…,pm。令 e=|pi|，那么 e 表示经过的第 i 条边的编号。如果 pi 为正数表示从 ve 走到 ue，否则表示从 ue 走到 ve。
如果 t=2，输出 m 个整数 p1,p2,…,pm。其中 pi 表示经过的第 i 条边的编号。
数据范围
1≤n≤105,
0≤m≤2×105
输入样例1：
1
3 3
1 2
2 3
1 3
输出样例1：
YES
1 2 -3
输入样例2：
2
5 6
2 3
2 5
3 4
1 2
4 2
5 1
输出样例2：
YES
4 1 3 5 2 6
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 400010;
int type;
int n, m;
int h[N], e[M], ne[M], idx;
bool used[M];
int ans[M], cnt;
int din[N], dout[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u)
{
for (int &i = h[u]; ~i;)
{
if (used[i])
{
i = ne[i];
continue;
}
used[i] = true;
if (type == 1) used[i ^ 1] = true;
int t;
if (type == 1)
{
t = i / 2 + 1;
if (i & 1) t = -t;
}
else t = i + 1;
int j = e[i];
i = ne[i];
dfs(j);
ans[ ++ cnt] = t;
}
}
int main()
{
scanf("%d", &type);
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
if (type == 1) add(b, a);
din[b] ++ , dout[a] ++ ;
}
if (type == 1)
{
for (int i = 1; i <= n; i ++ )
if (din[i] + dout[i] & 1)
{
puts("NO");
return 0;
}
}
else
{
for (int i = 1; i <= n; i ++ )
if (din[i] != dout[i])
{
puts("NO");
return 0;
}
}
for (int i = 1; i <= n; i ++ )
if (h[i] != -1)
{
dfs(i);
break;
}
if (cnt < m)
{
puts("NO");
return 0;
}
puts("YES");
for (int i = cnt; i; i -- ) printf("%d ", ans[i]);
puts("");
return 0;
}
欧拉路径
题目描述
求有向图字典序最小的欧拉路径。
输入格式
第一行两个整数 n,m 表示有向图的点数和边数。
接下来 m 行每行两个整数 u,v 表示存在一条 u →v 的有向边。
输出格式
如果不存在欧拉路径，输出一行 No。
否则输出一行 m+1 个数字，表示字典序最小的欧拉路径。
#include <bits/stdc++.h>
using namespace std;
const int MAX=100010;
int n,m,u,v,del[MAX];
int du[MAX][2];//记录入度和出度
stack <int> st;
vector <int> G[MAX];
void dfs(int now)
{
for(int i=del[now];i<G[now].size();i=del[now])
{
del[now]=i+1;
dfs(G[now][i]);
}
st.push(now);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++) scanf("%d%d",&u,&v),G[u].push_back(v),du[u][1]++,du[v][0]++;
for(int i=1;i<=n;i++) sort(G[i].begin(),G[i].end());
int S=1,cnt[2]={0,0}; //记录
bool flag=1; //flag=1表示,所有的节点的入度都等于出度,
for(int i=1;i<=n;i++)
{
if(du[i][1]!=du[i][0]) flag=0;
if(du[i][1]-du[i][0]==1/*出度比入度多1*/) cnt[1]++,S=i;
if(du[i][0]-du[i][1]==1/*入度比出度多1*/) cnt[0]++;
}
if((!flag)&&!(cnt[0]==cnt[1]&&cnt[0]==1)) return !printf("No");
//不满足欧拉回路的判定条件，也不满足欧拉路径的判定条件，直接输出"No"
dfs(S);
while(!st.empty()) printf("%d ",st.top()),st.pop();
return 0;
}
刷刷题目！
随着白天越来越短夜晚越来越长，我们不得不考虑铲雪问题了。
整个城市所有的道路都是双向车道,道路的两个方向均需要铲雪。因为城市预算的削减，整个城市只有 1 辆铲雪车。
铲雪车只能把它开过的地方（车道）的雪铲干净，无论哪儿有雪，铲雪车都得从停放的地方出发，游历整个城市的街道。
现在的问题是：最少要花多少时间去铲掉所有道路上的雪呢？
输入格式
输入数据的第 1 行表示铲雪车的停放坐标 (x,y)，x,y 为整数，单位为米。
下面最多有4000行，每行给出了一条街道的起点坐标和终点坐标，坐标均为整数，所有街道都是笔直的，且都是双向车道。
铲雪车可以在任意交叉口、或任何街道的末尾任意转向，包括转 U 型弯。
铲雪车铲雪时前进速度为 20 千米/时，不铲雪时前进速度为 50 千米/时。
保证：铲雪车从起点一定可以到达任何街道。
输出格式
输出铲掉所有街道上的雪并且返回出发点的最短时间，精确到分钟，四舍五入到整数。
输出格式为”hours:minutes”，minutes不足两位数时需要补前导零。
具体格式参照样例。
数据范围
−106≤x,y≤106
所有位置坐标绝对值不超过 106。
输入样例：
0 0
0 0 10000 10000
5000 -10000 5000 10000
5000 10000 10000 10000
输出样例：
3:55
样例解释
输出结果表示共需3小时55分钟。
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
double x1, y1, x2, y2;
cin >> x1 >> y1;
double sum = 0;
while (cin >> x1 >> y1 >> x2 >> y2)
{
double dx = x1 - x2;
double dy = y1 - y2;
sum += sqrt(dx * dx + dy * dy) * 2;
}
int minutes = round(sum / 1000 / 20 * 60);
int hours = minutes / 60;
minutes %= 60;
printf("%d:%02d\n", hours, minutes);
return 0;
}
农民John每年有很多栅栏要修理。
他总是骑着马穿过每一个栅栏并修复它破损的地方。
John是一个与其他农民一样懒的人。
他讨厌骑马，因此从来不两次经过一个栅栏。
你必须编一个程序，读入栅栏网络的描述，并计算出一条修栅栏的路径，使每个栅栏都恰好被经过一次。
John能从任何一个顶点(即两个栅栏的交点)开始骑马，在任意一个顶点结束。
每一个栅栏连接两个顶点，顶点用 1 到 500 标号(虽然有的农场并没有 500 个顶点)。
一个顶点上可连接任意多( ≥1 )个栅栏。
所有栅栏都是连通的(也就是你可以从任意一个栅栏到达另外的所有栅栏)。
你的程序必须输出骑马的路径(用路上依次经过的顶点号码表示)。
我们如果把输出的路径看成是一个500进制的数，那么当存在多组解的情况下，输出500进制表示法中最小的一个 (也就是输出第一个数较小的，如果还有多组解，输出第二个数较小的，等等)。
输入数据保证至少有一个解。
输入格式
第 1 行:一个整数 F，表示栅栏的数目;
第 2 到 F+1 行:每行两个整数 i,j 表示这条栅栏连接 i 与 j 号顶点。
输出格式
输出应当有 F+1 行，每行一个整数，依次表示路径经过的顶点号。
注意数据可能有多组解，但是只有上面题目要求的那一组解是认为正确的。
数据范围
1≤F≤1024,
1≤i,j≤500
输入样例：
9
1 2
2 3
3 4
4 2
4 5
2 5
5 6
5 7
4 6
输出样例：
1
2
3
4
2
5
4
6
5
7
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510;
int n = 500, m;
int g[N][N];
int ans[1100], cnt;
int d[N];
void dfs(int u)
{
for (int i = 1; i <= n; i ++ )
if (g[u][i])
{
g[u][i] --, g[i][u] -- ;
dfs(i);
}
ans[ ++ cnt] = u;
}
int main()
{
cin >> m;
while (m -- )
{
int a, b;
cin >> a >> b;
g[a][b] ++, g[b][a] ++ ;
d[a] ++, d[b] ++ ;
}
int start = 1;
while (!d[start]) start ++ ;
for (int i = 1; i <= n; i ++ )
if (d[i] % 2)
{
start = i;
break;
}
dfs(start);
for (int i = cnt; i; i -- ) printf("%d\n", ans[i]);
return 0;
}
有 N 个盘子，每个盘子上写着一个仅由小写字母组成的英文单词。
你需要给这些盘子安排一个合适的顺序，使得相邻两个盘子中，前一个盘子上单词的末字母等于后一个盘子上单词的首字母。
请你编写一个程序，判断是否能达到这一要求。
输入格式
第一行包含整数 T，表示共有 T 组测试数据。
每组数据第一行包含整数 N，表示盘子数量。
接下来 N 行，每行包含一个小写字母字符串，表示一个盘子上的单词。
一个单词可能出现多次。
输出格式
如果存在合法解，则输出”Ordering is possible.”，否则输出”The door cannot be opened.”。
数据范围
1≤N≤105,
单词长度均不超过1000
输入样例：
3
2
acm
ibm
3
acm
malform
mouse
2
ok
ok
输出样例：
The door cannot be opened.
Ordering is possible.
The door cannot be opened.
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 30;
int n;
int din[N], dout[N], p[N];
bool st[N];
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int main()
{
char str[1010];
int T;
scanf("%d", &T);
while (T -- )
{
scanf("%d", &n);
memset(din, 0, sizeof din);
memset(dout, 0, sizeof dout);
memset(st, 0, sizeof st);
for (int i = 0; i < 26; i ++ ) p[i] = i;
for (int i = 0; i < n; i ++ )
{
scanf("%s", str);
int len = strlen(str);
int a = str[0] - 'a', b = str[len - 1] - 'a';
st[a] = st[b] = true;
dout[a] ++, din[b] ++ ;
p[find(a)] = find(b);
}
int start = 0, end = 0;
bool success = true;
for (int i = 0; i < 26; i ++ )
if (din[i] != dout[i])
{
if (din[i] == dout[i] + 1) end ++ ;
else if (din[i] + 1 == dout[i]) start ++ ;
else
{
success = false;
break;
}
}
if (success && !(!start && !end || start == 1 && end == 1)) success = false;
int rep = -1;
for (int i = 0; i < 26; i ++ )
if (st[i])
{
if (rep == -1) rep = find(i);
else if (rep != find(i))
{
success = false;
break;
}
}
if (success) puts("Ordering is possible.");
else puts("The door cannot be opened.");
}
return 0;
}
