MIN-Scheitelpunkt, um in einem Baum zuzugreifen

Question

Ich muss die Mindestanzahl von $ N $ Scheitelpunkte auf einem Baum mit $ n-1 $ Kanten, so dass zumindest $ K $ Kanten dieses Baums mit diesen Scheitelpunkten verbunden sind.

Beispielsweise, wenn $ n= 9 $ und $ k= 6 $ und wir haben dasBaum:

generasacodicetagpre.

Die richtige Antwort sollte $ \ mathrm {min}= 2 $ sein.

irgendwelche Gedanken?

Answer 1

Es gibt einen $ \ Mathcal {O} (NK) $ dp-Ansatz.

Rufen Sie eine Kante auf, wenn wir neben ihm einen Scheitelpunkt auswählen. Wurzeln Sie den Baum an einem beliebigen Vertex $ R $ . Definieren Sie $ dp [i] [b] [t] $ als maximale Anzahl der Kanten im Teiltree von Knoten $ i $ , die mit der Auswahl von höchstens $ T $ Knoten aus dem Teilbaum abgedeckt werden. Wenn $ B= 0 $ wir nicht auswählen dürfen Knoten $ i $ , und wenn $ B= 1 $ Wir müssen es auswählen.

Wenn wir diesen DP berechnen, können wir das Problem lösen, da die Mindestanzahl der Knoten zum Abdecken von $ K $ Kanten ist, ist der kleinste $ T $ für welches $ max (dp [r] [0] [t], dp [r] [1] [t]) \ geq k $ . Weiterhin beachten Sie, dass er ausreicht, um nur den $ DP $ für $ t \ leq k $ als beliebige zu berechnen $ k Knoten decken mindestens $ K $ Kanten.

Um das Wiederauftreten zu berechnen, um den DP zu berechnen, geben wir zuerst die Knapsack-Funktion an: Lassen Sie $ k (v_ {1}, \ dots, v_ {m}) $ ein Array so sein, dass

\ beginnen {Gleichung *} K (v_ {1}, \ dots, v_ {m}) [t]=max_ {t_ {1} + \ dots + t_ {m}= t} \ sum_ {j= 1} ^ {m} v_ { j} [t_ {j}] \ \ end {Gleichung *}

Beachten Sie, dass $ k (k (v_ {1}, \ dots, v_ {m-1}), v_ {m})= k (v_ {1}, \ Punkte, v_ {m}) $ , und dass $ k (a, b) $ direkt von der obigen Formel in $ \ Mathcal {O} (| A | \ cdot | B |) $ Zeit. Somit berechnen $ k (v_ {1}, \ dots, v_ {m}) $ nimmt $ \ mathcal {o} (\ sum_ {i= 2} ^ {m} | v_ {i} | ^ {i-1} ^ {i-1} | v_ {j} |) $ Zeit unabhängig von der Bestellung, die wir kombinieren Die Sets in. Wenn wir uns an nur den ersten $ K $ Werte des DP interessieren, fällt die Komplexität auf $ \ mathcal {o} (\ sum_ {i= 2} ^ {m} | v_ {i} | \ min (k, \ sum_ {j= 1} ^ {i-1} | v_ {j} |)) $ < / span>

