배열의 각 요소에 대해 더 작은 요소 수를 효율적으로 찾기

이 문제에 갇혀 있습니다.

주어진 배열 $A$ 첫 번째 $n$ 무작위로 순열 된 자연수, 배열 $B$ 다음과 같이 구성됩니다 $B(k)$ 요소의 개수입니다 $A(1)$ 에 $A(k-1)$ 보다 작은 $A(k)$.

i) 주어진 $A$ 당신은 찾을 수 있나요 $B$ 에 $O(n)$시각?
ii) 주어진$B$ 당신은 찾을 수 있나요 $A$ 에 $O(n)$ 시각?

여기, $B(1) = 0$. 구체적인 예를 들면 다음과 같습니다.

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

누구든지 나를 도울 수 있습니까? 감사.

결정을위한 순진한 알고리즘 $B$ ...에서 $A$:

에 대한 $k=1,\dots,n$의 가치를 결정 $B(k)$ 각각을 비교함으로써 $A(i)$ 에 $A(k)$ ...에 대한 $i=1,\dots,k$ 만족하는 사람들을 세고 $A(i)<A(k)$.

이 알고리즘은 $A(1)$ 다른 사람들에게$n-1$ 타임스), $A(2)$ 에 $n-2$ 다른 것, 등 총 비교 횟수는 $\frac{(n-1)(n-2)}{2}$. 그러나 그것은 우리가 할 수있는 최선이 아닙니다. 예를 들어$B(n)$비교할 필요가 없습니다. $B(n)=A(n)-1$처음 이기 때문에 $n$ 자연수이며 (순열에 관계없이) $n-1$낮은 자연수가있을 것입니다. 이건 어떤가요$B(n-1)$? 확인하는 대신$A(1)$ ...을 통하여 $A(n-2)$, 우리는 단지 확인할 수 있었다 $A(n)$. 그건:

에 대한 $k=1, \dots,\frac{n}{2}$위의 알고리즘을 사용하십시오. ...에 대한 $k=\frac{n}{2},\dots,n$ 역 알고리즘을 사용하십시오 : 결정 $B(k)$ 처음에 설정하여 $A(n)-1$ 그런 다음 빼기 $1$ for each entry $A(i)$ for $i=k+1,\dots,n$ that is less than $A(k)$.

This would take $2\times\frac{(\frac{n}{2}-1) (\frac{n}{2}-2)}{2}=\frac{(n-2)(n-4)}{4}$ steps, which is still $O(n^2)$. Note also that in constructing $A$ from $B$, if $B(n)=A(n)-1$ then $A(n)=B(n)+1$.

But now for more finesse. If we’re allowed some additional space or sort in-place, we can sort the numbers as we’re comparing them. For example:

$$\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}$$

Instead of checking all of them (or checking them in order), we could use binary search to determine each $B(k)$. However, the sorting still takes time $O(n\log n)$.

Rather than determining each $B(k)$ one at a time, we can be forward looking and only go through each number in $A$ once! But we'll use $n$ space:

$$\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}$$

We could save even more time by not updating those that have already been determined (that is, there is no point in updating $8$ after the first step), but in the worst case, we still have to update $\frac{(n)(n+2)}{2}$ times

both I and II are solvable using #next_greater_element that i explained here. but its a little harder than just the problem but before solution you need to learn next greater element:

1. consider we have a vector for every element of $A$ name it $S_i$ for element $i$. now once run the next greater algorithm starting from right to left but except setting element $i$ in $A$ its next greater element index , push in $S_i$ the elements that $i$ is their next greater element.then iterate over the array left to right and then $B[i]=\sum_{j=0}^x (S_i[j]+1)$ where $x$ is the size of vector $S_i$.and its $\Theta(n)$ because each the next greater algorithm is $\Theta(n)$ and also iterating is $\Theta(n)$

second part is also similar noting that we can get the value of the rightest element in $O(1)$ EDIT:my solution is wrong it seems that it dont have any$o(n)$ solution