from collections import defaultdict, deque
 
def valid_path(n, edges, source, destination):
    if source == destination: return True
    adj = defaultdict(list)
    for u, v in edges:
        adj[u].append(v); adj[v].append(u)
 
    visited = {source}
    queue = deque([source])
    while queue:
        u = queue.popleft()
        for v in adj[u]:
            if v == destination: return True
            if v not in visited:
                visited.add(v)
                queue.append(v)
    return False

#include <vector>
#include <queue>
#include <unordered_set>
using namespace std;
 
bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
    if (source == destination) return true;
    vector<vector<int>> adj(n);
    for (auto& e : edges) {
        adj[e[0]].push_back(e[1]);
        adj[e[1]].push_back(e[0]);
    }
    unordered_set<int> visited{source};
    queue<int> q; q.push(source);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int v : adj[u]) {
            if (v == destination) return true;
            if (!visited.count(v)) { visited.insert(v); q.push(v); }
        }
    }
    return false;
}

import java.util.*;
 
public boolean validPath(int n, int[][] edges, int source, int destination) {
    if (source == destination) return true;
    List<List<Integer>> adj = new ArrayList<>();
    for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
    for (int[] e : edges) {
        adj.get(e[0]).add(e[1]);
        adj.get(e[1]).add(e[0]);
    }
    Set<Integer> visited = new HashSet<>();
    visited.add(source);
    Deque<Integer> q = new ArrayDeque<>();
    q.offer(source);
    while (!q.isEmpty()) {
        int u = q.poll();
        for (int v : adj.get(u)) {
            if (v == destination) return true;
            if (visited.add(v)) q.offer(v);
        }
    }
    return false;
}

def valid_path(n, edges, source, destination):
    adj = defaultdict(list)
    for u, v in edges:
        adj[u].append(v); adj[v].append(u)
 
    stack = [source]
    visited = {source}
    while stack:
        u = stack.pop()
        if u == destination: return True
        for v in adj[u]:
            if v not in visited:
                visited.add(v)
                stack.append(v)
    return False

bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
    vector<vector<int>> adj(n);
    for (auto& e : edges) { adj[e[0]].push_back(e[1]); adj[e[1]].push_back(e[0]); }
    vector<int> stack{source};
    vector<bool> visited(n, false);
    visited[source] = true;
    while (!stack.empty()) {
        int u = stack.back(); stack.pop_back();
        if (u == destination) return true;
        for (int v : adj[u]) {
            if (!visited[v]) { visited[v] = true; stack.push_back(v); }
        }
    }
    return false;
}

public boolean validPath(int n, int[][] edges, int source, int destination) {
    List<List<Integer>> adj = new ArrayList<>();
    for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
    for (int[] e : edges) { adj.get(e[0]).add(e[1]); adj.get(e[1]).add(e[0]); }
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(source);
    boolean[] visited = new boolean[n];
    visited[source] = true;
    while (!stack.isEmpty()) {
        int u = stack.pop();
        if (u == destination) return true;
        for (int v : adj.get(u)) {
            if (!visited[v]) { visited[v] = true; stack.push(v); }
        }
    }
    return false;
}

def valid_path(n, edges, source, destination):
    parent = list(range(n))
    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]      # path compression
            x = parent[x]
        return x
    def union(a, b):
        parent[find(a)] = find(b)
 
    for u, v in edges:
        union(u, v)
    return find(source) == find(destination)

class UnionFind {
    vector<int> parent;
public:
    UnionFind(int n) : parent(n) { iota(parent.begin(), parent.end(), 0); }
    int find(int x) {
        while (parent[x] != x) { parent[x] = parent[parent[x]]; x = parent[x]; }
        return x;
    }
    void unite(int a, int b) { parent[find(a)] = find(b); }
};
 
bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
    UnionFind uf(n);
    for (auto& e : edges) uf.unite(e[0], e[1]);
    return uf.find(source) == uf.find(destination);
}

public boolean validPath(int n, int[][] edges, int source, int destination) {
    int[] parent = new int[n];
    for (int i = 0; i < n; i++) parent[i] = i;
    for (int[] e : edges) union(parent, e[0], e[1]);
    return find(parent, source) == find(parent, destination);
}
private int find(int[] p, int x) {
    while (p[x] != x) { p[x] = p[p[x]]; x = p[x]; }
    return x;
}
private void union(int[] p, int a, int b) { p[find(p, a)] = find(p, b); }