Recherche de sommets jumeaux dans les graphiques

Soit un graphe. Pour un sommet , définir pour être le (ouvert) voisinage de dans . Autrement dit, . Définissez deux sommets dans comme des jumeaux si et ont le même ensemble de voisins, c'est-à-dire si .$G=(V,E)$$x\in V$$N(x)$$x$$G$$N(x)=\{y\in V \,\vert\, \{x,y\}\in E\}$$u,v$$G$$u$$v$$N(u)=N(v)$

Étant donné un graphique sur sommets et arêtes en entrée, à quelle vitesse peut-on trouver une paire de jumeaux dans , si une telle paire existe?$G$$n$$m$$G$

Nous pouvons vérifier si deux sommets donnés sont des jumeaux en temps , en comparant leurs voisinages. Un algorithme simple est de trouver des jumeaux, c'est donc de vérifier, pour chaque paire de sommets, s'il s'agit de jumeaux. Cela prend du temps (et trouve également toutes les paires de jumeaux). Existe-t-il un moyen beaucoup plus rapide de trouver (s'il existe) une paire de jumeaux dans le graphique? Existe-t-il des travaux connus dans la littérature qui traitent de ce problème?$O(n)$$O(n^{3})$

Les jumeaux dans un graphique ne sont que des modules de taille 2. La décomposition modulaire d'un graphique peut être trouvée en temps . L'arbre de décomposition modulaire représente implicitement tous les modules du graphique et se compose de trois types de nœuds internes: les nœuds série, parallèle et premier, et les feuilles se composent des nœuds individuels. Un ensemble d'au moins deux sommets est un module si et seulement s'il s'agit d'un nœud de l'arbre ou de l'union d'un ensemble d'enfants d'une série ou d'un nœud parallèle.S ⊂ $O(n+m)$$S \subset V$

Donc, pour trouver une paire de nœuds jumeaux, s'ils existent, nous pouvons construire l'arbre de décomposition modulaire en temps . Regardez ensuite les feuilles, si le parent d'une feuille est un nœud série ou parallèle, alors ce nœud doit avoir au moins deux enfants qui forment une paire jumelle. La durée totale de fonctionnement est donc linéaire.$O(n+m)$

http://en.wikipedia.org/wiki/Modular_decomposition

Le problème revient à déterminer s'il y a deux lignes égales dans la matrice graphique. Nous pouvons construire un trie sur des lignes de matrice graphique. La complétion temporelle sera O (n ^ 2)

EDIT: les solutions de @MikleB et @Travis sont très intelligentes. Désolé pour la réponse exagérée.

Il semble que le problème puisse être réduit au problème de multiplication matricielle sur la matrice d'adjacence du graphe, en remplaçant la multiplication par EQU (c'est-à-dire NXOR) et l'addition par AND. Donc, s'il y a une paire de jumeaux dans le graphique, alors la matrice résultante A A T ne sera pas la matrice d'identité, et les indices ( i , j ) où la valeur a i , j n'est pas nulle sont exactement les nœuds de paire jumelle .$A$$AA^T$$(i,j)$$a_{i,j}$

À ma connaissance, le problème de multiplication matricielle peut être résolu en temps avec α ≈ 2,376 par l' algorithme de Coppersmith – Winograd . Si des solutions pratiques sont nécessaires, tous les algorithmes de multiplication matricielle fonctionnent bien dans la pratique sont agréables.$O(n^\alpha)$$\alpha \approx 2.376$

En raison du système fou sur ce site, je ne peux pas commenter directement, mais j'ai quelques observations sur les réponses existantes.

Je suis sûr que les besoins de solutions de Chang Hsien-Chih pour corriger à A A T .$A^2$$AA^T$

L'observation 4 de TheMachineCharmer est dos à face (contre-exemple: [0,0,1], [0,1,0], [0,1,1] a un déterminant 0 mais pas de jumeaux). S'il existe des jumeaux, le déterminant est zéro.

Ce fil est assez ancien; cependant, personne ne semble avoir adopté l'approche la plus élégante et la plus simple. Trier lexicographiquement la liste d'adjacence en temps O (n + m) puis vérifier les doublons (voir Aho, Hopcroft, Ullman, 74 '). Vous pouvez utiliser la décomposition modulaire, mais c'est une exagération totale.

Ce fil est ancien et la question d'OP a été répondue, mais j'aimerais ajouter un autre algorithme pour trouver toutes ces paires en temps linéaire. Personne n'a mentionné le raffinement de partition !

Cet algorithme trouve les classes d'équivalence de faux jumeaux. L'algorithme repose sur une procédure efficace qui affine une partition. Étant donné un ensemble Set une partition P = {X1, ..., Xn}. refine(P, S) = {X1 ^ S, X1 - S, X2 ^ S, X2 - S, ..., Xn ^ S, Xn - S}. ^désigne l'intersection -définie et la différence définie. Une partition est stable si elle ne peut pas être affinée davantage. Cette procédure prend du temps O (| S |) (voir l'article de Wikipedia sur le raffinement des partitions), donc c'est rapide.

Algorithm:

P = {V} // initial partition consists of the vertex set
for every vertex v:
    P = refine(P, N(v)) // refine with the open neighborhood of v

Le temps total est O (| V | + | E |). C'est aussi simple à programmer.

Quelques observations qui pourraient aider

1. $a,b \in V$$a$$b$$c$$d$$c \in N(a)$$d \in N(b)$

2. $|N(a)| \neq |N(b)|$$a$$b$

3. $b \in N(a)$$a$$b$

4. S'il existe des jumeaux, le déterminant de la matrice d'adjacence est nul.

Idée de fantaisie:

1. Construisez un arbre binaire complet avec height = | V |.
2. Commencez ensuite à lire une ligne de la matrice d'adjacence.
3. Si vous rencontrez 0, prenez à gauche sinon prenez à droite.
4. Lorsque vous atteignez une feuille, stockez-y votre sommet.
5. Faites cela pour toutes les lignes. Donc, à la fin, chaque feuille aura des voisins.

Volé à partir de l'algorithme de compression inspiré par Huffman! :)