Structure de données pour définir l'intersection?

21

Existe-t-il une structure de données qui gère une collection d'ensembles (d'ensembles de sols finis) prenant en charge les opérations suivantes? Tout temps de fonctionnement sublinéaire sera apprécié?

Initiez un ensemble vide.
Ajoutez un élément à un ensemble.
Étant donné deux ensembles, indiquez s'ils se croisent.

data-structures sets

— Dawei Huang
source

1

Il s'agit d'une question très générale, car toute structure de données peut prendre en charge ces opérations avec un domaine fini. Pourriez-vous être un peu plus précis? Par exemple. Quelle complexité dont vous avez besoin, qu'êtes-vous prêt à sacrifier pour obtenir des opérations

— fixes,

13

Si chaque ensemble conserve un enregistrement des autres ensembles existants et que vous avez un total de $s > 0$ ensembles, vous pouvez facilement transformer n'importe quelle structure de données pour une collection ( par exemple, les arbres de recherche binaire, etc. ) en une où vous pouvez avoir la récupération de un élément de l'intersection de deux ensembles dans le temps $O(\log s)$ .

Chaque ensemble doit avoir un identifiant unique provenant d'un ensemble totalement ordonné. Si vous nommez explicitement vos ensembles $S_1, S_2, \ldots$ alors l'identifiant pourrait simplement être l'index.
Vous devez implémenter un "registre" des ensembles; une structure de données qui conserve une collection de tous les ensembles que vous avez définis. Le registre doit être implémenté sous la forme d'une structure de données d'arbre de recherche, pour permettre une récupération facile ( par exemple si vous souhaitez supprimer l'ensemble) et une traversée en temps linéaire des ensembles.
Chaque ensemble conserve également un "index" de chacun des autres ensembles - pas une copie d'entre eux, mais plutôt une structure de données qui est indexée par les étiquettes des autres ensembles. Cet index sera utilisé pour maintenir, pour chaque ensemble , un arbre de recherche binaire de tous les éléments de . (Les deux ensembles et partagent une copie de cet arbre de recherche.) $S_j$ $S_k$ $S_j \cap S_k$ $S_j$ $S_k$

Initialisation

Initialisation d'un ensemble est constitué de opérations pour initialiser l'arbre de ses éléments, les opérations que l' initialisation ( la copie du registre) l'indice pour l'ensemble et opérations que vous parcourez le registre pour ajouter dans les indices de chacun des autres ensembles . Dans l'index de , nous créons des arbres de recherche représentant $T = \varnothing$ $O(1)$ $O(s)$ $T$ $O(s \log s)$ $T$ $S_j$ $T$ $T \cap S_j = \varnothing$ pour les autres ensembles ; nous copions le même pointeur pour l'indice de . $S_j$ $S_j$

Ajout d'un élément à un ensemble $T$

L'ajout de à l'ensemble prend le temps comme d'habitude, où . Nous testons également l'appartenance de dans chacun des autres ensembles , ce qui prend du temps $x \in V$ $T$ $O(\log n_T)$ $n_T = |T|$ $x$ $S_1, S_2, \ldots$ oùest la taille de l'univers (ou du plus grand ensemble ) et est le nombre d'ensembles dans le registre. Pour chaque série de telle sorte que , également insérer dans l'index de l'ensemble . Pour chacun de ces ensembles , il faut pour rechercher

O (\log n_{S_{1}} + \log n_{S_{2}} + \dots) \subseteq O (s \log n),

$O(\log n_{S_1} + \log n_{S_2} + \cdots) \subseteq O(s \log n) ,$

n = | V |

$n = |V|$

S_{j}

$S_j$

s

$s$

S_{j}

$S_j$

x \in S_{j}

$x \in S_j$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{j}

$S_j$

O (\log s + \log n_{T})

$O(\log s + \log n_T)$

S_{j}

$S_j$ dans l'indice de

et insérer

dans

; sur tous les ensembles

cela prend du temps

. Si nous supposons que le nombre d'ensembles

est bien inférieur à la taille de l'univers

(c'est-à-dire si nous supposons

), le temps total pour l'insertion d'élément est alors

T

$T$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{1}, S_{2}, \dots

$S_1, S_2, \ldots$

O (s \log s + s \log n_{T})

$O(s \log s + s \log n_T)$

S_{j}

$S_j$

V

$V$

s ≪ n

$s \ll n$

O (s \log n)

$O(s \log n)$ .

Si vous ne permettez pas de doublons dans les jeux, nous pouvons gagner du temps dans le cas où déjà en renonçant à l'épreuve d'adhésion et les insertions pour les autres ensembles . "Insertion" dans le cas où est déjà présent ne prend alors que le temps . $x \in S$ $T$ $x$ $O(\log n_T)$

Test d'intersection

L'indice de chaque ensemble est maintenu avec précision afin de permettre une évaluation rapide de l' intersection ou non de deux ensembles et . Pour un ensemble , simplement en vérifiant son index pour l'ensemble , nous pouvons non seulement déterminer dans le temps si intersecte , mais nous pouvons également récupérer un arbre binaire contenant l'ensemble entier . $S_j$ $S_k$ $S_j$ $S_k$ $O(\log s)$ $S_j$ $S_k$ $S_j \cap S_k$

Suppression d'élément

Pour supprimer un élément d'un ensemble , nous le supprimons non seulement de l'arbre de recherche de lui-même, mais de chacune des intersections pour les ensembles dans son index. Cela prend le temps , où . $x$ $T$ $T$ $S_j \cap T$ $S_j$ $O(s \log n_T)$ $n_T = |T|$

Définir la suppression

En raison de la surcharge de recherche dans le registre, si vous disposez de plusieurs ensembles, il peut être souhaitable de supprimer les ensembles une fois qu'ils ne sont plus nécessaires. En parcourant l'ensemble du registre, nous pouvons supprimer de l'index de tous les autres ensembles dans le temps , dominé par le coût de la suppression de l'arbre de recherche représentant pour chacun des autres ensembles , où . $S$ $S_j$ $O(sn_T)$ $S_j \cap T$ $S_j$ $n_T = |T|$

Remarques

Si vous vous attendez à n'implémenter qu'un nombre constant d'ensembles, les temps d'exécution ci-dessus se réduisent à:

initialisation: $O(1)$
insertion d'élément: $O(\log n)$
test d'intersection (et récupération de l'intersection): $O(1)$
suppression d'élément: $O(\log n_T)$
supprimer la définition: $O(n_S)$

