Dato un semplice grafico G, qual è il modo più rapido noto per assaggiare uno dei suoi alberi che attraversano a caso?

Question

Diciamo che ho un semplice grafico G con un set di bordo E, set di vertice V e almeno 1 ciclo.

Siamo in grado di determinare il numero di alberi da spanning in questo grafico trovando la sua matrice di laplaciana grafica, colpendo una riga e una colonna e quindi prendendo il fattore determinante di quella sotto-matrice.

Chiamiamo quel determinante t (cioè ci sono possibili alberi in totale).

Qual è l'algoritmo più rapido noto in modo tale che il suo input sia G e il suo output è uno dei possibili alberi di G (in cui ogni albero che si spinge ha il più vicino a $ frac {1} {t} $ di essere selezionato il più possibile) ?

Ecco l'algoritmo che sto usando attualmente.

---

Definizioni:

$ V_ {visitato} $ - vertici già attraversati

$ E_ {visitato} $ - bordi già attraversati

$ V_c $ - v v_visited (cioè vertici in v ma non in $ v_ {visitato} $)

N ($ v_ {visitato} $) - Il set di tutti i vertici v in $ v_c $ in modo tale che esista un vantaggio tra V e un po 'di vertice in $ v_ {visitato} $

---

Algoritmo:

• Esempio $ v_0 $ da V in modo casuale
• Aggiungi $ v_0 $ a $ v_ {visitato} $
• Esempio $ v_1 $ da n ($ v_ {visitato} $) casualmente
• Aggiungi ($ v_0 $, $ v_1 $) a $ e_ {visitato} $
• Esempio $ v_2 $ da n ($ v_ {visitato} $) casualmente
• Aggiungi ($ v _*$, $ v_2 $) a $ e_ {visitato} $ (dove $ v _*$ è un scelto casualmente dai vicini di $ v_2 $ in $ v_ {visitato} $)

...

• Esempio $ V_ {| V | - 1} $ (il secondo all'ultimo vertice in v) in modo casuale
• Aggiungi ($ v _*$, $ v_ {| v | - 1} $) a $ e_ {visitato} $ (dove $ v _*$ è scelto casualmente da $ v_ {| v | - 1} $ 's in $ V_ {visitato} $)
• Esempio $ V_ {| V |} $ (l'ultimo vertice in V)
• add (v*, $ v_ {| v |} $) a $ e_ {visitato} $ (dove $ v _*$ è un scelto casualmente da $ v_ {| v |} $ di vicini in $ v_ {visitato} $ )

Ora $ v_ {visitato} $ e $ e_ {visitato} $ rappresenta un albero di spanning casuale di G.

---

È questo il modo più efficiente per ottenere un albero di spanning casuale? C'è un modo più efficiente? (Punti bonus se è parallelizzabile.)