Complexité temporelle de l'algorithme Held-Karp pour TSP

Lorsque j'ai examiné « Une approche de programmation dynamique pour résoudre les problèmes de séquençage » de Michael Held et Richard M. Karp, j'ai posé la question suivante: pourquoi la complexité de leur algorithme pour TSP est-elle (p. 199), je veux dire où prennent-ils le facteur ? Si j'ai bien compris, signifie le nombre d'ajouts pour chaque sous-ensemble de villes. Alors pourquoi chaque opération d'addition est couplé avec inconnu pour moi opérations? Je suppose qu'il est en quelque sorte lié à la prise de minimum, mais le minimum de calcul ne semble pas nécessiter autant d'opérations. $(\sum_{k=2}^{n-1}k(k-1)\binom{n-1}{k})+(n-1)$ $k$ $k-1$ $k$

L'algorithme de programmation dynamique par Held et Karp et indépendamment Bellman s'exécute comme suit: pour chaque paire $(S,c_i)$ , c'est-à-dire un chemin passant par $c_1$ , tous les éléments de $S$ et se terminant à $c_i$ calcul

$OPT[S,c_i]=min\{OPT[S\setminus\{c_i\},c_j]+d(c_j,c_i):c_j\in S\setminus\{c_i\}\},$

où $d(c_j,c_i)$ signifie la distance entre les villes $c_j$ et $c_i$ . Ensuite , dans la formule du papier $k$ signifie la taille de $S$ .

ds.algorithms tsp exp-time-algorithms Oleksandr Bondarenko
la source

Réponses:

Addendum ci-dessous, clarifiant les termes $k(k-1)$ :

Donc, si vous examinez les termes dans l'expression, vous pouvez imaginer (par analogie) que le terme est une énumération de toutes les chaînes binaires contenant 1 qui ont un 1 en première position. En d'autres termes, nous laissons chaque position dans la chaîne binaire représenter le choix de savoir si l'une donnée des villes du problème se trouve dans le sous-ensemble exact que nous considérons à l'époque. Ainsi, pour 5 villes, 10101 correspond au sous-ensemble {1,3,5}. $n-1 \choose k$ $k$ $n$

Ainsi, pour calculer à travers tous les sous-ensembles de {1, ..., }, nous comptons simplement à travers chaque sous-ensemble binaire (c'est-à-dire compter à travers des chaînes binaires) de taille = 2 (c'est-à-dire des chaînes binaires de taille qui contiennent deux 1), puis taille = 3, puis taille = 4, ... puis taille = n. (Notez que le sous-ensemble size = 1 ne doit contenir que la première ville, et donc il n'est pas pertinent de calculer sa distance partielle, car la distance de 1 -> toutes les autres villes du sous-ensemble -> 1 est exactement 0.) $n$ $n$

Pour chaque sous-ensemble avec villes, nous devons considérer jusqu'à chemins partiels optimaux pour les candidats. Plus précisément, le chemin optimal optimal pourrait traverser le sous-ensemble donné et aboutir à n'importe laquelle des villes, à l'exclusion de la première ville. Ensuite, pour chacun de ces sous-chemins candidats, nous calculons le tour optimal jusqu'à ce point comme le minimum de l'un des sous-chemins précédents, size = plus la distance de la ville terminale pour ce sous-chemin vers le ville terminale pour le sous-chemin candidat actuel. Cela donne telles comparaisons que nous devons faire. L'écart entre mon terme et le $k$ $k-1$ $k-1$ $k-1$ $(k-1)(k-2)$ $(k-1)(k-2)$ $k(k-1)$ terme dans l'analyse liée est une différence de notation (je résumerais sur une plage différente, étant donné ma définition de qu'ils ne l'ont fait). À tout le moins, cependant, il devrait illustrer la complexité d'ordre quadratique de ce terme. $k$

Comme c'est intéressant - je viens de terminer de coder cet algorithme exact en C ++ il y a quelques minutes. (Alors pardonnez la tangente de la théorie pure à une petite discussion pratique. :))

Cela coûte temps et espace - au moins sous mon implémentation. En pratique, cependant, lorsque vos besoins d'espace augmentent aussi rapidement, ils deviennent beaucoup plus douloureux que les besoins en temps. Par exemple, sur mon PC (avec 4 Go de RAM), je peux résoudre des instances avec jusqu'à 24 villes - plus que cela, et je manque de mémoire. $O(2^n n^2)$ $O(2^n n)$

Bien sûr, je pourrais juste être un mauvais programmeur, et vous pourriez peut-être faire mieux que moi dans la pratique. :)

