2015-07-25 11 views
25

Esiste un algoritmo per trovare uno spanning tree di un grafo non orientato che minimizzi il numero di vertici connessi a più di un bordo?Spanning tree che riduce al minimo il numero di vertici connessi a più spigoli?

Ad esempio, dato un grafico a griglia 4 x 4, vogliamo trovare uno spanning tree come quello a sinistra (che ha 7 vertici collegati a più di un bordo) piuttosto che a destra (che ha 12) :

4 x 4 grid graph

Edit: Sarebbe questo problema essere più semplice se si considerano solo grafi planari (o anche solo grafici griglia)?

+0

Ti interessa ridurre al minimo il livello medio dell'intero albero di copertura o solo la riduzione al minimo del numero di nodi non foglia? – aportr

+0

@jabolotai - Potresti definire cosa intendi per "il grado medio dell'intero albero di copertura"? – user200783

+0

Se si confrontano due spanning tree e uno ha un vertice di grado 5 mentre l'altro è identico tranne che invece ha un vertice di grado 4, ne tratteresti uno come soluzione migliore, o li considereresti uguali? – aportr

risposta

0

Non che io sappia.

È possibile utilizzare un approccio di Larghezza prima ricerca, aggiungendo tutti i vertici non visitati a una coda e visitando il vertice successivo nella coda. Nel frattempo dovresti aggiungere i vertici e i loro bordi a una coda prioritaria basata sul numero di possibili bordi che si diramano dal vertice di connessione. Quindi passa attraverso il PQ in modo ricorsivo, aggiungendo il miglior vantaggio ogni volta. Dovresti solo sminuire i bordi che contengono i vertici già usati. Quindi controlla se ci sono dei bordi con priorità più alta sull'ultimo vertice e, in tal caso, fai il backtrack.

È un concetto brutto e potrebbe essere anche peggio nell'implementazione.

0

Per un 4x4 avrei bisogno solo di 7 vertici collegati a più di 1 bordo, che mi darebbero 9 nodi foglia.

x-o-x x 
    | | 
x-o-x o 
    | | 
o-o-o-o 
| | | | 
x x x x 

Man mano che le dimensioni si ingrandiscono, è necessario espandere il motivo sopra descritto.

Per un 10x10 che avresti avuto 59 nodi foglia

x-o-x x-o-x x-o-x x 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
x-o-x x-o-x x-o-x o 
    |  |  | | 
o-o-o-o-o-o-o-o-o-o 
| | | | | | | | | | 
x x x x x x x x x x 

Per le griglie in cui le righe <> Cols che avrebbe dovuto provare il modello in entrambi gli orientamenti per vedere quale produce i risultati migliori.

+1

Non penso che la domanda sia limitata alla griglia. – Haozhun

4

Come osserva Evgeny nei commenti, questo è noto come maximum leaf spanning tree problem. Ho collegato l'articolo di Wikipedia al problema dei set dominanti connessi strettamente correlati, che è il problema di trovare un set minimo di vertici che (i) induca un sottografo collegato (ii) a soddisfare la proposizione che, per tutti gli altri vertici v , alcuni vertici nell'insieme sono adiacenti a v. I due problemi mostrati come equivalenti alla soluzione osservando che, dato uno spanning tree, possiamo costruire un set dominante collegato facendo cadere le foglie (i vertici con esattamente una connessione), e dato un set dominante collegato, possiamo estrarre un albero di copertura del sottografo indotto e attaccare gli altri vertici come foglie.

Sfortunatamente, entrambi i problemi sono NP-rigidi e rimangono NP-rigidi sotto una limitazione ai grafici planari. Non ho familiarità con la letteratura sul set dominante in particolare, ma la mia ipotesi è che ci siano tre angoli.

  1. Algoritmi/algoritmi di approssimazione esatti in tempo esponenziale "veloci".
  2. Algoritmi esatti che non sono sufficientemente veloci (ad es. Programmazione in interi) ma buoni nella pratica.
  3. Euristica.

# 1 può sembrare uno strano gruppo, ma ciò che tende ad accadere nella letteratura grafo planare è che gli algoritmi esatti vengono usate come subroutine all'interno degli algoritmi di approssimazione, spesso tramite una tecnica a causa Brenda Baker denominato mutevole. Una delle proprietà dei grafici planari è che un parametro chiamato treewidth è delimitato da O (sqrt (n)) invece di n, e ci sono programmi dinamici il cui esponente del tempo di esecuzione è una funzione della treewidth molto più piccola. Ad esempio, sulle griglie, è possibile eseguire una riga riga per riga D. Il macchinario di scomposizione dell'albero generalizza questo a grafici planari arbitrari.

È difficile consigliarti sul percorso migliore senza sapere come sono le istanze e forse anche senza sperimentare con loro. Probabilmente andrei con la porta # 2, ma non sono sicuro di come sarebbe una buona formulazione. La buona notizia è che la maggior parte della complessità algoritmica è astratta nella libreria del solutore che userete. Ecco una formulazione di qualità sconosciuta.

Per tutti i vertici v, cerchiamo x_v essere 1 se v è un non-foglia e 0 se v è una foglia. La parte set dominante è facile.

minimize sum_v x_v 
subject to 
for all v, sum_{w such that w = v or w ~ v} x_w >= 1 
for all v, x_v in {0, 1} 

Qui sto usando ~ per significare "è adiacente a". L'applicazione del vincolo di connettività è più complicata. L'approccio più semplice che posso pensare è quello di risolvere il programma intero così com'è, quindi cercare due vertici s e t che sono entrambi scelti ma non connessi nella soluzione, calcolare un separatore di vertici minimo U tra s e t tra i separatori non inclusi un vertice scelto, immettere un vincolo

(1 - x_s) + (1 - x_t) + sum_{v in U} x_v >= 1 

e quindi riprovare.

Sarei più fiducioso su un approccio che utilizza in modo esponenziale molte variabili, ma potrebbe essere molto più difficile da implementare (generazione di righe e colonne). Scegli un vertice r che sarà forzato come non foglia (indovina o prova tutte le possibilità). C'è una variabile y_P per ogni percorso semplice P con r come endpoint.

minimize sum_v x_v 
subject to 
for all v, for all P having v as an interior vertex, 
    x_v >= y_P 
for all v, sum_{P having v as an endpoint} y_P >= 1 
for all v, x_v in {0, 1} 
for all P, y_P in {0, 1}