[Un exemple] c'est calme coté propositions.. 
Plus simple, ci dessous il y a 6 ponts et ... 72 chemins possibles
Si ça peut aider..

Je trouve : 79488000 (qui a priori est validé par la case réponse)

En gros: On simplifie tout ça sous forme de graphe. Certains ilots peuvent être éliminés, on se retrouve en gros avec 3 pâtés A, B et C, avec
* 3 ponts entre A et B
* 4 ponts entre A et C
* 5 ponts entre B et C
* 2 ponts de B à lui-même
On peut donc passer par tout une et une seule fois, à condition de démarrer en A et de finir en C (ou l'inverse).

On peut virer les ponts de B vers B: on passe 4 fois sur le pâté B via les autres ponts (8 ponts vers / depuis B, donc 4 passages). Donc on peut calculer "1 parmi 4 + 2 parmi 4" = 10 pour tous les endroits où on peut glisser des trajets de B vers B (on peut faire les deux en une fois, ou sur deux passages)
Et on multiplie par 2! pour l'ordre de ces ponts --> total 20.
On multipliera le résultat final par 20.

Il reste
* 3 ponts entre A et B
* 4 ponts entre A et C
* 5 ponts entre B et C
On définit la fonction f(ile, ab, ac, bc) =
* f(A,0,0,0) = f(B,0,0,0) = 0
* f(C,0,0,0) = 1
* f(A,ab,ac,bc) = ab * f(B, ab-1, ac, bc) + ac * f(C, ab, ac-1, bc)
* f(B,ab,ac,bc) = ab * f(A, ab-1, ac, bc) + bc * f(C, ab, ac, bc-1)
* f(C,ab,ac,bc) = ac * f(A, ab, ac-1, bc) + bc * f(B, ab, ac, bc-1)

Avec ces récurrences, on peut calculer f(A, 3, 4, 5) et on trouve 3974400
Multiplié par 20 pour ajouter les trajets de B vers B: on trouve 79488000

f = (start, ab, ac, bc) => {
    if(ab < 0 || ac < 0 || bc < 0) return 0;
    if(ab == 0 && ac == 0 && bc == 0) return start == 'C' ? 1 : 0;
    if(start == 'A') return f('B', ab-1, ac, bc) * ab + f('C', ab, ac-1, bc) * ac;
    if(start == 'B') return f('A', ab-1, ac, bc) * ab + f('C', ab, ac, bc-1) * bc;
    return f('A', ab, ac-1, bc) * ac + f('B', ab, ac, bc-1) * bc;
}
f('A', 3, 4, 5) * 20
--> 79488000

En version combinatoire : en gros, il faut considérer deux cas:

* soit il n’y a pas de ABA.
Donc tous les AB sont des ABC (donc des AC), et tous les BA sont des CBA (donc des CA, donc des AC aussi en fait).
- On choisit 3 BC parmi 5, et avec les 3 AB on forme 3 AC --> facteur 5 x 4 x 3
- On a 7 AC et 2 BC, qui vont servir à faire
--- un aller AC
--- puis 4 allers-retours CAC ou CBC
- Ce qui revient à faire 7! pour l'ordre des AC, 2! pour l'ordre des BC, et C(1,4) pour placer l'aller-retour CBC au milieux des autres.

--- > On arrive à 5 x 4 x 3 x 7! x 2! x 4 = 4 x 7! x 5!

* soit on a ABA (une seule fois, pas possible de faire plus)
On choisit 2 AB pour savoir lesquels feront cet aller-retour (facteur 3x2)
On combine le AB restant avec un BC pour former un AC (facteur 5)
On a 5 AC, 4 BC et un aller-retour ABA qu'on traitera en dernier.
- un aller AC
- 4 allers-retours CAC ou CBC
Ce qui revient à faire 5! pour l'ordre des AC, 4! pour l'ordre des BC, et C(2,4) pour ordonner ces allers-retours.
On a pour l'instant 6 x 5 x 5! x 4! = 6! x 6!
Reste l'aller-retour ABA, qui peut arriver sur n'importe lequel des 3 A qu'on parcourt : facteur 3

--- > on arrive à 3 x 6! x 6!

Total: 5! x 5! x (168 + 108) = 5! x 5! x 276 = 3974400
(et le tout fois 20 pour finir)

Si on définit [latex]i[/latex] le nombre d'allers-retours ABA qu'on fait en pratique, ça doit donner un truc comme :
[TeX]ab! * bc! * ac! * \sum_i{C_{ac+ab-2i}^{ab-2i} * C_{\frac{ac+bc-1}{2}}^{\frac{bc-ab}{2}+i} * C_{\frac{ab+ac-1}{2}}^{i}}[/TeX]
avec i compris entre max(0, ab-bc)/2 et min(ab-1, bc-1)/2

Pour 3,4,5 :

6 x 24 x 120 x [C(3,7) x C(1,4) x C(0,3) + C(1,5) x C(2,4) x C(1,3)
6 x 24 x 120 x [35 x 4 x 1 + 5 x 6 x 3]
= 3974400

Le premier C() correspond au nombre de combinaisons pour placer les "ABC" (pseudos AC) parmi les autres AC
Le second C() correspond au nombre de combinaisons pour placer les aller-retours CBC parmi les allers-retours CxC
Le dernier C() correspond au nombre de combinaisons pour placer les aller-retours ABA parmi les différents A disponibles