算法-图-查找路径

力扣题目：1971. 寻找图中是否存在路径 - 力扣（LeetCode）

有一个具有 n 个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含 0 和 n - 1）。图中的边用一个二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示顶点 ui 和顶点 vi 之间的双向边。 每个顶点对由 最多一条 边连接，并且没有顶点存在与自身相连的边。

请你确定是否存在从顶点 source 开始，到顶点 destination 结束的 有效路径 。

给你数组 edges 和整数 n、source 和 destination，如果从 source 到 destination 存在 有效路径 ，则返回 true，否则返回 false 。

示例 1：

输入：n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2
输出：true
解释：存在由顶点 0 到顶点 2 的路径:
- 0 → 1 → 2 
- 0 → 2

示例 2：

输入：n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5
输出：false
解释：不存在由顶点 0 到顶点 5 的路径.

提示：

• 1 <= n <= 2 * 10^5
• 0 <= edges.length <= 2 * 10^5
• edges[i].length == 2
• 0 <= ui, vi <= n - 1
• ui != vi
• 0 <= source, destination <= n - 1
• 不存在重复边
• 不存在指向顶点自身的边

算法如下

package com.dji.sample.accessControlDf;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class Solution {
    //用DFS深度优先遍历解决,
    public  boolean validPath(int n, int[][] edges, int source, int destination) {
        //标记数组
        boolean []flagArr=new boolean[n];
        //构造邻接矩阵,内存会超出限制
//        int[][] vG=new int [n][n];
//        //这样构造需要的存储空间太大了
//        for(int i=0;i<edges.length;i++)
//        {
//            vG[edges[i][0]][edges[i][1]]=1;
//            vG[edges[i][1]][edges[i][0]]=1;
//        }
        List<Integer>[] adj = new List[n];
        for (int i = 0; i < n; i++) {
            adj[i] = new ArrayList<Integer>();
        }
        //添加无向图
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            adj[x].add(y);
            adj[y].add(x);
        }

//   dfs     dfsSearch(vG,source,flagArr,destination);
        //用bfs
        //队列存储标记点
        Queue<Integer> queue=new ArrayDeque<>();
        //出发点入队
        queue.offer(source);
//        bfsSearch(vG,flagArr,source,destination,queue);
        bfs(adj,source,destination,flagArr,queue);
        return flagArr[destination];
    }
    //DFS深度优先递归，内存、时间会超出限制
    public void dfsSearch(int [][] vG,int v,boolean[] flagArr,int destination)
    {
        //节点v被访问
        flagArr[v]=true;
        //优化：如果访问到目的地结束
        if(destination==v)
        {
            return;
        }
        for(int i=0;i<vG.length;i++)
        {
            if(vG[v][i]==1&&flagArr[i]==false)
            {
                //递归访问邻居节点，如果没有就回退
                dfsSearch(vG,i,flagArr,destination);
            }
        }
    }
    public void bfsSearch(int[][] vG, boolean[] flagArr,int v, int destination, Queue<Integer> queue)
    {
        flagArr[v]=true;

        while (!queue.isEmpty())
        {
            //队头出队
            int vHead=queue.poll();
            //访问队头所在的邻接矩阵
            for(int i=0;i<vG.length;i++)
            {
                if(vG[vHead][i]==1&&flagArr[i]==false)
                {
                    //入队
                    queue.offer(i);
                    //标记为访问
                    flagArr[i]=true;
                    if(i==destination)
                    {
                        return;
                    }
                }
            }
        }

    }
    public void bfs(List<Integer>[] adj,int source,int destination,boolean[]flagArr,Queue<Integer> queue )
    {
        //队头已经被访问
        flagArr[source]=true;
        while (!queue.isEmpty())
        {
            //队头出队
            int vHead= queue.poll();
            //访问队头所在的邻接矩阵
            List<Integer> nodeList=adj[vHead];
            for(Integer i:nodeList)
            {
                if(flagArr[i]==false)
                {
                    flagArr[i]=true;
                    //入队
                    queue.offer(i);
                    if(i==destination)
                    {
                        return;
                    }
                }
            }

        }

    }

}