Cómo verificar si existe una ruta simple entre los nodos a y b de modo que pase a través del nodo c

Puede hacer esto usando el problema de flujo máximo. Divida cada vértice [matemática] v [/ matemática] en dos: [matemática] v_ {dentro} [/ matemática] y [matemática] v_ {fuera} [/ matemática]: haga todos los bordes [matemática] (u, v) [ / math] se dirigen los bordes de u [math] _ {out} [/ math] a [math] v_ {in} [/ math] y agrega bordes dirigidos de [math] v_ {in} [/ math] a [math ] v_ {out} [/ math] para cada [math] v [/ math]. Establezca [math] c_ {out} [/ math] como la fuente, conecte [math] a_ {out} [/ math] y [math] b_ {out} [/ math] (y ningún otro vértice) con el objetivo. Todos los bordes deben tener capacidad 1. Luego ejecute el algoritmo Ford – Fulkerson – Wikipedia y vea cuál es el flujo máximo que encontró. Si es 2, ha encontrado una ruta simple: hay una forma de [matemáticas] c [/ matemáticas] a [matemáticas] b [/ matemáticas] y de [matemáticas] c [/ matemáticas] a [matemáticas] a [/ matemáticas] y no pasan por el mismo borde [math] v_ {in} [/ math] a [math] v_ {out} [/ math]. Si es 0 o 1, no hay una ruta simple. Como el flujo máximo no puede ser mayor que 2, el algoritmo FF se ejecutará en [matemática] O (E) [/ matemática].

Si existe una ruta de a a c, y una ruta de c a b, entonces existe una ruta de a a b que pasa por c.

* Editar *: No noté la palabra simple en la pregunta.

Así es como lo haría entonces:

Mantenga una matriz visitada de bools que tenga en cuenta si el nodo i ha sido visitado o no.

Codifique una profundidad Primero busque desde el nodo a, solo va a los nodos no visitados y marca los nodos visitados cada vez que los alcanza (y no se visita cuando termina de alcanzarlos).

Cada vez que llegue al nodo b, verifique si el nodo c fue visitado usando la matriz visitada en O (1).

// booleano que se almacenará si existe una ruta simple entre ayb que pasa por c.
bool encontrado = falso;

int nbNodes, nbEdges;
int a, b, c;
const int MAX_NB_NODES = 1e5;
vector adj [MAX_NB_NODES];
bool visitó [MAX_NB_NODES];

dfs nulo (nodo int) {
if (visitado [nodo] || encontrado)
regreso;
visitado [nodo] = verdadero;
if (nodo == b) {
encontrado | = visitado [c];
regreso;
}
para (int vecino: adj [nodo])
dfs (vecino);
visitado [nodo] = falso;
}

bool pathExists (int A, int B, int C) {
fill_n (visitado, nbNodes + 1, falso);
encontrado = falso;
a = A, b = B, c = C;
dfs (a);
retorno encontrado;
}

Supongamos que puede verificar si existe una ruta entre los nodos x e y.

Use eso para verificar que hay una ruta de a a c. Si es así, verifique que haya una ruta de c a b. Si es así, existe una ruta de a a b a c.

More Interesting

Cómo encontrar la solución más óptima para una pregunta en particular que se ha enviado en LeetCode

¿Qué significa esta notación sigma?

¿Por qué una elección de K es mejor que otras en el algoritmo K-means?

Dado que solo quedan 2 meses para las regiones regionales de ACM ICPC, ¿cuántos problemas podría resolver allí si comenzara a practicar ahora, teniendo solo la idea más básica sobre algoritmos?

¿Cuáles son algunas buenas implementaciones de un algoritmo evolutivo / genético en C / C ++?

Si tengo una base de datos con 100 mil millones de nombres de usuario, ¿cómo construyo eficientemente una matriz ordenada a partir de eso para realizar fácilmente una búsqueda binaria?

¿Cómo determinan los algoritmos de creación de mercado qué tan agresivamente deberían salir de las posiciones?

¿Cómo paso la matriz asociativa como un argumento con los elementos de esa matriz que se pasan en un orden específico?

¿Cuáles son los pros y los contras de imprimir una matriz en Java?

Cómo guardar la entrada del usuario dentro de una matriz en Java

¿Aprender más idiomas es bueno en comparación con el aprendizaje de estructuras de datos y algoritmos?

¿Es cierto que si me vuelvo competente en estructuras de datos y algoritmos, puedo aprender cualquier lenguaje de programación y habilidades técnicas muy rápido?

¿Qué es la optimización de divide y vencerás en la programación dinámica?

¿Cómo funciona este algoritmo para encontrar los bordes del corte mínimo de un gráfico?

¿Por qué el introsort se convierte de quicksort a heapsort después de cierta profundidad?