Pilha divisível

O que se sabe sobre estruturas de dados que podem manter uma sequência de itens sujeitos às duas operações a seguir?

Pressione (x): adicione x ao final da sequência e retorne um identificador para sua posição na sequência
Extrair (S): dado um conjunto não ordenado de identificadores, remova os itens nessas posições da sequência e retorne uma lista dos itens removidos em ordem de sequência

Se desejar, você pode pensar nisso como uma pilha ou fila com uma operação de divisão que o divide em duas pilhas: a operação de extração pode ser usada para implementar uma operação de pop ou desenfileiramento, e a sequência extraída de itens também pode ser colocada de volta para uma pilha ou fila diferente.

O que eu já sei: é possível manter a sequência como uma lista duplamente vinculada, onde cada identificador é apenas um ponteiro para um nó da lista vinculada, e cada nó também armazena um número de posição que permite comparações rápidas entre as posições de dois elementos não relacionados na sequência. Não é difícil atualizar os números de posição à medida que a estrutura de dados progride, para que todos sejam números inteiros positivos com o valor máximo , onde é o número atual de itens na lista. Com essa estrutura de dados, a única parte difícil de uma operação de extração é classificar os itens extraídos pelos números de posição. Uma extração de itens leva $O(n)$ $n$ $k$ $O(k\sqrt{\log\log k})$ tempo aleatório esperado usando o algoritmo de classificação inteira de Han e Thorup do FOCS 2002, por exemplo, e uma operação push leva tempo constante.

O que eu não sei: é possível lidar com extração no tempo e empurrar no tempo constante? Existe literatura sobre esse problema? É tão difícil quanto a classificação inteira? $O(k)$

Motivação: esta é a etapa básica necessária para solicitar os itens no algoritmo de programação Coffman-Graham, que também possui aplicações no desenho de gráficos. A parte difícil de Coffman-Graham é uma ordem topológica lexicográfica. Isso pode ser feito mantendo, para cada indegree diferente, uma sequência dos vértices com aquele indegree no subgráfico induzido pelos vértices restantes. Em seguida, remova repetidamente o primeiro vértice da sequência de vértices com zero nulo e adicione-o à ordem topológica; extraia os vizinhos de dos graus aos quais pertenciam anteriormente e empurre-os para a sequência pelo próximo grau menor. Então um $v$ $v$ $O(k)$ o tempo para as operações de extração nessa estrutura de dados levaria a uma implementação linear em tempo do algoritmo de Coffman-Graham.

Desde que originalmente perguntei isso, encontrei um artigo de Sethi de 1976 que permite que o algoritmo Coffman – Graham seja implementado em tempo linear e o inclua no meu artigo da Wikipedia sobre o algoritmo Coffman – Graham , de modo que a motivação original é menos significativa. Ainda estou curioso para saber qual é a resposta.

ds.data-structures

— David Eppstein
fonte

Se as inserções ocorrerem apenas no final da sequência, você poderá manter uma lista com dois links e uma tabela de hash das posições dos itens. Inserção: O (1) amortizado (basta manter um ponteiro para o último item). Extração de k itens: O (k) amortizado (para cada elemento de S, obtenha o ponteiro e remova-o da tabela de hash, obtenha e remova itens da lista e adicione-os ao resultado da extração).

— Marzio De Biasi

Não é a extração dos itens da lista que leva o tempo, está reorganizando-os da ordem não classificada do argumento para Extrair na ordem de sequência correta.

— David Eppstein

Eu acho que isso é pelo menos tão difícil quanto classificar um conjunto de números inteiros com "conselhos aleatórios" do tamanho polinomial em . Por conselho aleatório, quero dizer que para qualquer existe uma distribuição fixa (dependendo apenas de ) sobre cadeias de tamanho poli ( ) e nosso algoritmo (modelado por uma máquina RAM) recebe acesso aleatório a uma única amostra de . é a estrutura de dados (randomizada) depois de pressionar $S \subseteq [n]$ $n$ $n$ ${\cal D}_n$ $n$ $n$ ${\cal D}_n$ ${\cal D}_n$ $[n]$ $O(1)$

$S \subseteq [n]$ $S$ $S$ $O(1)$

Portanto, a mensagem é que, a menos que algumas informações secundárias "livres", que dependem apenas do limite superior dos números inteiros, possam facilitar a classificação por números inteiros, a extração é tão difícil quanto a classificação por números inteiros.

Isso implica uma relação entre os dois problemas sem o modelo estranho? Essa noção de conselho aleatório é algo conhecido? É como um protocolo MA, mas a mensagem de Merlin não depende da entrada e nos preocupamos com o tempo de execução de Arthur.

— Sasho Nikolov
fonte

[n]

$[n]$

D_{n}

$\mathcal{D}_n$

Ω (n)

$\Omega(n)$

D_{n}

$\mathcal{D}_n$

Ω (n)

$\Omega(n)$

k

$k$

[n]

$[n]$

O (n + k)

$O(n+k)$

O (k)

$O(k)$

— Dave

Ω (n)

$\Omega(n)$

D_{n}

${\cal D}_n$

k

$k$

O (k)

$O(k)$

D_{n}

${\cal D}_n$

Aqui está a razão pela qual não acho esta resposta inteiramente convincente. Se você possui apenas um conjunto S de números inteiros que deseja classificar, tudo é tempo linear (basta contar a classificação em O (n + k)). Mas se você estiver tentando usar essa estrutura de dados para simular uma sequência de muitas classificações pequenas (para que a classificação da contagem não seja boa o suficiente), apenas o primeiro desses tipos pequenos ficará completamente irrestrito: depois disso, você removeu alguns dos elementos de [n], portanto, cada sequência que você classificar deve ser separada das anteriores. Portanto, parece difícil fazer uma redução no trabalho de classificação.

— David Eppstein

ℓ

$\ell$

ℓ

$\ell$

O (k)

$O(k)$

O (n + k)

$O(n+k)$

Ω (n)

$\Omega(n)$

D_{n}

$\mathcal{D}_n$

O (k)

$O(k)$