Risolvere la relazione di ricorrenza con due chiamate ricorsive


10

Sto studiando il caso peggiore di quicksort a condizione che non farà mai una partizione molto sbilanciata per le diverse definizioni di molto .

Per fare questo mi chiedo quale sarebbe il runtime nel caso in cui Quicksort capiti sempre di partizionare in una frazione tale che elementi sono nella partizione sinistra e sono nella partizione destra (lasciando elemento, il perno, al centro).T(n,p)0<p12p(n1)(1p)(n1)1

Non dovrebbe essere difficile vedere che fornisce un limite superiore per il caso peggiore in cui è la partizione consentita massimamente sbilanciata, poiché qualsiasi partizione con frazione sarà più bilanciata e avrà un tempo di esecuzione minore, e qualsiasi frazione non è consentita.T(n,p)p>p<p

È ovvio che è il caso migliore e è il caso peggiore di quicksort. Entrambi hanno facili relazioni di ricorrenza che si trovano in qualsiasi risorsa educativa. Ma non ho idea di come studiare in generale. La relazione ovvia sarebbe:T(n,12)T(n,0)T(n,p)

T(n,p)=n+T(p(n1),p)+T((1p)(n1),p)

Qui mi blocco. Ho provato a cercare in giro, ma tutta la letteratura che ho capito sugli algoritmi di divisione e conquista ha preso letteralmente il "divario" e ha "ingannato" l'analisi usando il fatto che le partizioni hanno sempre le stesse dimensioni, unendo i termini in una volta costante.

Non so come gestire due chiamate ricorsive e non so se sia sicuro rimuovere l'arrotondamento. È possibile risolvere analiticamente e, se sì, come?

PS: Non mi interessano gli asintotici (che è facile mostrare per qualsiasi costante ). Sono interessato a quanto lo slowsort più lento diventa man mano che si riduce , ad esempio mi interessa il rapporto .p p T ( n , 0,25 )Θ(nlogn)ppT(n,0.25)T(n,0.5)

PPS: Come studente universitario, mi scuso se ho fatto cose ovvie troppo lunghe o non spiegate non banali. E anche se non so se sia guardato in basso qui tanto quanto gli altri siti SE, noterò che questo è un interesse personale, non compiti a casa.

Risposte:


9

Come dici tu, il teorema di Akra – Bazzi mostra che la soluzione alla ricorrenza è per tutti i . Tuttavia, ciò non rivela la natura della dipendenza da . Per determinare quest'ultimo, possiamo usare un approccio ad albero di ricorsione.O ( n log n ) p ( 0 , 1 ) pT(n,p)O(nlogn)p(0,1)p

Alla radice dell'albero di ricorsione si trova l'intervallo . I suoi due figli sono gli intervalli e , la cui lunghezza totale è di nuovo . Ognuno di questi nodi ha due figli (supponendo che sia abbastanza grande) e così via. Per semplicità ignoriamo gli errori di arrotondamento, ovvero supponiamo che sia un numero intero; questo è solo un tecnicismo e non me ne preoccuperei. Interrompiamo il processo ogni volta che un nodo ha una lunghezza al massimo . La complessità dell'algoritmo è proporzionale alla lunghezza totale degli intervalli nella struttura. Quando , le foglie{ 1 , ... , p n } { p n + 1 , ... , n } n n p n 1 p 1 / 2{1,n}{1,,pn}{pn+1,,n}nnpn1p1/2 (nodi in cui interrompiamo il processo) hanno profondità diverse e ciò rende più difficile determinare la complessità complessiva.

Possiamo ottenere un semplice limite superiore notando che l'albero ha al massimo livelli : ogni nodo è almeno un fattore più piccolo del suo genitore. Proprio come nell'analisi per , la lunghezza totale degli intervalli a qualsiasi livello è al massimo , e otteniamo un limite superiore di sul tempo di esecuzione. Poiché e per piccola , possiamo scrivere questo come .1 - p p = 1 / 2 n O ( n log 1 - p ( 1 / n ) ) log 1 - p ( 1 / n ) = log n / log ( 1 - p ) - 1 registro ( 1 - p ) - 1log1p(1/n)1pp=1/2nO(nlog1p(1/n))log1p(1/n)=logn/log(1p)1p O ( n log n / p )log(1p)1=log(1p)=p±O(p2)pO(nlogn/p)

Ecco un calcolo più accurato. Considera il livello . Supponiamo di non interrompere il processo al raggiungimento di un piccolo intervallo. Possiamo generare un vertice casuale prendendo passi, in ognuno dei quali andiamo a sinistra (diciamo) con probabilità e a destra (diciamo) con probabilità . Ogni volta che facciamo un passo a sinistra il registro della lunghezza dell'intervallo diminuisce di , e ogni volta che facciamo un passo a destra diminuisce di . Un vertice si trova nell'albero reale del registro della lunghezza diminuita al massimo . Il peso totale degli intervalli al livellotp 1 - p - log p - log ( 1 - p ) log n t log n D - log p p - log ( 1 - p ) 1 - p X 1 , , X tD t Pr [ X 1 + + X tlog n ] ttp1plogplog(1p)logntdell'albero è esattamente la probabilità che un vertice generato secondo questo processo corrisponda ad una diminuzione al massimo . Cioè, se è la distribuzione che è uguale a con probabilità e a con probabilità e sono indipendenti, quindi il il peso totale del livello è . Per super costante , la variabile casuale è approssimativamente normalmente distribuita con media varianza lineare inlognDlogpplog(1p)1pX1,,XtDtPr[X1++Xtlogn]t [ - p log p - ( 1 - p ) log ( 1 - p ) ] t t t [ - p log p - ( 1 - p ) log ( 1 - p ) ] t ( log n ) / 2 1 t [ - p logX1++Xt[plogp(1p)log(1p)]tt, quindi per soddisfacente , diciamo, la probabilità sarà molto vicina a , mentre per soddisfacente , diciamo, sarà molto vicino allo zero. Definendo (nota come funzione di entropia binaria), concludiamo che il tempo di esecuzione è (uniforme in , come da ). Come abbiamo , e quindi la nostra stima precedente non era stretta.t[plogp(1p)log(1p)]t(logn)/21th ( p ) = - p log p - ( 1 - p ) log ( 1 - p ) Θ ( n log n / h ( p ) ) p n p 0 h ([plogp(1p)log(1p)]t2lognh(p)=plogp(1p)log(1p)Θ(nlogn/h(p))pnp0h(p)plogp