Edit: Un peu plus de détails sur un détail de votre question: le terme vient du fait que vous devez, dans le pire des cas, calculer la distance optimale partielle à partir des sous-ensembles précédents (il y a au plus d'entre eux; notez que est additionné de dans l'analyse que vous avez liée) à l'analyse en cours. Cela nécessite, là encore dans le pire des cas, des comparaisons avec des sous-ensembles de taille pour un total de . $k(k-1)$ $n$ $k$ $n$ $O(k)$ $k-1$ $O(k^2)$

De plus, si mon explication n'était pas assez claire, voici quelques belles notes de cours de Vazirani ( PDF ). Faites défiler jusqu'à P. 188 pour une discussion sur le TSP, y compris une analyse de Held-Karp.

Daniel Apon
la source

Oh bien sûr! Je me sens idiot d'y penser maintenant; Je mettrai à jour ma réponse. J'avais déjà entendu ce commentaire précis auparavant et je l'avais transmis sans y penser. Et oui - écrire dans un fichier / lire à partir d'un fichier vous permettra effectivement d'aller arbitrairement haut sur le nombre de villes. ... c'est aussi une douleur qui ne vaut pas la peine de s'inquiéter, sauf si vous essayez de résoudre des instances TSP dans un but réel. La mienne n'était décidément pas à des fins pratiques. ;)

Daniel Apon

Il est temps de mettre en œuvre l'algorithme Bjorklund :)

Suresh Venkat

@Suresh: Bonne idée!

Daniel Apon

@Daniel Apon Pourriez-vous, s'il vous plaît, préciser pourquoi nous avons besoin de comparaisons pour calculer "la distance partielle optimale"?

Oleksandr Bondarenko

@Oleksandr: Bien sûr, je vais l'ajouter en haut de ma réponse.

Daniel Apon

Note principale

Il est important de noter que nous calculons et stockons non pas
"la distance du chemin optimal pour combination of k cities"
mais
"la distance du chemin optimal pour combination of k cities ET pour end-point city from this combination".
Le comprendre aidera à la signification des deux premiers multiplicateurs dans la formule suivante.

Première phase

Le nombre d'opérations dans la première phase est:

\sum_{k >= 2} \underset{\begin{matrix} choose city combination \\ of size = k - 1 \end{matrix}}{\underset{⏟}{(\binom{n - 1}{k - 1})}} \cdot \underset{\begin{matrix} choose city to be the last \\ from k - 1 cities \\ in chosen combination \end{matrix}}{\underset{⏟}{(k - 1)}} \cdot \underset{\begin{matrix} choose city \\ that is not in chosen combination \\ to add to path \end{matrix}}{\underset{⏟}{((n - 1) - (k - 1))}}

$\displaystyle \sum_{k>=2} \underbrace{ \binom{n-1}{k-1} }_{\substack{ \text{choose city combination} \\ \text{of size = $k-1$}}} \cdot \underbrace{ (k-1) }_{\substack{ \text{choose city to be the last} \\ \text{from $k-1$ cities} \\ \text{in chosen combination} } } \cdot \underbrace{ ((n-1)-(k-1)) }_{ \substack{ \text{choose city} \\ \text{that is not in chosen combination} \\ \text{to add to path} } }$

L'exposant manquant dans la somme signifie for all k>=2 that is valid for binomial coefficient. Ainsi, le dernier terme de somme non nul valide sera pour Cela signifie que notre somme ne capture pas les derniers choix de la ville pour se connecter à la première ville. Il y a villes pour se connecter à la première ville. Enfin, nous ajouterons ce terme à la somme. $k=n-1$

