将无向图转换为有向欧拉电路

在图论中，欧拉电路指一条经过图中每条边恰好一次的闭合路径。如果一个无向图含有欧拉电路，那么将每个顶点转化为一个捆绑（bundled）点，用一个完全二部图表示，每个节点代表原图中的一个点。将每条边拆成两条有向边，从一个节点指向另外一个节点。这样，每个捆绑点的所有入度和出度相等。为了消除“死胡同”（即一条路径的末端不能到达其他路径的情况），我们需要在图中添加一些边，使得每个捆绑点的入度和出度均为偶数。当每个捆绑点的入度和出度都为偶数时，就存在一个欧拉路径或者欧拉回路。如果原图是连通的，那么欧拉路径就是欧拉电路；否则，欧拉路径就是原图每个连通分量中欧拉电路的组合。下面是一个示例图：

我们将这张图转换为有向欧拉电路。首先，我们转换成完全二分图分别为以下两个子图：

将每条无向边拆成两条有向边，从同一个节点分别指向另外两个节点，即

(u, v) => (u', v), (v', u)

这样每个捆绑点的所有入度和出度相等。但是，还需要添加一些边来消除死胡同。具体来说，我们需要添加一些额外的有向边，使得每个捆绑点的入度和出度均为偶数。在本例中，我们添加以下几条边

2'->1, 2'->5
5'->6, 5'->2
6'->5

添加这些附加边后，每个捆绑点的入度和出度均为偶数，因此这张图就存在一个欧拉电路。

下面是相应的转换程序：

from collections import defaultdict

# 无向图转完全二分图
def convert_to_bipartite(graph):
    l = []
    r = []
    node_to_bundled = {}
    bundled_to_node = {}
    
    for node in graph:
        if node not in node_to_bundled:
            if len(l) <= len(r):
                l.append(node)
                node_to_bundled[node] = "l%d" % len(l)
                bundled_to_node[node_to_bundled[node]] = node
            else:
                r.append(node)
                node_to_bundled[node] = "r%d" % len(r)
                bundled_to_node[node_to_bundled[node]] = node
    
    # 完全二分图中所有的边
    bipartite_edges = []
    for node in graph:
        for neighbor in graph[node]:
            bipartite_edges.append((node_to_bundled[node], node_to_bundled[neighbor]))

    return (bipartite_edges, bundled_to_node)

# 添加附加边
def add_extra_edges(graph):
    in_degrees = defaultdict(int)
    out_degrees = defaultdict(int)
    
    for node in graph:
        for neighbor in graph[node]:
            out_degrees[node] += 1
            in_degrees[neighbor] += 1
    
    extra_edges = []
    for node in graph:
        if in_degrees[node] % 2 == 1:
            for neighbor in graph[node]:
                if out_degrees[neighbor] % 2 == 1:
                    extra_edges.append((node, neighbor))

    # 添加附加边
    for edge in extra_edges:
        graph[edge[0]].append(edge[1])

    return extra_edges

# 无向图转有向欧拉电路
def undirected_to_directed_eulerian_circuit(graph):
    # 无向图转完全二分图
    bipartite_edges, bundled_to_node = convert_to_bipartite(graph)
    
    # 完全二分图转有向图
    directed_edges = []
    for edge in bipartite_edges:
        directed_edges.append((edge[0] + "'", edge[1]))
        directed_edges.append((edge[1] + "'", edge[0]))
    graph = defaultdict(list)
    for edge in directed_edges:
        graph[edge[0]].append(edge[1])
    
    # 添加附加边
    add_extra_edges(graph)
    
    # 返回欧拉电路
    start_node = list(graph.keys())[0]
    circuit = []
    visited_edges = {}
    visited_edges_count = 0
    
    while visited_edges_count < len(directed_edges):
        for neighbor in graph[start_node]:
            if (start_node, neighbor) not in visited_edges:
                visited_edges[(start_node, neighbor)] = True
                visited_edges[(neighbor, start_node)] = True
                visited_edges_count += 1
                circuit.append((start_node, neighbor))
                start_node = neighbor
                break

    # 将捆绑点转化为原始节点
    eulerian_circuit = []
    for edge in circuit:
        eulerian_circuit.append((bundled_to_node[edge[0]], bundled_to_node[edge[1]]))
    return eulerian_circuit

代码片段中包含了三个函数。函数 convert_to_bipartite 将无向图转换为完全二分图。函数 add_extra_edges 添加附加边。函数 undirected_to_directed_eulerian_circuit 将无向图转换为有向欧拉电路。最后一个函数是主要的函数，并且调用了前两个函数以进行必要的图形转换。这个函数的输出是一个元组，其中包含了欧拉电路的所有边。