[Registro de cepillado de LeetCode] 28. Rutas entre nodos

Llega oferta, cava amigos a recoger! Estoy participando en el evento de registro de reclutamiento de primavera de 2022, haga clic para ver los detalles del evento .

1. Descripción del tema:

Fuente del tema: LeetCode -Acceso entre nodos

camino entre nodos. Dado un gráfico dirigido, diseñe un algoritmo para averiguar si hay un camino entre dos nodos.

Ejemplo 1:

Entrada: n = 3, gráfico = [[0, 1], [0, 2], [1, 2], [1, 2]], inicio = 0, objetivo = 2

salida: verdadero

Ejemplo 2:

Entrada: n = 5, gráfico = [[0, 1], [0, 2], [0, 4], [0, 4], [0, 1], [1, 3], [1, 4] , [1, 3], [2, 3], [3, 4]], inicio = 0, objetivo = 4

salida verdadera

insinuación:

El número de nodos n está en el rango [0, 1e5].

El número de nodo es mayor o igual a 0 y menor que n.

Puede haber bucles propios y bordes paralelos en el gráfico.

2. Análisis del pensamiento:

Idea 1: primero establezca la matriz de estado de acceso

Búsqueda recursiva usando DFS "búsqueda primero en profundidad"

Comprima gradualmente el rango de búsqueda hasta que finalmente se encuentre que el inicio y el objetivo están en la misma ruta, lo que indica que la búsqueda es exitosa

Cuando se produce un lazo cerrado, se da una situación de lazo infinito, y en cada proceso recursivo se debe marcar el camino que se ha tomado.

Al buscar recursivamente en orden positivo, habrá un tiempo de espera, por lo que se utiliza el método de búsqueda en orden inverso para resolverlo.

Idea dos:

Construir Mapa<Entero,Lista>

Hacer un recorrido primero en profundidad

Determinar si el nodo actual tiene un nodo de ruta en el mapa

Utilice HashSet para registrar los nodos que se han visitado.

3. Código de CA:

Idea uno:

    class AnimalShelf {
        private boolean[] visitArray = null;

        public boolean findWhetherExistsPath(int n, int[][] graph, int start, int target) {
            this.visitArray = new boolean[graph.length];
            return helpful(graph, start, target);
        }

        private boolean helpful(int[][] graph, int start, int target) {
            for (int i = 0; i < graph.length; ++i) {
                if (!visitArray[i]) {
                    if (graph[i][0] == start && graph[i][1] == target) return true;
                    visitArray[i] = true;
                    if (graph[i][1] == target && helpful(graph, start, graph[i][0])) return true;
                    visitArray[i] = false;
                }
            }
            return false;
        }
    }
复制代码

Idea dos:

    class Solution {
        Set<Integer> visitSet = new HashSet<>();

        public boolean findWhetherExistsPath(int n, int[][] graph, int start, int target) {
            Map<Integer, List<Integer>> tempMap = new HashMap<>();
            for (int[] a : graph) {
                tempMap.computeIfAbsent(a[0], o -> new ArrayList<>()).add(a[1]);
            }
            if (start == target) {
                return true;
            }
            if (!tempMap.containsKey(start)) {
                return false;
            }
            return DFS(start, target, tempMap);

        }

        public boolean DFS(int current, int target, Map<Integer, List<Integer>> midMap) {
            if (current == target) {
                return true;
            }
            if (!midMap.containsKey(current)) {
                return false;
            }
            visitSet.add(current);
            for (int val : midMap.get(current)) {
                if (!visitSet.contains(val)) {
                    if (DFS(val, target, midMap)) {
                        return true;
                    }
                }
            }
            return false;
        }
    }
复制代码