Complessità temporale dell'algoritmo Held-Karp per TSP

Quando ho esaminato " Un approccio di programmazione dinamica ai problemi di sequenziamento " di Michael Held e Richard M. Karp, ho trovato la seguente domanda: perché la complessità del loro algoritmo per TSP è $(\sum_{k=2}^{n-1}k(k-1)\binom{n-1}{k})+(n-1)$ (p. 199), intendo dove prendono il fattore $k$ ? Se ho capito bene $k-1$ significa il numero di aggiunte per ciascun sottoinsieme di città. Allora perché ogni operazione di aggiunta è accoppiata con operazioni sconosciute a me $k$ ? Suppongo che sia collegato in qualche modo al minimo, ma il minimo di calcolo non sembra richiedere così tante operazioni.

L'algoritmo di programmazione dinamica di Held e Karp e indipendentemente Bellman funziona come segue: per ogni coppia $(S,c_i)$ , che significa un percorso che attraversa $c_1$ , tutti gli elementi di $S$ e termina al calcolo $c_i$

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

dove $d(c_j,c_i)$ indica la distanza tra le città $c_j$ e $c_i$ . Poi nella formula dalla carta $k$ indica la dimensione di $S$ .

ds.algorithms tsp exp-time-algorithms

— Oleksandr Bondarenko
fonte

Risposte:

Appendice al seguito, che chiarisce i termini $k(k-1)$ :

Quindi, se si esaminano i termini nell'espressione, si può immaginare (come analogia) il termine è un'enumerazione di tutte le stringhe binarie contenenti 1 che hanno un 1 in prima posizione. In altre parole, lasciamo che ogni posizione nella stringa binaria rappresenti la scelta se una data delle città del problema si trova nel sottoinsieme esatto che stiamo considerando al momento. Pertanto, per 5 città, 10101 corrisponde al sottoinsieme {1,3,5}. $n-1 \choose k$ $k$ $n$

Pertanto, per calcolare tutti i sottoinsiemi di {1, ..., }, contiamo semplicemente attraverso ogni sottoinsieme binario (ovvero contiamo attraverso stringhe binarie) di dimensione = 2 (ovvero stringhe binarie di dimensione che contengono due 1), quindi size = 3, quindi size = 4, ... quindi size = n. (Notare che la dimensione = 1 sottoinsieme deve contenere solo la prima città, quindi è irrilevante calcolare la sua distanza parziale, poiché la distanza da 1 -> tutte le altre città nel sottoinsieme -> 1 è esattamente 0.) $n$ $n$

In ogni sottoinsieme con città, dobbiamo considerare fino a percorsi parziali ottimali per i candidati. In particolare, il percorso ottimale e totale potrebbe concepibilmente attraversare il sottoinsieme dato e finire su una qualsiasi delle città , esclusa la prima città. Quindi, per ciascuno di questi sotto-percorsi candidati, calcoliamo il tour ottimale fino a quel punto come il minimo di uno dei precedenti sotto-percorsi size = più la distanza dalla città terminale per quel sotto-percorso verso il città terminale per l'attuale sotto-percorso candidato. Questo dà a paragoni che dobbiamo fare. La discrepanza tra il mio termine e il termine $k$ $k-1$ $k-1$ $k-1$ $(k-1)(k-2)$ $(k-1)(k-2)$ $k(k-1)$ il termine nell'analisi collegata è una differenza notazionale (vorrei sommare su un intervallo diverso, data la mia definizione di rispetto a loro). Per lo meno, tuttavia, dovrebbe illustrare la complessità dell'ordine di secondo grado di quel termine. $k$

È interessante - ho appena finito di codificare questo esatto algoritmo in C ++ pochi minuti fa. (Quindi perdona la tangente della pura teoria in una piccola discussione pratica. :))

