Estrutura de dados para testar todos os subconjuntos de uma consulta para associação

Existe uma estrutura de dados que ofereça suporte eficiente às seguintes operações?

1. Adicionar conjunto
2. Pergunte se algum subconjunto de um conjunto foi adicionado.

Isso pode ser implementado com sobrecarga linear, testando todos os conjuntos adicionados durante cada consulta. Pode ser implementado com mais eficiência? Pequenas probabilidades de falsos positivos / negativos são aceitáveis ​​(por exemplo, estilo de filtro Bloom).

Digamos que todos os seus conjuntos sejam subconjuntos finitos de $\mathbb N$. Deixei$S\subseteq \mathcal P( \mathbb N)$ denotar seu conjunto de conjuntos.

Você quer duas operações:

• $O_1(S,s')$: Para qualquer $s'\subseteq \mathbb N$, adicionar $s'$ para $S$

• $O_2(S,s')$: Para qualquer $s'\subseteq \mathbb N$, existe algum $s\in S$ de modo a $s\subseteq s'$?

Aqui estão algumas idéias para acelerar as coisas:

• Você vai testar se um conjunto se um subconjunto de outro muito, então você provavelmente deve manter o tamanho $|s|$ de cada conjunto $s$ disponível em $O(1)$ para que quando você precisar testar se $s\subseteq s'$, você começa verificando se $|s|\le |s'|$e se não, você pode retornar falso imediatamente. E você realmente tem$|s|\le |s'|$, basta executar o teste lento normal.

• Observe que se você tiver $s_1\in S$ e $s_2\in S$, de modo a $s_1\subseteq s_2$, então se $s_2\subseteq s'$, você também tem $s_1\subseteq s'$. Então você não precisa manter$s_2$ no $S$ para $O_2$. Então você pode representar$S$ por um conjunto de conjuntos para que $s\in S$ e $s\subsetneq s'$ implica $s'\not \in S$. Em outras palavras, você só precisa acompanhar os conjuntos em$S$que são mínimos para inclusão. Isso pode ser implementado com bastante eficiência: Ao adicionar um conjunto$s'$, para todos os conjuntos $s\in S$ de modo a $|s|\le |s'|$ (ordenado pelo aumento do cardeal), se $s\subseteq s'$, então não adicione $s'$ porque não será mínimo (ou já está em $S$) Caso contrário, adicione$s'$ e depois entre conjuntos $s\in S$ de modo a $|s'|<|s|$, remova-os para que $s'\subseteq s$ (porque eles não são mais mínimos).

• Mantenha um conjunto $t$ isso é igual à união de todos os conjuntos $S$. Então, ao invés de correr$O_2(S,s')$, você pode correr $O_2(S,s'\cap t)$ em vez disso (porque se por algum $s\in S$, $s\subseteq s'$então desde $s\subseteq t$, $s\subseteq s'\cap t$ e se $s\subseteq s'\cap t$, então $s\subseteq s'\cap t \subseteq s'$)

Com essas idéias em mente, eu representaria $S$ por um dictionnary (implementado como uma lista duplamente ligada de pares $(key,value)$ com as teclas em ordem crescente) $d$ de modo a $d(k)$ é uma lista duplamente vinculada que contém exatamente o mínimo (para inclusão) de conjuntos $S$ do cardeal $k$.

O1(S,s')
  if O2(S,s')
    return
  if d(k) doesn't exist
    d(k) := new_doubly_linked_list()
  add(d(k),s')
  S.t := union(S.t, s')
  for each key k of d so that |s'|+1 <= k
    for s in d(k)
      if subset(s', s)
        remove s

_O2(S,s')
  for each key k of d so that k <= |s'|
    for s in d(k)
      if subset(s,s')
        return true
  return false

O2(S,s')
  return _O2(S,inter(S.t,s'))

(Observe que, embora eu não tenha feito isso explicitamente no código de O1, você pode fazer uma única travessia da lista duplamente vinculada que representa d)

Não acho que isso melhore muito no pior dos casos, mas, em média, deveria.