(\binom{n - 1}{n - 2}) \cdot (n - 2) \cdot 1

$\binom{n-1}{n-2} \cdot (n-2) \cdot 1$

n - 1

$n-1$

Laisser transformer la formule à la forme que vous fournissez c'est aussi détenus Karp la page Wikipedia .

\sum_{k >= 2} (\binom{n - 1}{k - 1}) \cdot (k - 1) \cdot ((n - 1) - (k - 1)) = \sum_{k >= 2} \frac{(n - 1)!}{(k - 1)! (n - k)!} \cdot (k - 1) \cdot (n - k) = \sum_{k >= 2} \frac{(n - 1)!}{k! (n - 1 - k)!} \cdot k \cdot (k - 1) = \sum_{k >= 2} (\binom{n - 1}{k}) \cdot k \cdot (k - 1)

$\displaystyle \sum_{k>=2} \binom{n-1}{k-1} \cdot (k-1) \cdot ((n-1)-(k-1))= \sum_{k>=2} \frac{(n-1)!}{(k-1)!(n-k)!} \cdot (k-1) \cdot (n-k)= \sum_{k>=2} \frac{(n-1)!}{k!(n-1-k)!} \cdot k \cdot (k-1)= \sum_{k>=2} \binom{n-1}{k} \cdot k \cdot (k-1)$ manipulation des coefficients binomiaux conduit à: Donc, le nombre d'opérations dans la première la phase est

\sum_{k >= 2} (\binom{n - 1}{k}) \cdot k \cdot (k - 1) = \sum_{k >= 2} \frac{(n - 1)!}{k! (n - 1 - k)!} \cdot k \cdot (k - 1) = \sum_{k >= 2} \frac{(n - 3)!}{(k - 2)! (n - 3 - (k - 2))!} \cdot (n - 1) \cdot (n - 2) = (n - 1) \cdot (n - 2) \sum_{k >= 2} (\binom{n - 3}{k - 2}) = (n - 1) \cdot (n - 2) \cdot 2^{n - 3}

$\displaystyle \sum_{k>=2} \binom{n-1}{k} \cdot k \cdot (k-1) = \sum_{k>=2} \frac{(n-1)!}{k!(n-1-k)!} \cdot k \cdot (k-1) = \sum_{k>=2} \frac{(n-3)!}{(k-2)!(n-3-(k-2))!} \cdot (n-1) \cdot (n-2)= (n-1) \cdot (n-2)\sum_{k>=2} \binom{n-3}{k-2}=(n-1) \cdot (n-2) \cdot 2^{n-3}$

(n - 1) \cdot (n - 2) \cdot 2^{n - 3} + (n - 1)

$(n-1) \cdot (n-2) \cdot 2^{n-3}+(n-1)$

Seconde phase

La deuxième phase restaure le chemin optimal par les marques que nous avons faites dans la première phase simultanément avec le calcul des distances.

Pour chaque chemin optimal "pour combination of k cities ET pour end-point city from this combination", nous avons enregistré l'avant-dernière ville.

Pour revenir en arrière sur le chemin optimal, nous devons demander à une structure de données de renvoyer l'avant-dernière ville "pour combination of k cities ET pour end-point city from this combination". Cette structure de données doit donc ressembler à quelque chose
Map<combination of k cities, Map<last city, second-to-last city>>. Comme index de combination of k citiesnous pouvons utiliser, par exemple binary_string[city id]=1 if city id is in combination,. Nous devons donc examiner tous les éléments de combination of k citiespour identifier la combinaison et indexer notre structure de données. Cela nous donne le nombre d'opérations pour la deuxième phase:

\sum_{k >= 2}^{n - 1} k = \frac{(n) (n - 1)}{2} - 1

$\displaystyle \sum_{k>=2}^{n-1} k = \frac{(n)(n-1)}{2} - 1$

dimathe47
la source