Encontrando o pior caso de classificação de heap

Estou trabalhando no problema H no concurso ACM ICPC 2004-2005 do nordeste da Europa .

O problema é basicamente encontrar o pior caso que produz um número máximo de trocas no algoritmo (peneirar) para criar o heap.

• Entrada: O arquivo de entrada contém ( ).$n$$1 \le n \le 50{,}000$
• Saída: imprima a matriz que contém números inteiros diferentes de a , de forma que seja uma pilha, e ao convertê-la em uma matriz classificada, o número total de trocas em operações de peneiração é o máximo possível.$n$$1$$n$

Entrada de amostra: 6
Saída correspondente:6 5 3 2 4 1

E os resultados básicos:

[2, 1]   
[3, 2, 1]   
[4, 3, 1, 2] 
[5, 4, 3, 2, 1] 
[6, 5, 3, 4, 1, 2]

Dado o pior caso para $n$, podemos construir o pior caso para $n+1$ da seguinte maneira: fazemos um 'ciclo de troca' da seguinte maneira: $n+1$, coloque dentro $a[0]$e trocamos $a[0]$ com o elemento máximo de seus filhos, que é $a[1]$ ou $a[2]$, que trocamos novamente com o elemento máximo de seus filhos e assim por diante, até deixarmos o $n$heap de elemento; nesse ponto, colocamos esse último elemento no $n+1$-ª posição.

Um exemplo: o pior caso para $n=5$ é $[5, 4, 3, 2, 1]$. Trocamos 6, que cria a pilha$[\textbf{6}, \textbf{5}, 3, \textbf{4}, 1]$, após o que terminamos com 2, que inserimos no final: $[\textbf{6}, \textbf{5}, 3, \textbf{4}, 1, \textbf{2}]$.

O método acima funciona por indução: partimos do pior resultado para $n-1$ elementos e execute uma operação de peneiração inversa, maximizando o número de swaps que ele deve fazer ($\lfloor\log(n)\rfloor$swaps). Você não pode fazer mais trocas do que isso; portanto, você maximiza o número de trocas após a primeira operação de extração-min, após a qual você fica exatamente com o pior caso possível.$n-1$elementos para a próxima operação extrair-min. Isso implica que o número de swaps é realmente máximo.

Observe que este método fornece resultados diferentes dos obtidos:

[1]
[2, 1]
[3, 2, 1]
[4, 3, 1, 2]
[5, 4, 1, 3, 2]
[6, 5, 1, 4, 2, 3]
[7, 6, 1, 5, 2, 4, 3]
[8, 7, 1, 6, 2, 4, 3, 5]
[9, 8, 1, 7, 2, 4, 3, 6, 5]
[10, 9, 1, 8, 2, 4, 3, 7, 5 ,6]

No entanto, ambas as soluções estão corretas:

[5, 4, 1, 3, 2]
[2, 4, 1, 3| 5]
[4, 2, 1, 3| 5]
[4, 3, 1, 2| 5]
[2, 3, 1| 4, 5]
[3, 2, 1| 4, 5]

[5, 4, 3, 2, 1]
[1, 4, 3, 2| 5]
[4, 1, 3, 2| 5]
[4, 2, 3, 1| 5]
[1, 2, 3| 4, 5]
[3, 2, 1| 4, 5]

[6, 5, 1, 4, 2, 3]
[3, 5, 1, 4, 2| 6]
[5, 3, 1, 4, 2| 6]
[5, 4, 1, 3, 2| 6]
[2, 4, 1, 3| 5, 6]
[4, 2, 1, 3| 5, 6]
[4, 3, 1, 2| 5, 6]
[2, 3, 1| 4, 5, 6]
[3, 2, 1| 4, 5, 6]

[6, 5, 3, 4, 1, 2]
[2, 5, 3, 4, 1| 6]
[5, 2, 3, 4, 1| 6]
[5, 4, 3, 2, 1| 6]
[1, 4, 3, 2| 5, 6]
[4, 1, 3, 2| 5, 6]
[4, 2, 3, 1| 5, 6]
[1, 2, 3| 4, 5, 6]
[3, 2, 1| 4, 5, 6]