0 结果

1 题目

2 思路

使用DFS算法（深度遍历算法），仅加入源点，然后使用DFS从该点遍历，如果途中遍历到目的点，那就说明源点到目的点存在路径。

3 代码

#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;

class Solution {
public:
    bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
        bool vis[n];
        std::fill(vis, vis + n, 0);
        //邻接矩阵
//        int G[n + 1][n + 1];//测试值有5000
//        std::memset(G, 0, sizeof(G));
//        for(int i = 0;i < edges.size();i++){
//            int u = edges[i][0];
//            int v = edges[i][1];
//            G[u][v] = 1;
//            G[v][u] = 1;
//        }
        //邻接表
        vector<int> G[n];
        for (int i = 0;i < edges.size();i++){
            int u = edges[i][0];
            int v = edges[i][1];
            G[u].push_back(v);
            G[v].push_back(u);
        }

        bool isFind = false;
        auto DFS = [&vis, &G, &isFind, destination, n](int u, int depth)->void {
            auto f = [&](auto&& self, int u, int depth)->void {
                if(u == destination){
                    isFind = true;
                    return ;
                }
                vis[u] = true;
//                for(int v = 0;v < n;v++){//邻接矩阵
//                    if(vis[v] == false && G[u][v] != 0){
//                        self(self, v, depth + 1);
//                    }
//                }
                for(int i = 0;i < G[u].size();i++){//邻接表
                    int v = G[u][i];
                    if(vis[v] == false){
                        self(self, v, depth + 1);
                    }
                }

            };
            return f(f, u, depth);
        };

        DFS(source, 0);

        return isFind;
    }
};

测试代码：

    vector<vector<int>> edges{{0,7}, {0,8}, {6,1}, {2,0}, {0,4}, {5,8}, {4,7}, {1,3}, {3,5}, {6,5}};
//    vector<vector<int>> edges{{0,1}, {1,2}, {2,0}};
//    vector<vector<int>> edges{{0,1}, {0,2}, {3,5}, {5, 4}, {4,3}};
    Solution s;
    cout<<s.validPath(10, edges, 7, 5);