A singularidade do elemento pode ser resolvida no tempo linear determinístico?

9

Considere o seguinte problema:

Entrada : lista de números inteiros $X,Y$

Objetivo : determine se existe um número inteiro nas duas listas. $x$

Suponha que ambas as listas sejam do tamanho . Existe um algoritmo determinístico de tempo linear para esse problema? Em outras palavras, você pode resolver esse problema em tempo deterministicamente, sem usar aleatoriedade? $X,Y$ $n$ $O(n)$

Infelizmente, você não pode assumir que os elementos da lista são todos pequenos.

Eu posso ver como resolvê-lo no tempo esperado de usando um algoritmo aleatório: escolha aleatoriamente uma função hash 2 universal , armazene os elementos de em uma hashtable (usando como função hash) e, em seguida, procure cada elemento de para ver se está na hashtable. O tempo de execução esperado será . No entanto, não consigo ver como encontrar um algoritmo determinístico com tempo de execução. Se você tentar des randomizar isso e corrigir uma única função hash específica, haverá uma entrada no pior caso que fará com que este procedimento seja executado em $O(n)$ $h$ $X$ $h$ $Y$ $O(n)$ $O(n)$ tempo. O melhor algoritmo determinístico que posso encontrar envolve a classificação dos valores, mas isso não será em tempo linear. Podemos obter tempo de execução linear? $\Theta(n^2)$

Além disso, eu posso ver como resolvê-lo em tempo linear se você assumir que todos os elementos da lista são números inteiros no intervalo (basicamente, faça a contagem de classificação) - mas estou interessado no que acontece no geral caso em que não podemos assumir isso. $[1,n]$

Se a resposta depende do modelo de computação, o modelo de RAM é lembrado, mas eu estaria interessado nos resultados de qualquer modelo razoável de computação. Estou ciente de limites inferiores para algoritmos de árvore de decisão para exclusividade do elemento , mas isso não é definitivo, pois às vezes podemos encontrar algoritmos de tempo linear mesmo quando existe um vinculado em o modelo da árvore de decisão. $\Omega(n \log n)$ $\Omega(n \log n)$

algorithms complexity-theory lower-bounds

— DW
fonte

As tabelas de hash são O (n log n), pois você precisa lidar com colisões.

— Thorbjørn Ravn Andersen

11

@ ThorbjørnRavnAndersen, não estou vendo de onde você está tirando isso. O uso de funções de hash 2-universais e uma tabela de hash de tamanho adequado garante que o número de colisões de hash seja mínimo (com alta probabilidade), então acredito que

tempo de execução seja possível. Não sei de onde você tirou

; se você não fizer algo especial (como usar o hash 2-universal), o pior caso é

, devido a colisões.

O (n)

$O(n)$

O (n \lg n)

$O(n \lg n)$

O (n^{2})

$O(n^2)$

— DW

O diabo está nos detalhes, aqui uma "tabela de hash de tamanho adequado". Isso pode ser bastante grande, se você não quiser colisões. O típico n-log-n é (se bem me lembro) para lidar com as colisões de funções hash com uma lista.

— Thorbjørn Ravn Andersen

11

@ ThorbjørnRavnAndersen O número esperado de chaves mapeadas para o mesmo endereço é constante (para tabelas que não estão sobrecarregadas), portanto, o tipo de resolução de colisão é irrelevante. Veja também aqui .

se encaixa no pior caso se você usar BSTs balanceadas (externas) em vez de listas.

O (n \log n)

$O(n \log n)$

— Raphael

1

Você pode resolver o problema em tempo linear se tiver memória suficiente para ter um pouco para cada valor possível em X e Y. Isso não impõe restrições à ordenação de X e Y.

Inicialmente todos os bits estão desmarcados.
Itere sobre X configurando o bit correspondente.
Faça uma iteração sobre Y, verificando se o bit correspondente foi definido acima.

— Thorbjørn Ravn Andersen
fonte

2

Infelizmente, você não pode assumir que todos os números inteiros são pequenos (você não pode assumir que eles sejam pequenos o suficiente para que esse algoritmo funcione). Geralmente, o tempo de execução desse algoritmo será exponencial no tamanho dos bits dos elementos da lista. Obrigado mesmo assim!

— DW

Vamos chamá-lo de "matriz de bits de tamanho adequado" então. Também linear no comprimento do bit é equivalente ao log-n. Você está interessado em obter desempenho de log-n sem restrições ou pré-condições nos dados de entrada?

— Thorbjørn Ravn Andersen

2

@ ThorbjørnRavnAndersen O espaço é exponencial no tamanho do bit (é necessário mapear todos os valores possíveis) e o tempo é linear no tamanho total da lista (é necessário examinar todos os valores nas duas listas). Nada é linear no comprimento do bit.

— wchargin

0

Como você está dizendo que as duas listas contêm números inteiros, acho que podemos executar uma classificação radix nas duas listas e, em seguida, fazer uma pesquisa linear comparando as duas listas por itens equivalentes.

— anirudh
fonte

4

Isso só funciona se houver um limite na magnitude dos números.

— Lucas Mathieson

mas pensei que a alta magnitude seria um problema apenas para contar a classificação e para a classificação de base podemos selecionar uma base suficientemente alta para resolver esse problema ... por favor, deixe-me saber o que estou perdendo aqui

— anirudh

E se um dos números for 2 ^ (2 ^ 128)?

— miniBill

@anirudh, mas você tem um algoritmo diferente para diferentes tamanhos de entrada - você precisa de um alfabeto maior a cada vez que aumenta o raio, exportando a complexidade de aumentar a magnitude para aumentar o tamanho do alfabeto. É claro que isso só é possível em teoria também, não acho que muito hardware permita alterar em qual base ele representa números (podemos fingir que as entradas e saídas terminam, mas tudo se resume a (principalmente) binário )

— Lucas Mathieson

0

$\mathcal O\left(n\cdot \overline m\right)$ $\overline m$

— Realz Slaw
fonte

O (n)

$O(n)$

O (n \cdot \overbar m)

$O(n \cdot \overbar{m})$

w

$w$

m

$m$

\bar{m}

$\overline{m}$

O (n)

$\mathcal O\left(n\right)$

w

$w$

w

$w$

n

$n$

m

$m$

n

$n$

n^{m}

$n^m$

-1

$O(n\log n)$

— Omer Gold
fonte

11

A questão é bastante explícita sobre o tempo determinístico linear, não log-linear. Também para determinar se (e não em qual valor) o conjunto possui apenas elementos exclusivos que você pode executar mais rapidamente do que o linear.

— Mal

11

Ω (n \log n)

$\Omega(n\log n)$

11

Ω (n \log n)

$\Omega(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$

O (n \log \log n)

$O(n \log \log n)$

O (n \log n)

$O(n \log n)$

Ω (n \log n)

$\Omega(n \log n)$