où est la taille du plus grand ensemble du registre et pour l'ensemble lequel vous opérez. $n$ $n_T = |T|$ $T$

Si vous vous attendez à avoir des ensembles , où est votre univers, vous pouvez avoir besoin d'une structure de données différente si vous voulez que ces opérations fonctionnent en temps sub-linéaire. Cependant, si vous avez des paires d'ensembles dont vous savez que vous ne testerez jamais l'intersection, vous pourrez peut-être réduire la taille de l'index pour les ensembles (en n'incluant aucun ensemble dont vous allez tester l'intersection) ou utiliser plusieurs registres ( un pour chaque collection d'ensembles dont vous pourriez tester l'intersection). En fait, un registre n'est utile que si vous voulez un contrôle centralisé pour vous assurer que chaque paire d'ensembles a un enregistrement les uns des autres dans l'index: il peut être pratique dans certains cas, lors de l'initialisation d'un ensemble , d'enregistrer simplement $O(|V|)$ $V$ $S$ ad hoc chaque nouvel ensemble dans les indices des autres ensembles dont l'intersection avec vous intéresse. $T$ $S$

— Niel de Beaudrap
source

6

Il existe des structures de données qui vous permettent de le faire en moins de temps linéaire, même pour les entrées du pire des cas. Voir http://research.microsoft.com/pubs/173795/vldb11intersection.pdf (et les références des articles qui s'y trouvent).

Si vos deux ensembles S et T ont une grande intersection et que vous avez un dictionnaire pour S, la recherche d'éléments de T dans un ordre aléatoire devrait rapidement vous donner un élément commun. Le cas le plus difficile est lorsque la taille de l'intersection est 0 ou 1.

— Rasmus Pagh
source

3

Habituellement, le langage de programmation de votre choix prendra en charge une structure de données avec des éléments uniques. En général, il existe trois approches populaires: les arbres, les hachages et les bitmasks. Les éléments d'arbre doivent être comparables, les éléments de hachage doivent être lavables et les éléments de masque de bits doivent avoir un moyen de conversion en entiers.

Un ensemble d'arbres prend en charge l'insertion dans O (log n) et les tests d'intersection dans le pire cas O (n log n).

Un ensemble de hachage prend en charge l'insertion dans Amortized O (1 * h) où «h» est le temps d'exécution de l'algorithme de hachage et le test d'intersection dans le pire cas O (n).

Les ensembles de masques de bits ne sont généralement pas utilisés comme des ensembles d'arbres et de hachage.

— Karl Damgaard Asmussen
source

2

Ce serait une réponse décente à Stack Overflow , mais ici, nous aimerions avoir des détails sur comment et pourquoi cela fonctionne.

— Raphael

3

Si votre cas autorise de fausses réponses positives, j'utiliserais le filtre Bloom avec une seule fonction de hachage.

Vous pouvez l'implémenter comme suit:

Initier un ensemble vide

$B$ $n$ $n$

Ajoutez un élément à un ensemble.

$B[hash(element)]=1$

Étant donné deux ensembles (B1, B2), indiquez s'ils se croisent.

$B1$ $AND$ $B2$ $=$ $0$

Complexité

$n$ $O(1)$

— Grisha Weintraub
source