思路：搜索，或者用并查集

搜索的话，其实作者有一个想法，就是用昨天的那个无向图数组来存储每个顶点是否存在边。但是一看长度，靠，怎么那么多，就放弃了开二维的想法。

于是就采用了当时做树状dp的vector存储，也就是把那个父节点下面的子节点那个数组变成了与这一个点有关联的点的集合。（其实就是换了一种含义）

这里的dfs是一种比较新颖的用法（个人认为），也就是提前dfs递归下去知道结果，然后在反过来判断这里的条件，根据以前做的acwing火柴棒剪枝那道题的dfs用法是一样的。

所以这里做一个小总结：当判断某个状态是否符合条件的题目时，如果要用dfs，可以设成Bool类型，然后用这里的dfs递归下去。（下面是C++写的）

class Solution {
public:
bool dfs(int source,int destination,vector<vector<int>>&s,vector<bool>&st){
    if(source==destination)
    return true;
    st[source]=true;
    for(int i=0;i<s[source].size();i++){
        int tmp=s[source][i];
        if(!st[tmp]&&dfs(tmp,destination,s,st)){
            return true;
        }
    } 
    return false;
}
    bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
        int len=edges.size();
        vector<vector<int>>s(n);
        vector<bool>st(n,false);
        for(int i=0;i<len;i++){
            int x=edges[i][0];
            int y=edges[i][1];
            s[x].emplace_back(y);
            s[y].emplace_back(x);
        }
        return dfs(source,destination,s,st);
    }
};

搜索的话就用dfs和bfs都可以做出来，但是并查集更简单一点，我们在把这些结点构成一个并查集之后看一看起点和终点是不是存在一个共同的根就行了。（java）

上代码：

class Solution {
    int []f=new int[200010];
    public int find(int x){
        if(f[x]==x)
        return x;
        else
        return f[x]=find(f[x]);
    }
    public void unit(int x,int y){
        int s=find(x);
        if(s==find(y))
        return;
        else
        f[s]=find(y);
    }
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        for(int i=0;i<n;i++){
            f[i]=i;
        }
        for(int i=0;i<edges.length;i++){
            unit(edges[i][0],edges[i][1]);
        }
        return find(destination)==find(source)?true:false;
    }
}