Um algoritmo de pesquisa de subconjunto

9

Suponha que eu tenho uma lista de subconjuntos de . Eu posso fazer o pré-processamento nesta lista, se necessário. Após este pré-processamento, eu sou apresentado com um outro conjunto . Quero identificar quaisquer conjuntos com . $\cal X$ $\{1, ..., n\}$ $A \subseteq \{1, ..., n \}$ $B \in \mathcal X$ $B \subseteq A$

O algoritmo óbvio (sem nenhum pré-processamento) leva tempo - você simplesmente testa contra cada separadamente. Existe algo melhor que isso? $O(n |\cal X|)$ $A$ $B \in \mathcal X$

Se ajudar, você pode assumir que, para qualquer , o número total de correspondências é limitado por algo como . $A$ $B \in \mathcal X$ $O(1)$

ds.algorithms ds.data-structures

— David Harris
fonte

3

Esta não é uma resposta. É uma observação simples, mas longa. Espero que seja útil.

A versão de decisão do seu problema é: $\cal X$ contém um subconjunto de $A$ ?

$n$ $\{1,\ldots,n\}$ $n$ $\cal X$ $f$ $n$ $f$ $f$ $g(y)=(\exists x\subseteq y,\,f(x))$ $g(A)$ $f=g$ $f$ $\cal X$

$f$ $g$ $g$ $g$ $\Omega\left(\binom{n}{n/2}\right)$

Mas (1) uma análise melhor pode ser possível e (2) pode haver ajustes nessa abordagem que a tornam melhor. Por exemplo, eu não usei de forma alguma a correlação entre o tamanho de e o tamanho do BDD de . (Deve haver uma correlação, mas não sei se é simples ou utilizável aqui.) $\cal X$ $g$

Para completar, um algoritmo simples para calcular o BDD for partir do BDD for é o seguinte. Aqui é a operação ou operação padrão nos BDDs. $g$ $f$

m (x ? f_{1} : f_{0}) = x ? (m (f_{0}) \lor m (f_{1})) : m (f_{0})

$m(x?f_1:f_0)=x?(m(f_0)\lor m(f_1)):m(f_0)$

\lor

$\lor$

— Radu GRIGore
fonte

2

Isso não é mais ou menos equivalente a pré-calcular a resposta para cada subconjunto de , armazenando em cache todos os resultados em uma árvore binária de tamanho e, em seguida, procurando a direita resultado (no tempo ) quando você recebe ?

{1, 2, . . ., n}

$\{1,2,...,n\}$

2^{n}

$2^n$

O (n)

$O(n)$

A

$A$

— precisa saber é o seguinte

Usar espaço exponencial para armazenar dados pré-processados parece trapaça para mim, embora não seja proibido na pergunta. Mas posso ser tendencioso em relação à Igreja da Pior Complexidade.

— Tsuyoshi Ito

mjqxxxx e Tsuyoshi: Eu concordo com vocês dois. Reescrevi o texto para que, espero, fique mais claro que concordo. :)

— Radu GRIGore

3

Talvez você possa usar uma técnica de "recuperação de informações": na fase de pré-processamento, crie um índice invertido (no seu caso, é suficiente uma matriz bidimensional ) que mapeia um elemento para os conjuntos em que o contêm: . $n \times | {\cal X}|$ $x_i \in \{1,...,n\}$ $\cal X$ $inv(x_i)= \{ X_j \in {\cal X} \; | \; x_i \in X_j \}$

Configure um array inteiro de comprimento. $occ$ $|\cal X|$

Então, para cada recupera , e para cada ocorre $y_i \in A$ $inv(y_i)$ $X_j \in inv(y_i)$ $occ[j] = occ[j]+1$

No final, os conjuntos necessários são aqueles para os quais . $|X_j|=occ[j]$

Você pode acelerar arbitrariamente o processo (ao custo do espaço exponencial) indexando dois ou mais elementos juntos.

— Marzio De Biasi
fonte