1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

# Nachbarknoten von v bezueglich Kante e
def adjacent_vertex(v, e):
    for x in e:
        if x != v: return x
    raise RuntimeError("unreachable")

# Auflistung der Kanten eines Knotens v
def edges(v, E):
    return [e for e in E if v in e]

# Erschoepfende Suche (Backtracking), rekursiv
def traverse_rec(E, v, acc, path):
    if len(E) == 0:
        acc.append(path + [v])
    for e in edges(v, E):
        E.remove(e)
        traverse_rec(E, adjacent_vertex(v, e), acc, path + [v])
        E.add(e)

# Eulerwege zum Startknoten v
def traverse(E, v):
    acc = []
    traverse_rec(set(E), v, acc, [])
    return acc

# Anzahl der Eulerwege des Graphen G
def count_paths(G):
    (V, E) = G
    acc = 0
    for v in V:
        paths = traverse(E, v)
        count = len(paths)
        print("Knoten {}: {}".format(v, count))
        acc += count
    print("Insgesamt: {}".format(acc))

# [links unten, rechts unten, rechts oben, links oben, First]
# https://commons.wikimedia.org/wiki/File:HausNikolaus.svg
Haus_des_Nikolaus = (
    [1, 2, 3, 4, 5],
    [(1, 2), (2, 3), (3, 4), (1, 4), (1, 3), (2, 4), (3, 5), (4, 5)]
)

count_paths(Haus_des_Nikolaus)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

def traverse_rec(E, v):
    if len(E) == 0: yield 1
    for e in [e for e in E if v in e]:
        yield from traverse_rec(E - {e}, e[1] if v == e[0] else e[0])

def count_paths(G):
    return sum(sum(traverse_rec(set(G[1]), v)) for v in G[0])

Haus_des_Nikolaus = (
    [1, 2, 3, 4, 5],
    [(1, 2), (2, 3), (3, 4), (1, 4), (1, 3), (2, 4), (3, 5), (4, 5)]
)

print(count_paths(Haus_des_Nikolaus))

1:

    for e in [e for e in E if v in e]:

1:
2:

    for e in E:
        if v in e:

1:
2:
3:
4:

    for e in (e for e in E if v in e):
        E.remove(e)
        yield from traverse_rec(E, e[1] if v == e[0] else e[0])
        E.add(e)

1:
2:
3:
4:
5:

    for e in E:
        if v in e:
            E.remove(e)
            yield from traverse_rec(E, e[1] if v == e[0] else e[0])
            E.add(e)

1:

e[1] if v == e[0] else e[0]

1:

e[v == e[0]]

1:
2:
3:
4:
5:
6:

def traverse(E, v):
    return sum(traverse(E - {e}, e[v == e[0]]) for e in E if v in e) if E else 1

def count_paths(G):
    return sum(traverse(set(G[1]), v) for v in G[0])

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

from itertools import permutations

def adjacent_vertex(v, e):
    return e[1] if e[0] == v else e[0] if e[1] == v else None

def is_path(E, v):
    for e in E:
        v = adjacent_vertex(v, e)
        if v is None: return False
    return True

def count_paths(G):
    (V, E) = G
    paths = [P for P in permutations(E) for v in V if is_path(P, v)]
    print(len(paths))

Haus_des_Nikolaus = (
    [1, 2, 3, 4, 5],
    [(1, 2), (2, 3), (3, 4), (1, 4), (1, 3), (2, 4), (3, 5), (4, 5)]
)

count_paths(Haus_des_Nikolaus)