Trovare tutti i cicli

Ho un insieme finito , una funzione , e un ordine totale su . Voglio trovare il numero di cicli distinti in .f : S → S < S $S$$f:S\to S$$<$$S$$S$

Per un dato elemento posso usare l'algoritmo di Floyd (o Brent, ecc.) Per trovare la lunghezza del ciclo a cui ripetute applicazioni di invia ; con un po 'più di sforzo riesco a identificare questo ciclo (ad es. con il suo elemento -minimal). Un metodo errato per risolvere il problema sarebbe quello di ripetere questo ogni elemento, ordinare gli elementi minimi risultanti scartando i duplicati e restituire il conteggio. Ma ciò comporta potenzialmente molti passaggi sugli stessi elementi e requisiti di spazio elevati.f s $s\in S$$f$$s$$<$

Quali metodi offrono migliori prestazioni in termini di tempo e spazio? Non sono nemmeno sicuro di quale sia il modo migliore per misurare lo spazio necessario: se è la funzione di identità, qualsiasi metodo che memorizza tutti i cicli utilizzerà lo spazio .Ω ( n $f$$\Omega(n)$

Se tutto ciò che vuoi fare è contare il numero di cicli, puoi farlo con 2 | S | bit (più cambio) di spazio. Sembra improbabile che tu possa fare molto meglio a meno che S o f non abbiano alcune proprietà particolarmente convenienti.

Inizia con un array A che memorizza numeri interi {0,1,2} - uno per elemento di S - inizializzato su zero; indicheremo questi come (unexplored), (partially explored)e (fully explored). Inizializza un contatore di cicli a zero. Per ogni elemento s  ∈  S in ordine, procedi come segue:

1. Se A [ s ] =  (fully explored), vai al passaggio 6.
2. Impostare A [ s ] ←  (partially explored)e impostare un iteratore j  ←  f (s) .
3. Mentre A [ j ] =  (unexplored), imposta A [ j ] ←  (partially explored)e imposta j  ←  f (j) .
4. Se A [ j ] =  (partially explored), abbiamo chiuso un nuovo ciclo; incrementa c di 1. (Se vuoi tenere un registro di un rappresentante di questo ciclo, il valore corrente di j farà una scelta arbitraria; ovviamente, questo non sarà necessariamente l'elemento minimo nel ciclo sotto il tuo preferito order <.) Altrimenti, abbiamo A [ j ] =  (fully explored), il che significa che abbiamo scoperto un'orbita pre-esplorata che termina in un ciclo già contato; non incrementare c .
5. Per indicare che l'orbita che inizia da s è stata esplorata completamente, impostare j  ←  s .
   Mentre A [ j ] =  (partially explored), imposta A [ j ] ←  (fully explored)e imposta j  ←  f (j) .
6. Procedere con l'elemento successivo s  ∈  S .

Pertanto, ogni ciclo tra le orbite indotte da f verrà conteggiato una volta; e tutti gli elementi che registri come rappresentanti saranno elementi di cicli distinti. I requisiti di memoria sono 2 | S | per l'array A, O (log | S |) per il conteggio dei cicli e altre probabilità e fine.

Ogni elemento s  ∈  S verrà visitato almeno due volte: una volta quando il valore di A [ s ] viene modificato da (unexplored)a (partially explored), e una volta per la modifica a (fully explored). Il numero totale di volte che qualsiasi nodo viene rivisitato dopo essere stato (fully explored)è limitato dal numero di tentativi di trovare nuovi cicli che non riescono a farlo, che è al massimo | S | - derivante dalla iterazione ciclo principale attraverso tutti gli elementi di S . Quindi, possiamo aspettarci che questo processo coinvolga al massimo 3 | S | attraversamenti dei nodi, contando tutte le volte in cui i nodi vengono visitati o rivisitati.

Se si desidera tenere traccia degli elementi rappresentativi dei cicli e si desidera che siano gli elementi minimi, è possibile limitare il numero di visite ai nodi a 4 | S |, se aggiungi un ulteriore "giro attorno al ciclo" al punto 4 per trovare un rappresentante più piccolo di quello in cui chiudi il ciclo. (Se le orbite sotto f consistessero solo di cicli, questo lavoro extra potrebbe essere evitato, ma questo non è vero per le f arbitrarie .)

Se hai pochissimi cicli, ecco un algoritmo che utilizzerà meno spazio, ma impiegherà molto più tempo per terminare.

[Modifica.] La mia precedente analisi di runtime ha mancato il costo cruciale per determinare se i nodi che visitiamo sono tra quelli precedentemente campionati; questa risposta è stata in qualche modo rivista per correggere questo.

Abbiamo ancora una volta scorrere tutti gli elementi di S . Mentre esploriamo le orbite degli elementi s  ∈  S , campioniamo dai nodi che abbiamo visitato, per essere in grado di verificare se li incontriamo di nuovo. Manteniamo anche un elenco di campioni di "componenti" - unioni di orbite che terminano in un ciclo comune (e che sono quindi equivalenti ai cicli) - che sono stati precedentemente visitati.

Inizializzare un elenco vuoto di componenti, complist. Ogni componente è rappresentato da una raccolta di campioni da quel componente; manteniamo anche un albero di ricerca samplesche memorizza tutti quegli elementi che sono stati selezionati come campioni per un componente o altro. Sia G una sequenza di numeri interi fino a n , per cui l'appartenenza è efficacemente determinabile calcolando un predicato booleano; per esempio, i poteri di 2 o perfetti p ^th poteri per qualche intero p . Per ogni s  ∈  S , procedi come segue:

1. Se s è samplesattivo, vai al passaggio 5.
2. Inizializza un elenco vuoto cursample, un iteratore j  ← f ( s ) e un contatore t  ← 1.
3. Mentre j non è in samples:
   - Se t  ∈  G , inserire j in entrambi cursamplee samples.
   - Incremento t e set j  ←  f (j) .
4. Controlla se j è dentro cursample. In caso contrario, abbiamo riscontrato un componente esplorato in precedenza: controlliamo a quale componente j appartiene e inseriamo tutti gli elementi cursamplenell'elemento appropriato complistper aumentarlo. Altrimenti, abbiamo incontrato nuovamente un elemento dall'orbita attuale, il che significa che abbiamo attraversato un ciclo almeno una volta senza incontrare alcun rappresentante di cicli precedentemente scoperti: inseriamo cursample, come raccolta di campioni da un componente appena trovato, in complist.
5. Procedere con l'elemento successivo s  ∈  S .

Per n  = | S |, sia X (n) una funzione monotona crescente che descriva il numero atteso di cicli ( ad es.  X (n) =  n ^1/3 ), e sia Y (n) = y (n)  log ( n ) ∈ Ω ( X (n)  log ( n )) è una funzione crescente monotona che determina un target per l'utilizzo della memoria ( es.  Y (n) =  n ^1/2 ). Richiediamo y (n)  ∈ Ω ( X (n) ) perché ci vorrà almeno X (n)  log ( n ) spazio per memorizzare un campione da ciascun componente.

• Maggiore è il numero di elementi di un'orbita che campioniamo, maggiore è la probabilità che selezioniamo rapidamente un campione nel ciclo alla fine di un'orbita e quindi rileviamo rapidamente quel ciclo. Da un punto di vista asintotico, ha quindi senso ottenere tutti i campioni consentiti dai nostri limiti di memoria: possiamo anche impostare G per avere un elemento y (n) atteso inferiore a n .
  - Se la lunghezza massima di un'orbita in S dovrebbe essere L , potremmo lasciare che G sia il numero intero multiplo di L  /  y (n) .
  - Se non è prevista una lunghezza, possiamo semplicemente campionare una volta ogni n  / a  (n)elementi; questo è comunque un limite superiore agli intervalli tra i campioni.

• Se, cercando un nuovo componente, iniziamo a attraversare elementi di S che abbiamo precedentemente visitato (o da un nuovo componente scoperto o da uno vecchio il cui ciclo terminale è già stato trovato), ci vorrà al massimo n  /  y ( n) iterazioni per incontrare un elemento precedentemente campionato; questo è quindi un limite superiore per il numero di volte, per ogni tentativo di trovare un nuovo componente, attraversiamo nodi ridondanti. Poiché effettuiamo n tali tentativi, visiteremo quindi in modo ridondante elementi di S al massimo n ²  /  y (n) volte in totale.

• Il lavoro richiesto per verificare l'adesione samplesè O ( y (n)  log  y (n) ), che ripetiamo ad ogni visita: il costo cumulativo di questo controllo è O ( n ²  log  y (n) ). C'è anche il costo di aggiungere i campioni alle rispettive raccolte, che cumulativamente è O ( y (n)  log  y (n) ). Infine, ogni volta che incontriamo un componente precedentemente scoperto, dobbiamo dedicare fino a X (n)  log *  y (n) tempo per determinare quale componente abbiamo riscoperto; poiché ciò può accadere fino a n volte, il lavoro cumulativo coinvolto è limitato da n X (n)  log  y (n) .

Pertanto, il lavoro cumulativo svolto per verificare se i nodi che visitiamo sono tra i campioni dominano il tempo di esecuzione: questo costa O ( n ²  log  y (n) ). Quindi dovremmo rendere y (n) il più piccolo possibile, vale a dire O ( X (n) ).

Pertanto, si può enumerare il numero di cicli (che è uguale al numero di componenti che terminano in quei cicli) nello spazio O ( X (n)  log ( n )), prendendo O ( n ²  log  X (n) ) tempo per farlo, dove X (n) è il numero atteso di cicli.

$s$$s$$f(s)$