欧拉回路：图G，若存在一条路，经过G中每条边有且仅有一次，称这条路为欧拉路，如果存在一条回路经过G每条边有且仅有一次，
称这条回路为欧拉回路。具有欧拉回路的图成为欧拉图。
判断欧拉路是否存在的方法
有向图：图连通，有一个顶点出度大入度1，有一个顶点入度大出度1，其余都是出度=入度。
无向图：图连通，只有两个顶点是奇数度，其余都是偶数度的。
判断欧拉回路是否存在的方法
有向图：图连通，所有的顶点出度=入度。
无向图：图连通，所有顶点都是偶数度。
程序实现一般是如下过程：
1.利用并查集判断图是否连通，即判断p[i] < 0的个数，如果大于1，说明不连通。
2.根据出度入度个数，判断是否满足要求。
3.利用dfs输出路径。
比较好的题目是poj2337，判断单词是否连成一排的。
hdu3018
给出N个节点，M个边，问要遍历一遍所有的边，需要的最小group数目。
求一个图中最少几笔画，利用欧拉回路性质，首先得到图的每个强连通分支，然后计算每个强连通分支每个是否都是偶数度是的话，一笔解决，否的话，需要奇数度节点个数的1/2笔解决。（当一个节点度数为奇数时，我们只需要令它的度数为1，因为偶数的话直接抵消了，最后判断一个scc中未1的节点个数，除以2就得到该scc的最小笔画了）
代码：
View Code
#include <iostream> #include <stdio.h> using namespace std; const int maxv = 100000 + 2; int odds[maxv]; /* 顶点 */ int du[maxv]; /* 每个顶点的度数 */ int p[maxv]; /* 并查集数组 */ bool used[maxv]; int scc[maxv]; /* scc个数 */ void init(int n) { for(int i = 0; i <= n; ++i) { odds[i] = 0; p[i] = -1; du[i] = 0; used[i] = 0; } } int utf_find(int x) { if(0 <= p[x]) { p[x] = utf_find(p[x]); return p[x]; } return x; } void utf_union(int a, int b) { int r1 = utf_find(a); int r2 = utf_find(b); if(r1 == r2) return; int n1 = p[r1]; int n2 = p[r2]; if(n1 < n2) { p[r2] = r1; p[r1] += n2; } else { p[r1] = r2; p[r2] += n1; } } int main() { int n = 0; int m = 0; int a = 0; int b = 0; int i = 0; int cnt = 0; while(scanf("%d%d", &n, &m) != EOF) { init(n); cnt = 0; for(i = 1; i <= m; ++i) { scanf("%d%d", &a, &b); du[a]++; du[b]++; utf_union(a, b); } for(i = 1; i <= n; ++i) { int f = utf_find(i); if(!used[f]) { used[f] = 1; scc[cnt++] = f; } if(1 == du[i]%2) odds[f]++; } int ret = 0; for(i = 0; i < cnt; ++i) { if(0 == du[scc[i]]) continue; if(0 == odds[scc[i]]) ++ret; else ret += odds[scc[i]]/2; } printf("%d\n", ret); } return 0; }
poj1386
给出n个单词，如果一个单词的尾和另一个单词的头字符相等，那么可以相连，问这n个单词是否可以排成一列。欧拉路应用，构图：一个单词的头尾字母分别作为顶点，每输入一个word，该word的头指向word的尾画一个有向边，并且记录每个顶点的出入度。利用并查集先判断是否为scc，如果是的话则判断是否奇数度节点为0或者只有2个。
代码：
View Code
#include <iostream> #include <stdio.h> using namespace std; const int max_len = 1000 + 10; const int maxv = 27; int in[maxv]; /* 入度 */ int out[maxv]; /* 出度 */ int p[maxv];/* 并查集数组 */ bool used[maxv];/* 标识字符是否出现在图中 */ void init() { for(int i = 0; i < maxv; ++i) { in[i] = 0; out[i] = 0; p[i] = -1; used[i] = 0; } } int find_set(int x) { if(0 <= p[x]) { p[x] = find_set(p[x]); return p[x]; } return x; } void union_set(int a, int b) { int r1 = find_set(a); int r2 = find_set(b); if(r1 == r2) return; int n1 = p[r1]; int n2 = p[r2]; if(n1 < n2) { p[r2] = r1; p[r1] += n2; } else { p[r1] = r2; p[r2] += n1; } } int main() { int t = 0; int n = 0; int len = 0; int s = 0; int e = 0; int i = 0; char word[max_len]; scanf("%d", &t); while(t--) { init(); scanf("%d", &n); for(i = 0; i < n; ++i) { scanf("%s", word); len = strlen(word); s = word[0] - 'a'; e = word[len - 1] - 'a'; used[s] = 1; used[e] = 1; out[s]++; in[e]++; union_set(s, e); } //根据并查集判断图是否连通 int scc = 0; for(i = 0; i < maxv; ++i) { if(used[i] && 0 > p[i]) ++scc; } if(1 < scc) { printf("The door cannot be opened.\n"); continue; } //入度是否等于出度 int a = 0; int b = 0; for(i = 0; i < maxv; ++i) { if(used[i] && in[i] != out[i]) { if(1 == (in[i] - out[i])) ++a; else if(1 == (out[i] - in[i])) ++b; else break; } } if(i < maxv) printf("The door cannot be opened.\n"); else if(0 == (a + b) || (1 == a && 1 == b)) printf("Ordering is possible.\n"); else printf("The door cannot be opened.\n"); } return 0; }
poj2230
题目大意：给出n个field及m个连接field的边，然后要求遍历每条边仅且2次，求出一条路径来。
这个题目典型欧拉回路，由于题目保证了肯定存在，所以我们直接dfs就行，首先有个小技巧是如何判断该条路是否走过了，也就是我们得对有向边进行标记。利用之前的结构
struct edge{
int next;
int to;
};
edge node[maxm];
int adj[maxv] = {-1}
每一条边对应了一个next，我们只需要对next标记就可以了。
View Code
#include <iostream> #include <stdio.h> using namespace std; const int maxm = 2*50000 + 1; const int maxv = 10000 + 5; struct edge{ int to; int next; }; edge node[maxm]; /*邻接表*/ int adj[maxv]; bool used[maxm];/* 标记边是否访问过*/ void Euler(int vertix) { for(int i = adj[vertix]; i != -1; i = node[i].next) { if(!used[i]) { used[i] = 1; Euler(node[i].to); } } printf("%d\n", vertix); } int main() { int n = 0; int m = 0; int i = 0; int u = 0; int v = 0; int cnt = 0; scanf("%d%d", &n, &m); for(i = 0; i <= n; ++i) adj[i] = -1; for(i = 0; i <= m*2; ++i) used[i] = 0; for(i = 0; i < m; ++i) { scanf("%d%d", &u, &v); //u->v node[cnt].to = v; node[cnt].next = adj[u]; adj[u] = cnt++; //v->u node[cnt].to = u; node[cnt].next = adj[v]; adj[v] = cnt++; } Euler(1); return 0; }
poj2337
求欧拉路径和poj1386同一个题，只不过这个题目需要输出欧拉路径。
题目大意：给出一组单词，如果两个单词，一个单词的头和另一个单词的尾相同，则可以相连，例如abce, efdg,可以相连，问这组单词能否排成一排，如果可以求出字典序自小的那个。
构图：单词作为边，单词的头字母和尾字母分别作为顶点，读入一个单词，添加一条边，并且用邻接表来存边，首先利用并查集判断图是否连通，然后再判断是否可以构成欧拉通路或者回路，如果是回路，则从a开始找，找到第一个存在的字母，从这个字母遍历就行，如果是通路，则必须从出度大于入度1的那个顶点开始遍历。由于这个题目要求最小字典顺序，然后考虑我们建立邻接表的时候是采用头插法，那么我们如果将单词从小到大排序，由于我们遍历顶点肯定是从小的顶点开始的，这样遍历一个顶点的邻接边的时候就会从大到小访问这个顶点的边，无法满足字典最小，所以从大到小排序,遍历依node数组为准，每次遍历一条边设置该下标已访问过。
代码：
View Code
#include <iostream> #include <algorithm> using namespace std; const int maxn = 1000 + 10; const int max_l = 28; //char word[maxn][max_l]; char ret[maxn][max_l]; struct edge{ int to; int next; char str[max_l]; }; edge node[maxn]; int adj[max_l]; int in[max_l]; int out[max_l]; bool used[maxn]; bool exist[max_l]; int p[max_l]; /* 并查集 */ int num_e = 0; int ret_e = 0; //从大到小排序 bool cmp(edge p1, edge p2) { return strcmp(p1.str, p2.str) > 0; } void init() { for(int i = 0; i < max_l; ++i) { in[i] = 0; out[i] = 0; p[i] = -1; exist[i] = 0; adj[i] = -1; } for(int j = 0; j < maxn; ++j) used[j] = 0; num_e = 0; ret_e = 0; } int find_set(int u) { if(0 <= p[u]) { p[u] = find_set(p[u]); return p[u]; } return u; } void union_set(int u, int v) { int r1 = find_set(u); int r2 = find_set(v); if(r1 == r2) return; int n1 = p[r1]; int n2 = p[r2]; if(n1 < n2) { p[r2] = r1; p[r1] += n2; } else { p[r1] = r2; p[r2] += n1; } } void Eular(int vertix, int idx) { for(int i = adj[vertix]; i != -1; i = node[i].next) { if(!used[i]) { // strcpy(ret[ret_e++], node[i].str); used[i] = 1; Eular(node[i].to, i); } } /*idx就是node数组的下标，标识一条边*/ if(0 <= idx) strcpy(ret[ret_e++], node[idx].str); } int main() { int t = 0; int n = 0; int i = 0; int u = 0; int v = 0; int start = 0; //从哪个顶点开始遍历 scanf("%d", &t); while(t--) { scanf("%d", &n); if(!n) continue; for(i = 0; i < n; ++i) scanf("%s", node[i].str); init(); start = max_l; sort(node, node + n, cmp); //建图 for(i = 0; i < n; ++i) { u = node[i].str[0] - 'a'; v = node[i].str[strlen(node[i].str) - 1] - 'a'; in[v]++; out[u]++; exist[u] = 1; exist[v] = 1; union_set(u, v); node[num_e].to = v; node[num_e].next = adj[u]; adj[u] = num_e++; } //判断是否连通 int scc = 0; for(i = 0; i < max_l; ++i) { if(exist[i] && 0 > p[i]) ++scc; if(1 < scc) break; } if(1 < scc) //不连通 { printf("***\n"); continue; } //是通路or回路 int a = 0; int b = 0; start = -1; for(i = 0; i < max_l; ++i) { if(exist[i] && in[i] != out[i]) { if(1 == in[i] - out[i]) ++a; else if(1 == out[i] - in[i]) { ++b; start = i; } else break; } } if(i < max_l) { printf("***\n"); continue; } else { if(!((0 == a + b) || (1 == a && 1 == b))) { printf("***\n"); continue; } if(-1 == start) {//回路 找到第一个存在的字母 int k = 0; for(k = 0; k < max_l; ++k) { if(out[k]) break; } start = k; } //从顶点start开始dfs Eular(start, -1); printf("%s", ret[ret_e - 1]); for(i = ret_e - 2; i >= 0; --i) printf(".%s", ret[i]); printf("\n"); } } return 0; }