Encontrar vértices gemelos en gráficos

Deje ser un gráfico. Para un vértice x ∈ V , definir N ( x ) para ser el barrio (abierto) de x en G . Es decir, N ( x ) = { y ∈ $G=(V,E)$$x\in V$$N(x)$$x$$G$ . Defina dos vértices u , v en G para que seangemelossi u y v tienen el mismo conjunto de vecinos, es decir, si N ( u ) = N ( v ) .$N(x)=\{y\in V \,\vert\, \{x,y\}\in E\}$$u,v$$G$$u$$v$$N(u)=N(v)$

Dado un gráfico en n vértices ym aristas como entrada, ¿qué tan rápido podemos encontrar un par de gemelos en G , si tal par existe?$G$$n$$m$$G$

Podemos verificar si dos vértices dados son gemelos en el tiempo , comparando sus vecindarios. Un algoritmo directo es encontrar gemelos para verificar, para cada par de vértices, si son gemelos. Esto toma tiempo O ( n 3 ) (y también encuentra todos los pares de gemelos). ¿Hay una manera significativamente más rápida de encontrar (si existe) un par de gemelos en el gráfico? ¿Existe algún trabajo conocido en la literatura que aborde este problema?$O(n)$$O(n^{3})$

Los gemelos en un gráfico son solo módulos de tamaño 2. La descomposición modular de un gráfico se puede encontrar en el tiempo . El árbol de descomposición modular representa implícitamente todos los módulos del gráfico y consta de tres tipos de nodos internos: nodos serie, paralelo y primo, y las hojas consisten en nodos individuales. Un conjunto de al menos dos vértices S ⊂ V es un módulo si y solo si es un nodo en el árbol o la unión de algún conjunto de hijos de una serie o un nodo paralelo.$O(n+m)$$S \subset V$

Entonces, para encontrar un par de nodos gemelos, si existen, podemos construir el árbol de descomposición modular en tiempo . Luego mire las hojas, si el padre de cualquier hoja es un nodo en serie o paralelo, entonces ese nodo debe tener al menos dos hijos que formen un par gemelo. Entonces, el tiempo total de ejecución es lineal.$O(n+m)$

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

El problema es equivalente a determinar si hay dos filas iguales en la matriz gráfica. Podemos construir trie en filas de matriz gráfica. La complejidad del tiempo será O (n ^ 2)

EDITAR: las soluciones de @MikleB y @Travis son mucho más inteligentes. Perdón por la respuesta exagerada.

Parece que el problema puede reducirse al problema de multiplicación de la matriz en la matriz de adyacencia del gráfico, reemplazando la multiplicación con EQU (es decir, NXOR) y la suma con AND. Entonces, si hay un par de gemelos en el gráfico, entonces la matriz resultante A A T no será la matriz de identidad, y los índices ( i , j ) donde el valor a i , j no es cero son exactamente los nodos del par gemelo .$A$$AA^T$$(i,j)$$a_{i,j}$

Que yo sepa, el problema de multiplicación de matrices se puede resolver en tiempo con α ≈ 2.376 mediante el algoritmo Coppersmith-Winograd . Si se necesitan soluciones prácticas, cualquier algoritmo de multiplicación de matrices que funcione bien en la práctica es bueno.$O(n^\alpha)$$\alpha \approx 2.376$

Debido al sistema loco en este sitio, no puedo comentar directamente, pero tengo un par de observaciones sobre las respuestas existentes.

$A^2$$AA^T$

La observación 4 de TheMachineCharmer está de vuelta al frente (contraejemplo: [0,0,1], [0,1,0], [0,1,1] tiene determinante 0 pero no gemelos). Si existen gemelos, entonces el determinante es cero.

Este hilo es bastante viejo; Sin embargo, nadie parece haber dado con el enfoque más elegante y simple. Clasifique lexicográficamente la lista de adyacencia en tiempo O (n + m) y luego busque duplicados (ver Aho, Hopcroft, Ullman, 74 '). Puede usar la descomposición modular, pero esto es una exageración total.

Este hilo es antiguo y la pregunta de OP ha sido respondida, pero me gustaría agregar otro algoritmo para encontrar todos estos pares en tiempo lineal. ¡Nadie mencionó el refinamiento de partición !

Este algoritmo encuentra las clases de equivalencia de gemelos falsos. El algoritmo se basa en un procedimiento eficiente que refina una partición. Dado un conjunto Sy una partición P = {X1, ..., Xn}. refine(P, S) = {X1 ^ S, X1 - S, X2 ^ S, X2 - S, ..., Xn ^ S, Xn - S}. ^denota la intersección -establecida y la diferencia establecida. Una partición es estable si no se puede refinar más. Este procedimiento lleva tiempo O (| S |) (consulte el artículo de Wikipedia sobre el refinamiento de la partición), por lo que es rápido.

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

El tiempo total es O (| V | + | E |). Esto es simple de programar también.

Algunas observaciones que pueden ayudar

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. Si existen gemelos, entonces el determinante de la matriz de adyacencia es cero.

Idea de lujo:

1. Construya un árbol binario completo con altura = | V |.
2. Luego comience a leer una fila de matriz de adyacencia.
3. Si encuentra 0, gire a la izquierda, de lo contrario, gire a la derecha.
4. Cuando llegues a una hoja, almacena tu vértice allí.
5. Haga esto para todas las filas. Entonces, al final cada hoja tendrá vecinos.

¡Robado del algoritmo de compresión Inspirado por Huffman! :)