Encontre a mediana de uma lista de matrizes classificadas

8

Entrada: um conjunto de $\ell$ matrizes $A_i$ (de números).
Os elementos em cada matriz estão em ordem classificada, mas o conjunto de matrizes não é necessariamente classificado. As matrizes não são necessariamente do mesmo tamanho. O número total de elementos é $n$ .

Saída: O $k$ o menor elemento dentre todos os elementos da entrada.

Qual é o algoritmo mais eficiente para esse problema?

É possível, por exemplo, obter um tempo de execução de $O(\ell + \log n)$ ?

algorithms algorithm-analysis

— Joe
fonte

Há uma pergunta muito relacionada ao SO , com respostas insatisfatórias.

— 21413 Joe Joe

Todas as matrizes têm o mesmo comprimento?

— vonbrand

As matrizes não são necessariamente do mesmo tamanho. No entanto, também estou interessado em um caso especial em que os tamanhos são geométricos, ou seja, matriz

A_{i}

$A_i$ tem tamanho

n / 2^{i}

$n / 2^i$ , mas duvido que ajude no tempo de execução.

— 5303 Joe

4

Como você conseguiu

O (ℓ \log n)

$O(\ell\log n)$ ? Você pode ter

O (ℓ (\log n)^{2})

$O(\ell(\log n)^2)$ emulando o algoritmo "seleção rápida". Em cada fase, você escolhe um pivô e calcula quantos elementos estão abaixo dele, em

O (ℓ \log n)

$O(\ell\log n)$ . Então você remove os elementos do lado errado e repete. O processo termina após

\log n

$\log n$ iterações (na expectativa ou, na pior das hipóteses, se você escolher o pivô de maneira inteligente).

— Yuval Filmus

2

@ Joe Eu acho que você deve descrever seu algoritmo também. Seria muito interessante e pode fornecer um ponto de partida para melhores algoritmos, se correto. Se incorretas, as pessoas podem encontrar erros.

— Paresh

5

Você pode fazer isso em $O(l + k \text{ log } l)$ tempo e $O(l)$ espaço extra da seguinte maneira:

Crie uma pilha binária com uma entrada para cada uma das matrizes. A chave para entrada $i$ é o menor elemento da matriz $A_i$ . Isso leva $O(l)$ Tempo.
Selecione a menor entrada da pilha e remova-a $O(\text{log } l$ ) Tempo). Adicione essa entrada de volta ao heap usando a próxima menor entrada na matriz relevante como chave (novamente $O(\text{log } l)$ Tempo).
Faça o passo anterior $k$ vezes. O último elemento que você remove da pilha é sua resposta.

Se você substituir a pilha binária por uma pilha de Fibonacci, acho que isso fará com que você seja amortizado $O(l + k)$ tempo, mas, na prática, será mais lento que o monte binário, a menos que $l$ é enorme.

Eu suspeito que o limite de heap de Fibonacci seja ideal, porque intuitivamente você precisará inspecionar pelo menos $k$ elementos para encontrar o $k$ o menor, e você terá que inspecionar pelo menos um elemento de cada um dos $l$ matrizes, já que você não sabe como elas são classificadas, o que imediatamente fornece um limite inferior de $\Omega(\text{max}(k, l)) = \Omega(k + l)$ .

— Matt Lewis
fonte

3

Você não precisa inspecionar pelo menos

k

$k$ elementos desde que as matrizes são classificadas. Veja a solução no meu comentário, que dá

O (ℓ (\log n)^{2})

$O(\ell (\log n)^2)$ .

— Yuval Filmus

1

Você pode melhorar o pior caso de tempo de execução no modelo de RAM, pois pode implementar sua fila de prioridade para

n

$n$ elementos em

o (\log n)

$o(\log n)$ . Neste modelo, você pode realizar operações de inserção e exclusão

O (\sqrt{\log \log n})

$\mathcal{O}(\sqrt{\log \log n})$ e

O (1)

$\mathcal{O}(1)$ hora da operação findMin.

— Massimo Cafaro

1

Você tem certeza de que a pilha Fibonnaci suporta a operação correta? Eu acho que você está pensando em diminuir chave em um min-heap.

— Joe

Isso é basicamente o mesmo que a resposta de vonbrand, com a observação adicional de que você não precisa mesclar nenhum elemento após o quinto.

— Joe

Eu acredito que a pilha de Fibonacci permite diminuir ou aumentar uma chave

O (1)

$O(1)$ Tempo. Sim, esta é basicamente a mesma resposta, mas observando que você só precisa mesclar

k

$k$ elementos reduz seu tempo de execução de maneira justa.

— Matt Lewis

5

Aqui está um randomizado $O(\ell\log^2 n)$ algoritmo. Provavelmente, pode ser des randomizado usando o mesmo truque usado para des randomizar a seleção rápida usual.

Emulamos o algoritmo clássico de seleção rápida. Em cada fase, você escolhe um pivô e calcula quantos elementos estão abaixo dele, em $O(\ell\log n)$ , usando a pesquisa binária em cada lista. Então você remove os elementos do lado errado e repete. O processo termina após $\log n$ iterações na expectativa.

— Yuval Filmus
fonte

1

Isso parece ter sido resolvido pelo artigo Seleção e classificação generalizada (Versão Preliminar) de Frederickson e Johnson no STOC '80.

Eles fornecem limites superior e inferior de: $\Theta(\ell + \sum_{i=1}^\ell \log|A_i|)$ que acaba por ser $\ell \log n$ para a maioria das distribuições de tamanho de matriz.

O algoritmo real para atingir o limite superior é aparentemente apresentado em um artigo anterior: algoritmos ótimos para gerar informações quantílicas em X + Y e matrizes com colunas classificadas , Proc. 13ª Conferência Anual sobre Ciência da Informação e Sistemas, Universidade Johns Hopkins (1979) 47-52.

— Joe
fonte

0

A $\ell$ mesclagem leva tempo $\Theta(n \log \ell)$ (use uma maneira eficiente de representar uma fila de prioridade dos elementos principais em cada lista) e escolha a opção $k$ -ésimo elemento em tempo constante. Acho que isso é discutido em "Classificação e pesquisa" de Knuth para classificação. Obter o menor (ou maior) leva claramente $\Theta(\ell)$ , para uma matriz não classificada, é $O(n)$ IIRC.

Por favor, descreva seu algoritmo.

— vonbrand
fonte

1

É muito mais lento do que estou interessado. Você pode encontrar a mediana em

O (n)

$O(n)$ tempo apenas concatenando as listas e usando o algoritmo de seleção de tempo linear.

— 5303 Joe