Un altro modo di guardare la stessa analisi è avere una sequenza infinita di variabili casuali indipendenti come in precedenza e definire un tempo di arresto per essere la prima volta tale che . Il tempo di esecuzione è quindi proporzionale a . Il teorema di rinnovamento elementare afferma quindi che , sottintendendo che il la dimensione totale degli intervalli è uguale a . Più precisamente, per ogni costante la dimensione totale degli intervalli è , doveT t X 1 + + X tlog n n E [ T ] lim n E [ T ] / log n = 1 / E [ D ] = 1 / h ( p ) ( 1 + o ( 1 ) ) n log nX1,X2,TtX1++XtlognnE[T]limnE[T]/logn=1/E[D]=1/h(p)p ( 1 + α p ( n ) ) n log n / h ( p ) α p ( n ) = o ( n ) log n n α p ( n ) = O ( n - C p ) p ( δ , 1 - δ ) δ > 0(1+o(1))nlogn/h(p)p(1+αp(n))nlogn/h(p)αp(n)=o(n) . La convergenza nel teorema di rinnovo elementare è esponenziale nel parametro time - nel nostro caso - quindi dovrebbe essere polinomiale in , cioè . La convergenza è probabilmente anche uniforme per per qualsiasi .lognnαp(n)=O(nCp)p(δ,1δ)δ>0


Riassumendo, la lunghezza totale degli intervalli nell'albero di ricorsione, che è proporzionale al tempo di esecuzione, è della seguente forma per ogni : dove e vengono portati sulla stessa base e è una funzione che dipende da e tende a con .T ( n , p ) = ( 1 + o ( 1 ) ) n log nplognh(p)=-plogp-(1-p)log(1-p)o(1)p0n

T(n,p)=(1+o(1))nlognh(p),
lognh(p)=plogp(1p)log(1p)o(1)p0n

Inoltre, è probabilmente vero che per qualsiasi e qualsiasi è vero che la lunghezza totale degli intervalli è della forma dove e la grande costante O nascosta dipendono solo da . In particolare, dovrebbe essere il caso che per tutte le costanti , e la convergenza è polinomialmente veloce.δ>0p(δ,1δ)

T(n,p)=(1+O(nCδ))nlognh(p),
Cδ>0δp1,p2
limnT(n,p1)T(n,p2)=h(p2)h(p1),

Grazie per la tua rapida risposta Yuval. Sono un po 'confuso dal fatto che tu abbia usato nel tuo riassunto. è una costante e ciò non significa che sia irrilevante in ? Ho deciso di scrivere un piccolo programma di test , che ha mostrato che per confrontando tra il metodo analitico e uno computazionale ha dato un errore di 0,03. Sembra piuttosto grande, o è prevedibile? Θh(p)Θn=100000000000000T(n,0.1)/T(n,0.5)
orlp

La costante in è uniforme in . Più precisamente, per alcune costanti è il caso che per ogni esista tale che per , . Probabilmente puoi ottenere un'istruzione ancora più forte della forma per ogni fissa , dove la piccola o è rispetto a ( ma potrebbe dipendere da ); non dovrebbe dipendere da . Θpc,CpNpnNpcnlogn/h(p)T(n,p)Cnlogn/h(p)p n p C pT(n,p)=(1+o(1))Cnlogn/h(p)pnpCp
Yuval Filmus,

La convergenza al limite dipende da , quindi potrebbe essere necessario che sia grande per ottenere una buona approssimazione. D'altra parte, un errore relativo di 0,03 non sembra così grande. Puoi provare a correggere e tracciare il tempo di esecuzione in funzione di , confrontandolo con . log n n p 1 / h ( p )lognlognnp1/h(p)
Yuval Filmus,

Oh mi dispiace, non intendevo un errore relativo di 0,03, ma assoluto (2,13222 vs 2,10339). Tracciare in funzione di , rispetto a dato una differenza relativa del 4%, con essendo il 96% di . p 1 / h ( p ) T ( 10 11 , 0,05 ) h ( 0,05 ) T ( 10 11 , 0,4 ) h ( 0,4 )T(n,p)p1/h(p)T(1011,0.05)h(0.05)T(1011,0.4)h(0.4)
orlp

1
La super-costante è una funzione che tende all'infinito rispetto alla variabile rilevante (in questo caso ). È lo stesso di . ω ( 1 )nω(1)
Yuval Filmus,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.