Costa tempo e spazio - almeno sotto la mia implementazione. In pratica, tuttavia, quando i requisiti di spazio crescono così velocemente, diventano molto più dolorosi dei requisiti di tempo. Ad esempio, sul mio PC (con 4 GB di RAM), posso risolvere istanze con un massimo di 24 città, non più di così, e ho esaurito la memoria. $O(2^n n^2)$ $O(2^n n)$

Certo, potrei solo essere un cattivo programmatore e potresti essere in grado di fare meglio di me in pratica. :)

Modifica: un po 'più specifici su un dettaglio della tua domanda: il termine deriva dal fatto che devi, nel peggiore dei casi, calcolare la distanza parziale, ottimale dai sottoinsiemi precedenti (ci sono al massimo di essi; nota che è sommato su nell'analisi che hai collegato) a quello corrente. Ciò richiede, sempre nel peggiore dei casi, confronti con sottoinsiemi di dimensione per un totale di . $k(k-1)$ $n$ $k$ $n$ $O(k)$ $k-1$ $O(k^2)$

Inoltre, se la mia spiegazione non fosse abbastanza chiara, ecco alcune belle note di lezione di Vazirani ( PDF ). Scorri verso il basso fino a P. 188 per una discussione su TSP, inclusa un'analisi di Held-Karp.

— Daniel Apon
fonte

Oh, certo! Mi sento sciocco a pensarci adesso; Aggiornerò la mia risposta. In realtà avevo già sentito quel commento esatto prima e l'avevo trasmesso senza pensarci. E sì: scrivere su un file / leggere da un file ti consentirà di andare effettivamente in alto arbitrariamente su un numero di città. ... è anche un dolore di cui non vale la pena preoccuparsi se non stai cercando di risolvere istanze TSP per uno scopo reale. Il mio non era decisamente per uno scopo pratico. ;)

— Daniel Apon il

È ora di implementare l'algoritmo di Bjorklund :)

— Suresh Venkat il

@Suresh: buona idea!

— Daniel Apon,

@Daniel Apon Potresti, per favore, precisare perché abbiamo bisogno di confronti nel calcolo della "distanza parziale, ottimale"?

— Oleksandr Bondarenko il

@Oleksandr: Certo, lo aggiungerò all'inizio della mia risposta.

— Daniel Apon,

Nota principale

È importante notare che calcoliamo e memorizziamo non
"distanza del percorso ottimale per combination of k cities"
ma
"distanza del percorso ottimale per combination of k cities AND per end-point city from this combination".
Comprenderlo aiuterà con il significato dei primi due moltiplicatori nella seguente formula.

Prima fase

Il numero di operazioni nella prima fase è:

\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'apice mancante in somma significa for all k>=2 that is valid for binomial coefficient. Quindi l'ultimo termine valido non nullo della somma sarà per Significa che la nostra somma non acquisisce le ultime scelte della città per connettersi alla prima città. Ci sono città per connettersi alla prima città. Quindi alla fine aggiungeremo questo termine alla somma. $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$

Consenti di trasformare la formula nel modulo che fornisci che si trova anche sulla pagina di Held-Karp 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)$ manipolazione dei coefficienti binomiali porta a: Quindi il numero di operazioni nella prima phase is

\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)$

Seconda fase

La seconda fase sta ripristinando il percorso ottimale con i segni che abbiamo fatto nella prima fase contemporaneamente alle distanze di calcolo.

Per ogni percorso ottimale "per combination of k cities AND per end-point city from this combination" abbiamo salvato la penultima città.

Per tornare indietro nel percorso ottimale, dobbiamo chiedere ad alcune strutture di dati di restituire la penultima città "per combination of k cities AND per end-point city from this combination". Quindi questa struttura di dati deve essere qualcosa di simile
Map<combination of k cities, Map<last city, second-to-last city>>. Come indice di combination of k citiespossiamo usare, per esempio binary_string[city id]=1 if city id is in combination,. Quindi dobbiamo esaminare tutti gli elementi combination of k citiesper identificare la combinazione e indicizzare la nostra struttura di dati. Questo ci dà il numero di operazioni per la seconda fase:

\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
fonte