Um problema de pilha d-ária do CLRS

Fiquei confuso ao resolver o seguinte problema (perguntas 1 a 3).

Questão

Uma pilha d -ary é como uma pilha binária, mas (com uma possível exceção) nós não-folha têm filhos d em vez de dois filhos.

1. Como você representaria um d pilha -ary em uma matriz?

2. O que é a altura de um d montão -ary de n elementos em termos de n e d ?

3. Forneça uma implementação eficiente do EXTRACT-MAX em um h-max d -ary. Analise seu tempo de execução em termos de d e n .

4. _{Forneça uma implementação eficiente do INSERT em um d -ary max-heap. Analise seu tempo de execução em termos de d e n .}

5. _{Forneça uma implementação eficiente de INCREASE-KEY ( A , i , k ), que sinaliza um erro se k <A [i] = k e atualiza a estrutura de heap da matriz d -ary adequadamente. Analise seu tempo de execução em termos de d e n .}

Minha solução

1. Dê uma matriz$A[a_1 .. a_n]$

   $\qquad \begin{align} \text{root} &: a_1\\ \text{level 1} &: a_{2} \dots a_{2+d-1}\\ \text{level 2} &: a_{2+d} \dots a_{2+d+d^2-1}\\ &\vdots\\ \text{level k} &: a_{2+\sum\limits_{i=1}^{k-1}d^i} \dots a_{2+\sum\limits_{i=1}^{k}d^i-1} \end{align}$

   → Minha notação parece um pouco sofisticada. Existe algum outro mais simples?

2. Deixe h denota a altura da pilha d- ar.

   Suponha que a pilha seja uma árvore d- ar completa

   $$1+d+d^2+..+d^h=n\\ \dfrac{d^{h+1}-1}{d-1}=n\\ h=log_d[n{d-1}+1] - 1$$