lass $ c_ {i} $ sein Set von Kindern des Knotens $ i $ , und $ C_ {IJ} $ Seien Sie der $ J $ th-kind von $ i $ . Dann \ beginnen {sammeln *} Dp [i] [0] [t]= k (v_ {1}, \ dots, v_ {| c_ {i} |}) [t] \\ Dp [i] [1] [t]= | c_ {i} | + K (v '_ {1}, \ dots, v' _ {| c_ {i} |}) [T-1] \ ende {sammeln *} Wo \ beginnen {sammeln *} V_ {j} [t]=max (dp [c_ {ij}] [0] [t], dp [c_ {ij}] [1] [t] + 1) \\ V '_ {j} [t]=max (dp [c_ {ij}] [0] [t], dp [c_ {ij}] [1] [t]) \\ \ ende {sammeln *} Die Berechnung der Antwort mit diesem Rekursion nimmt $ \ Mathcal {O} (NK) $ Uhrzeit. Informell ist dies, weil wir im Laufe des Algorithmus einzelne Elemente-DPs in einen DP kombinieren, der den gesamten Baum darstellt. Wir machen höchstens $ \ frac {n} {k} $ Kombinationen von Größe der Größe $ K $ , und jedes Element kostet uns höchstens $ 2K $ Time (falls Element $ X \ in einem $ Kosten US $ | B | $ Zeit beim Berechnen der $ k (a, b) $ ), bevor es zusammengeführt wird in einen Satz von Größe $ K $ , so ist der Gesamtbetrag der Arbeit höchstens $ \ Mathcal {O} (k ^ {2} \ frac {n} {k} + kN)=mathcal {o} (nk) $ . Dies ist einfach, aber langweilig, um mit der Induktion zu formalisieren.

generasacodicetagpre.

Answer 2

Eine einfache Lösung besteht darin, den Status $ dp (n, 2, n) $ zu verwenden. Lassen Sie $ dp (i, 0, j) $ Seien Sie die maximale Anzahl der Kanten, die wir mit $ \ leqj J erhalten können $ Knoten in dem Teilbaum, das bei Knoten $ I $ , mit Knoten $ I $ selbst nicht in der Scheitelpunktabdeckung sein. Lassen Sie $ dp (i, 1, j) $ dasselbe, außer dem Knoten $ I $ ist enthalten in der Scheitelpunktabdeckung.

Der Übergang selbst ist nicht offensichtlich, aber es kann mit einer knapsackähnlichen Methode erfolgen. Betrachten Sie alle Kinder des Knotens $ i $ . Verwenden Sie alle Werte von $ DP (CH, 0, C) $ und $ dp (CH, 1, C) $ $ als Elemente in zwei separaten Rucksacks: Eine zur Berechnung des vollständigen Arrays $ dp (i, 0) $ und eine, um das vollständige Array $ dp (i, 1) $ . Die Kosten für Elemente sind einheitlich $ C $ , während die Werte derzeit sind:

Wenn berechnet $ dp (i, 0) $ : Wert von $ dp (CH, 0, C) $ ist $ dp (CH, 0, C) $ ; Wert von $ DP (CH, 1, C) $ ist $ dp (CH, 1, c) + 1 $ < / span>.
Bei Berechnung der $ dp (i, 1) $ : Wert von $ dp (CH, 0, c) $ ist $ dp (CH, 0, C) +1 $ ; Wert von $ DP (CH, 1, C) $ ist $ dp (CH, 1, c) + 1 $ < / span>.

Wir können die vollständigen Arrays $ dp (i, 0) $ und $ dp (i, 1) $ Direkt aus den Endwerten der Rucksäcke (dh die Werte von $ kN (last, j) $ für alle $ J $ ). Der Knapsack hat $ O (\ # Kinder * n) $ Elemente pro Knoten und läuft in $ O (\ # Kinder * n * n) $ pro Knoten. Daher ist die Gesamtkomplexität der Lösung $ o (n ^ 3) $ . Bitte beachten Sie, dass Sie den traditionellen 0-1-Rucksack leicht modifizieren müssen, um zwei Elemente zu verhindern, die denselben Knoten darstellen, der vomselben Node darstellt; Das ist nicht sehr schwierig. Beachten Sie auch, wenn Sie den $ dp (i, 1) $ -Ary berechnen, beachten Sie, dass der Knoten $ I $ selbst ist ein zusätzlicher Knoten auf der Scheitelpunktabdeckung.

Ich blieb sicher, ob es Lösungen gibt, die in der Zeit schneller laufen als dieses, aber ich würde nicht daran zweifeln.