堂堂互联网大厂，这么龌龊的事也干的出来。|boolean|dfs|spiderlinebreak|互联网|算法|起始点

最近看到一篇文章，标题是“一个月被AI大厂投诉4次，我招谁惹谁了”。仔细看了下文章发现很有意思，文章中描述自己的账号多次被投诉，投诉的原因是昵称侵权。

该网友说自己是在10多年前自媒体兴起的时候注册了一个叫“千问”的公众号，总共就发表了23篇文章，后来基本上就停更了，结果在2025年11月份开始，陆续收到昵称侵权的投诉，结果腾讯还算是比较公正，一直不承认侵权，一次次投诉全部失败。

人家是10年前就注册了，你是现在才使用这个昵称，结果你投诉别人昵称侵权，这无论如何也说不过去啊，如果真的想要这个昵称直接花钱买下来不就行了，前段时间还花十几个亿搞活动，现在花个几万块钱买下来，就做不到了？直接投诉别人昵称侵权，这么龌龊的事也能干的出来。

--------------下面是今天的算法题--------------

来看下今天的算法题，这题是LeetCode的第1971题：寻找图中是否存在路径，难度是简单。

有一个具有 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
不存在重复边
不存在指向顶点自身的边

问题分析

这题给出一个起始点和一个终点，让判断是否有从起始点到终点的路径，这是一道非常简单的题。我们直接使用深度优先搜索（DFS），从起始点开始搜索，只要能搜索到终点就返回true，如果相邻的点全部都搜索完，没有找到终点则返回false。

对于图的搜索，还需要使用一个数组vis来记录哪些点是搜索过的，防止重复搜索陷入死循环。

JAVA：

public boolean validPath(int n, int[][] edges, int source, int destination) {
    // 图的邻接矩阵转化为邻接表
    List 
                  
 [] g =  
         new List[n];
    for (int i = 0; i < n; i++)
        g[i] = new ArrayList<>();
    for (int[] edge : edges) {
        g[edge[0]].add(edge[1]);
        g[edge[1]].add(edge[0]);
    }
    boolean[] vis = newboolean[n];
    vis[source] = true;// 起始点
    return dfs(g, source, destination, vis);
}


 private boolean dfs(List 
 
 [] g,  
 int start, int end, boolean[] vis) {
    if (start == end)// 如果起始点能到达终点，返回true。
        returntrue;
    vis[start] = true;
    for (int next : g[start]) {// 遍历当前位置所有邻接点。
        if (!vis[next] && dfs(g, next, end, vis))
            returntrue;
    }
    returnfalse;
}

C++：

public:
    bool validPath(int n, vector 
                       
            int 
            >> &edges,  
            int 
             source,  
            int 
             destination) 
            {
        // 构建邻接表
        vector 
                     
           int 
           >> g(n); 
           
 
                    
           for 
            (auto &edge: edges) { 
           
 
                        
           int 
            u = edge[ 
           0 
           ]; 
           
 
                        
           int 
            v = edge[ 
           1 
           ]; 
           
 
                       g[u].push_back(v); 
           
 
                       g[v].push_back(u); 
           
 
                   } 
           
 
           
 
                    
           // 访问标记数组 
           
 
                    
           vector 
                          
   
             vis(n, false) 
           ; 
           
 
                   vis[source] =  
           true 
           ; 
           
 
                    
           return 
            dfs(g, source, destination, vis); 
           
 
               } 
           
 
           
 
                
           bool dfs(vector 
                             
               int 
               >> &g,  
               int 
                start,  
               int 
                end, vector 
                                
 &vis) 
                 
               {
        // 到达目标节点，返回true
        if (start == end)
            returntrue;
        vis[start] = true;
        // 遍历所有邻接节点
        for (int next: g[start]) {
            if (!vis[next] && dfs(g, next, end, vis))
                returntrue;
        }
        returnfalse; // 所有路径都遍历完，无法到达
    }