3. Esta é a minha implementação:

   EXTRACT-MAX(A)
   1  if A.heapsize < 1
   2      error "heap underflow"
   3  max = A[1]
   4  A[1] = A[A.heapsize]
   5  A.heap-size = A.heap-size - 1
   6  MAX-HEAPIFY(A, 1)
   7  return max
   
   MAX-HEAPIFY(A, i)
   1  assign depthk-children to AUX[1..d]
   2  for k=1 to d
   3      compare A[i] with AUX[k]
   4      if A[i] <= AUX[k]
   5          exchange A[i] with AUX[k]
   6          k = largest
   7  assign AUX[1..d] back to A[depthk-children]
   8  if largest != i
   9      MAX-HEAPIFY(A, (2+(1+d+d^2+..+d^{k-1})+(largest-1) )
   

   • O tempo de execução de MAX-HEAPIFY:

     c

     $$T_M = d(c_8*d + (c_9+..+c_13)*d +c_14*d)$$ que indica o custo da i- ésima linha acima.$c_i$

   • EXTRATO-MÁX:

     $$T_E = (c_1+..+c_7) + T_M \leq C*d*h\\ = C*d*(log_d[n(d-1)+1] - 1)\\ = O(dlog_d[n(d-1)])$$

   → Esta é uma solução eficiente? Ou há algo errado na minha solução?

1. Sua solução é válida e segue a definição de pilha d -ary. Mas, como você apontou, sua notação é um pouco sofisticada.

   Você pode usar essas duas funções a seguir para recuperar o pai do i- ésimo elemento e j- ésimo filho do i- ésimo elemento.

   $\text{d-ary-parent}({\it i}) \\ \ \ \ \ {\bf return}\ \lfloor (i-2)/d + 1 \rfloor$

   $\text{d-ary-child}(i, j) \\ \ \ \ \ {\bf return}\ d(i-1)+j+1$

   Obviamente . Você pode verificar essas funções verificando se d-ário-pai ( d-ário-filho ( i , j ) ) = $1 \le j \le d$$\text{d-ary-parent}(\text{d-ary-child}(i,j)) = i$

   Também é fácil ver que a pilha binária é um tipo especial de pilha -ary onde d = 2 , se você substituir d por 2 , verá que elas correspondem às funções PARENT, LEFT e RIGHT mencionadas no livro.$d$$d=2$$d$$2$

2. Se entendi sua resposta corretamente, você usa uma progressão geométrica . No seu caso, você começa , que é obviamente log d ( $h = log_d(n\,d-1+1) - 1$ , que de fato é uma solução válida e correta. Mas apenas para lidar com flutuações constantes, você pode querer escrever Θ ( log d ( n ) ) .$\log_d(n\,d) - 1 = \log_d(n) + \log_d(d) - 1 = \log_d(n) + 1 - 1 = \log_d(n)$$\Theta(\log_d(n))$

   A razão para isto é que alguns montes não pode ser equilibrada, assim que seu caminho mais longo e caminho shorthest migt variam de acordo com alguma constante , usando Θ notação que eliminar este problema.$c$$\Theta$

3. Você não precisa reimplementar o procedimento fornecido no livro didático, mas deve alterá-lo um pouco, por exemplo, atribuindo todos os filhos à tabela usando as funções d-ário-pai e d-ário-filho .$AUX$$\text{d-ary-parent}$$\text{d-ary-child}$

   Como o não foi alterado, depende do tempo de execução de MAX-HEAPIFY . Em sua análise, agora você deve usar o pior caso, proporcional à altura e ao número de filhos que cada nó deve examinar (que é no máximo d ). Mais uma vez, sua análise é muito precisa. No final, você obtém O ( d log d ( n ( d - 1 ) ) ) , que pode ser transformado em:$\text{EXTRACT-MAX}$$\text{MAX-HEAPIFY}$$O(d\ \log_d(n(d-1)))$

   $O(d\ \log_d(n(d-1))) = O(d(\log_d(n) + \log(d-1))) = O(d\ log_d(n) + d\ \log_d(d-1))$

   Por razões práticas, sempre podemos assumir que , para que possamos perder a parte d log d ( d - 1 ) da notação O , então obteremos O ( d log d ( n ) ) . O que também é uma solução válida. Mas não é de surpreender que você também possa analisar o tempo de execução das funções usando o teorema mestre , que mostrará que MAX-HEAPIFY não é apenas O, mas Θ .$d \ll n$$d \log_d(d-1)$$O(d\log_d(n))$$\text{MAX-HEAPIFY}$$O$$\Theta$

4. O livro CLRS já fornece o procedimento INSERT. Que se parece com isso:

   $\text{INSERT}(A, key)\\ \ \ \ \ A.heap\_size = A.heap\_size + 1 \\ \ \ \ \ A[A.heap\_size] = -\infty\\ \ \ \ \ \text{INCREASE-KEY}(A, A.heap\_size, key)$

   Pode ser facilmente comprovado, mas o senso comum exige que a complexidade do tempo seja . É porque o heap pode ser atravessado até a raiz.$O(\log_d(n))$

5. Assim como INSERT, INCREASE-KEY também é definido no livro como:

   $\text{INCREASE-KEY}(A, i, key)\\ \ \ \ \ {\bf if}\ key < A[i]\\ \ \ \ \ \ \ \ \ {\bf error} \text{"new key is smaller then current"}\\ \ \ \ \ A[i] = key\\ \ \ \ \ {\bf while}\ i > 1\ and\ A[i] > A[\text{d-ary-parent}(i)]\\ \ \ \ \ \ \ \ \ A[i] \leftrightarrow A[\text{d-ary-parent(i)}]\\ \ \ \ \ \ \ \ \ i = \text{d-ary-parent(i)}$

   $O(\log_d(n))$

A resposta para a segunda questão é h = log _d (n (d-1) + 1) - 1 Então, h = log _d (nd - n + 1) - 1