在图论中，欧拉道路和欧拉回路是两个重要的概念，它们分别描述了在图中找到一条经过所有边且每条边只经过一次的道路或回路的可能性。欧拉道路和欧拉回路在实际应用中有着广泛的用途，如路线规划、电路设计等。
欧拉道路：通过图中每条边恰好一次且仅一次的行进路线，若存在，则称为欧拉道路。欧拉道路不必是回路，也就是说，起点和终点可以不同。
欧拉回路：通过图中每条边恰好一次且仅一次的闭回路（或圈、环），若存在，则称为欧拉回路。欧拉回路是欧拉道路的一个特例，它要求起点和终点相同，形成闭环。
欧拉道路的判定条件：一个连通图存在欧拉道路，当且仅当该图中有且仅有两个奇度顶点（度数为奇数的顶点）。
欧拉回路的判定条件：一个连通图存在欧拉回路，当且仅当该图中所有顶点的度数均为偶数。
以下是一个简单的C++程序，用于判断一个给定的图是否存在欧拉道路或欧拉回路，并输出对应的路径（如果存在的话），代码如下。
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class Graph {
int V; // 顶点数
vector<int> *adj; // 邻接表
public:
Graph(int V); // 构造函数
void addEdge(int v, int w); // 添加边
bool hasEulerianPath(); // 是否存在欧拉道路
bool hasEulerianCycle(); // 是否存在欧拉回路
void printEulerianPath(); // 打印欧拉道路
void printEulerianCycle(); // 打印欧拉回路
};
Graph::Graph(int V) {
this->V = V;
adj = new vector<int>[V];
}
void Graph::addEdge(int v, int w) {
adj[v].push_back(w);
adj[w].push_back(v); // 无向图，添加双向边
}
bool Graph::hasEulerianPath() {
int oddDegreeCount = 0;
for (int i = 0; i < V; i++) {
int degree = adj[i].size();
if (degree % 2 != 0) {
oddDegreeCount++;
}
if (oddDegreeCount > 2) {
return false; // 超过两个奇度顶点，不存在欧拉道路
}
}
return oddDegreeCount == 0 || oddDegreeCount == 2; // 要么没有奇度顶点（存在欧拉回路），要么有两个奇度顶点（存在欧拉道路）
}
bool Graph::hasEulerianCycle() {
for (int i = 0; i < V; i++) {
if (adj[i].size() % 2 != 0) {
return false; // 存在奇度顶点，不存在欧拉回路
}
}
return true; // 所有顶点度数均为偶数，存在欧拉回路
}
void Graph::printEulerianPath() {
if (!hasEulerianPath()) {
cout << "图形没有欧拉路径." << endl;
return;
}
stack<int> stk;
bool *visited = new bool[V];
for (int i = 0; i < V; i++) {
visited[i] = false;
}
// 找到任意一个奇度顶点（如果存在的话）作为起点
for (int i = 0; i < V; i++) {
if (adj[i].size() % 2 != 0 && !visited[i]) {
stk.push(i);
visited[i] = true;
break;
}
}
// 如果所有顶点都是偶度顶点，则任意选择一个未访问的顶点作为起点
if (stk.empty()) {
for (int i = 0; i < V; i++) {
if (!visited[i]) {
stk.push(i);
visited[i] = true;
break;
}
}
}
// 深度优先搜索，打印欧拉道路
while (!stk.empty()) {
int current = stk.top();
stk.pop();
cout << current << " ";
for (int i = adj[current].size() - 1; i >= 0; i--) {
int next = adj[current][i];
cout<<"next "<<next<<endl;
if (!visited[next]) {
stk.push(next);
visited[next] = true;
adj[current].erase(adj[current].begin() + i); // 删除已访问的边
// adj[next].erase(remove(adj[next].begin(), adj[next].end(), current), adj[next].end()); // 从相邻顶点的邻接表中删除对应的反向边
}
}
}
delete[] visited;
cout << endl;
}
void Graph::printEulerianCycle() {
if (!hasEulerianCycle()) {
cout << "图没有欧拉循环." << endl;
return;
}
stack<int> stk;
bool *visited = new bool[V];
for (int i = 0; i < V; i++) {
visited[i] = false;
}
// 从任意顶点开始深度优先搜索
for (int i = 0; i < V; i++) {
if (!visited[i]) {
stk.push(i);
visited[i] = true;
break;
}
}
// 深度优先搜索，打印欧拉回路
while (!stk.empty()) {
int current = stk.top();
stk.pop();
cout << current << " ";
for (int i = adj[current].size() - 1; i >= 0; i--) {
int next = adj[current][i];
if (!visited[next]) {
stk.push(next);
visited[next] = true;
adj[current].erase(adj[current].begin() + i); // 删除已访问的边
//adj[next].erase(remove(adj[next].begin(), adj[next].end(), current), adj[next].end()); // 从相邻顶点的邻接表中删除对应的反向边
}
}
}
delete[] visited;
cout << endl;
}
int main() {
// 创建一个图并添加边
Graph g(4);
g.addEdge(0, 1);
g.addEdge(1, 2);
g.addEdge(2, 3);
g.addEdge(3, 0);
// 判断并打印欧拉道路或欧拉回路
if (g.hasEulerianPath()) {
cout << "该图具有欧拉路径:" << endl;
g.printEulerianPath();
} else if (g.hasEulerianCycle()) {
cout << "该图具有欧拉循环" << endl;
g.printEulerianCycle();
} else {
cout << "该图没有欧拉路径或循环." << endl;
}
return 0;
}在上面的代码中，我们定义了一个`Graph`类，该类包含了一个邻接表来表示图的结构。`addEdge`函数用于添加无向边。`hasEulerianPath`和`hasEulerianCycle`函数分别用于判断图中是否存在欧拉道路或欧拉回路。`printEulerianPath`和`printEulerianCycle`函数则用于打印对应的路径或回路。
在`main`函数中，我们创建了一个图并添加了一些边，然后判断并打印了图中是否存在欧拉道路或欧拉回路。根据欧拉道路和欧拉回路的定义及判定条件，程序会输出相应的结果。
请注意，上述代码仅为示例，实际应用中可能需要根据具体需求进行调整和优化。同时，为了保证程序的正确性和可读性，建议在实际开发中添加必要的错误检查和边界条件处理。
欧拉图算法的应用通常涉及到深度优先搜索（DFS）来寻找欧拉路径或欧拉回路。力扣上的“重新安排行程”这道题就是一个很好的应用实例，它要求根据给定的航班信息（表示为起点和终点的对），重新安排一个可能的行程。
这个算法的思路如下：
1. 构造邻接表，其中每个节点的邻接节点按字典序排序，以确保DFS的确定性。
2. 从任意一个非空邻接表的节点开始，使用深度优先搜索遍历整个图。
3. 回溯时将访问的节点逆序添加到结果中，这样就可以得到一条欧拉路径。
代码如下。
#include <iostream>
#include <vector>
#include <unordered_map>
#include <stack>
#include <algorithm>
using namespace std;
class Solution {
public:
vector<string> findItinerary(vector<pair<string, string>>& tickets) {
// 构建邻接表
unordered_map<string, vector<string>> graph;
for (const auto& ticket : tickets) {
graph[ticket.first].push_back(ticket.second);
}
// 对每个节点的邻接表进行排序，保证DFS的确定性
for (auto& entry : graph) {
sort(entry.second.begin(), entry.second.end());
}
vector<string> result;
stack<string> s;
// 找到起始点，即邻接表不为空的第一个节点
for (const auto& entry : graph) {
if (!entry.second.empty()) {
s.push(entry.first);
break;
}
}
// 深度优先搜索，回溯时添加节点到结果中
while (!s.empty()) {
string curr = s.top();
s.pop();
// 将当前节点添加到结果中
result.push_back(curr);
// 遍历当前节点的所有邻接节点
vector<string>& neighbors = graph[curr];
while (!neighbors.empty()) {
string next = neighbors.back();
neighbors.pop_back(); // 移除已访问的邻接节点
s.push(next); // 添加到栈中以便后续搜索
}
}
// 反转结果，因为我们是从后往前添加的
reverse(result.begin(), result.end());
return result;
}
};
int main() {
Solution solution;
vector<pair<string, string>> tickets = {
{"MUC", "LHR"},
{"JFK", "MUC"},
{"SFO", "JFK"},
{"LHR", "SFO"}
};
vector<string> itinerary = solution.findItinerary(tickets);
cout << "重建的行程:" << endl;
for (const string& city : itinerary) {
cout << city << " ";
}
cout << endl;
return 0;
}在这个代码中，我们首先创建了一个`unordered_map<string, vector<string>>`类型的`graph`，用于存储每个机场（节点）及其对应的可达机场列表（邻接表）。我们遍历`tickets`数组，将每个起点和终点对添加到`graph`中。
接下来，我们对每个节点的邻接表进行排序，这是为了保证在搜索过程中，每次选择的节点顺序是一致的，从而得到确定的欧拉路径。
我们使用一个栈来进行深度优先搜索。我们从`graph`中找到第一个非空邻接表的节点作为起始点，并将其压入栈中。然后，我们进入一个循环，不断从栈顶取出节点，将其添加到结果数组中，并继续遍历其邻接节点，将它们压入栈中。当栈为空时，说明已经搜索完所有可达的节点。
最后，我们返回反转后的结果数组，因为我们是逆序添加节点的，所以需要反转以得到正确的行程顺序。
这段代码可以在满足题目要求的条件下，正确地重新安排行程，并输出结果。
标签：int,C++,stk,回路,adj,节点,欧拉 From： https://blog.csdn.net/winterling/article/details/139561130