Trovare il numero di elementi più piccoli per ciascun elemento in un array in modo efficiente

Sono bloccato su questo problema:

Dato un array $A$ dei primi $n$ numeri naturali casualmente permutati, viene costruito un array $B$ , in modo tale che $B(k)$ è il numero di elementi da $A(1)$ ad $A(k-1)$ che sono più piccoli di $A(k)$ .

i) Dato $A$ puoi trovare $B$ in $O(n)$ tempo?
ii) Dato $B$ riesci a trovare $A$ in $O(n)$ tempo?

Qui, $B(1) = 0$ . Per un esempio concreto:

| \begin{matrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 & 4 & 4 \end{matrix} |

$\begin{vmatrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 & 4 & 4 \\ \end{vmatrix}$

Qualcuno può aiutarmi? Grazie.

algorithms arrays permutations

— dannato
fonte

Ho trovato questo: codifiche di permutazione computazionale che fornisce algoritmi

per questi problemi. Almeno penso che siano gli stessi problemi.

O (n \log n)

$\mathcal O(n \log n)$

— Realz Slaw,

@Merbs Questo suggerimento che hai dato significa che hai una soluzione?

— AJed,

@AJed, significa che ho un algoritmo, anche se ci vuole

per l'algoritmo semplice senza spazio e

se ci è concesso spazio. Al momento, mi sto proponendo che non sia possibile in

ed entrambi sono lo stesso algoritmo.

O (n^{2})

$O(n^2)$

O (n \log n)

$O(n\log n)$

O (n)

$O(n)$

— Merbs,

@Merbs. Sento che il tuo suggerimento può portare sulla strada giusta. Ho anche una soluzione (seguendo il tuo suggerimento). Immagino che ci sia un trucco nell'analisi che lo porta ad .. Penso che il trucco sia la conoscenza che va solo da 1: .

O (n)

$O(n)$

A

$A$

n

$n$

— AJed,

Questo documento fornisce anche un algoritmo . Sei sicuro che esista un algoritmo per questo?

O (n \log n)

$\mathcal O(n \log n)$

O (n)

$\mathcal O(n)$

— Realz Slaw,

Risposte:

L'algoritmo ingenuo per determinare da : $B$ $A$

Per , determinare il valore di confrontando ogni con per e contando quelli che soddisfano . $k=1,\dots,n$ $B(k)$ $A(i)$ $A(k)$ $i=1,\dots,k$ $A(i)<A(k)$

Questo algoritmo confronta con tutti gli altri ( volte), con altri, ecc. Quindi il numero totale di confronti è $A(1)$ $n-1$ $A(2)$ $n-2$ . Ma non è il massimo che possiamo fare. Ad esempio, guardando, non dobbiamo fare paragoni! perché sono ipriminumeri naturali, ed è garantito (indipendentemente dalla permutazione) checi saranno i numeri naturali inferiori. Che dire di? Invece di controllare daa $\frac{(n-1)(n-2)}{2}$ $B(n)$ $B(n)=A(n)-1$ $n$ $n-1$ $B(n-1)$ $A(1)$ , potremmo semplicemente controllare . Questo è: $A(n-2)$ $A(n)$

Per , utilizzare l'algoritmo sopra; per $k=1, \dots,\frac{n}{2}$ usa l'algoritmo inverso: determinaimpostandolo inizialmente sue quindi sottraendoper ogni voceperche è minore di. $k=\frac{n}{2},\dots,n$ $B(k)$ $A(n)-1$ $1$ $A(i)$ $i=k+1,\dots,n$ $A(k)$

Ciò richiederebbe passaggi, che è ancora. Nota anche che nel costruireda, seallora. $2\times\frac{(\frac{n}{2}-1) (\frac{n}{2}-2)}{2}=\frac{(n-2)(n-4)}{4}$ $O(n^2)$ $A$ $B$ $B(n)=A(n)-1$ $A(n)=B(n)+1$

Ma ora per più finezza. Se ci viene concesso dello spazio aggiuntivo o l'ordinamento sul posto, possiamo ordinare i numeri mentre li stiamo confrontando. Ad esempio:

| \begin{matrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ S & 9 & 8 & 7 & 4 & 3 & 2 & 1 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 \end{matrix} |

$\begin{vmatrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ S & 9 & 8 & 7 & 4 & 3 & 2 & 1 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 & & \\ \end{vmatrix}$

Invece di controllarli tutti (o controllarli in ordine), potremmo usare la ricerca binaria per determinare ogni . Tuttavia, l'ordinamento richiede ancora tempo . $B(k)$ $O(n\log n)$

— Merbs
fonte

Questa era solo la mia prima idea; anche se mi rendo conto che il problema è più interessante di quanto inizialmente gli abbia dato credito. E non ho ancora avuto l'opportunità di leggere i risultati di Realz Slaw, quindi l'algoritmo potrebbe essere spento.

— Merbs,

Invece di determinare ogni uno alla volta, possiamo guardare avanti e passare attraverso ogni numero in una volta ! Ma useremo spazio: $B(k)$ $A$ $n$

| \begin{matrix} A & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & B \\ 8 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ 4 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 1 & 2 & 0 \\ 3 & 0 & 0 & 0 & 1 & 2 & 2 & 2 & 2 & 3 & 0 \\ 1 & 0 & 1 & 1 & 2 & 3 & 3 & 3 & 3 & 4 & 0 \\ 7 & 0 & 1 & 1 & 2 & 3 & 3 & 3 & 4 & 5 & 3 \\ 2 & 0 & 1 & 2 & 3 & 4 & 4 & 4 & 5 & 6 & 1 \\ 9 & 0 & 1 & 2 & 3 & 4 & 4 & 4 & 5 & 6 & 6 \\ 6 & 0 & 1 & 2 & 3 & 4 & 4 & 5 & 6 & 7 & 4 \\ 5 & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 4 \end{matrix} |

$\begin{vmatrix} A & & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & & B \\ 8 & & 0 & 0 & 0 & 0 & 0 & 0 & 0 & \color{red}{0} & 1 & & 0\\ 4 & & 0 & 0 & 0 & \color{red}{0} & 1 & 1 & 1 & 1 & 2 & & 0\\ 3 & & 0 & 0 & \color{red}{0} & 1 & 2 & 2 & 2 & 2 & 3 & & 0\\ 1 & & \color{red}{0} & 1 & 1 & 2 & 3 & 3 & 3 & 3 & 4 & & 0\\ 7 & & 0 & 1 & 1 & 2 & 3 & 3 & \color{red}{3} & 4 & 5 & & 3\\ 2 & & 0 & \color{red}{1} & 2 & 3 & 4 & 4 & 4 & 5 & 6 & & 1\\ 9 & & 0 & 1 & 2 & 3 & 4 & 4 & 4 & 5 & \color{red}{6} & & 6\\ 6 & & 0 & 1 & 2 & 3 & 4 & \color{red}{4} & 5 & 6 & 7 & & 4\\ 5 & & 0 & 1 & 2 & 3 & \color{red}{4} & 5 & 6 & 7 & 8 & & 4\\ \end{vmatrix}$

Potremmo risparmiare ancora più tempo non aggiornando quelli che sono già stati determinati (vale a dire, non ha senso aggiornare dopo il primo passaggio), ma nel caso peggiore, dobbiamo ancora aggiornare $8$ volte $\frac{(n)(n+2)}{2}$

— Merbs
fonte

sia I che II sono risolvibili usando #next_greater_element che ho spiegato qui . ma è un po 'più difficile del semplice problema, ma prima della soluzione devi imparare il prossimo elemento maggiore:

considera che abbiamo un vettore per ogni elemento di name it per element . ora, una volta eseguito l'algoritmo più prossimo partendo da destra a sinistra ma tranne modificando elemento in sua prossima maggiore indice di elemento, spingere elementi che è la loro successiva maggiore element.then iterate sulla matrice sinistra a destra e poi dove $A$ $S_i$ $i$ $i$ $A$ $S_i$ $i$ $B[i]=\sum_{j=0}^x (S_i[j]+1)$ $x$ $S_i$ $\Theta(n)$ $\Theta(n)$ $\Theta(n)$

$O(1)$ $o(n)$

— Ali.Mollahoseini
fonte