Go: package main

import (
	"fmt"
)

var n, m int
var g [][]int
var color []int

func main() {
	fmt.Scan(&n, &m)
	g = make([][]int, n) // SNSの関係を表すグラフ
	for i := 0; i < m; i++ {
		var a, b int
		fmt.Scan(&a, &b)
		g[a] = append(g[a], b) // 無向重みなしグラフ
		g[b] = append(g[b], a)
	}
	color = make([]int, n) // 各ノードにつける色
	for i := 0; i < len(color); i++ {
		color[i] = -1 // 初期化しておく
	}
	type query struct {
		s, t int
	}
	var Q int
	fmt.Scan(&Q)
	qs := make([]query, Q)
	for i := 0; i < Q; i++ {
		fmt.Scan(&qs[i].s, &qs[i].t)
	}
	// fmt.Println("n", n, "m", m, "g", g, "Q", Q, "qs", qs)
	// 全ての頂点からdfsする
	id := 1
	for u := 0; u < n; u++ {
		if color[u] == -1 {
			dfs(u, id)
			id++
		}
	}
	// fmt.Println("color", color)
	for i := 0; i < Q; i++ {
		if color[qs[i].s] == color[qs[i].t] {
			fmt.Println("yes")
		} else {
			fmt.Println("no")
		}
	}
}

func dfs(v, c int) {
	// fmt.Printf("dfs(v %d, c %d) en:\n", v, c)
	color[v] = c
	for _, vv := range g[v] {
		// fmt.Printf("  v %d, g[v] %v, vv %d\n", v, g[v], vv)
		if color[vv] == -1 {
			dfs(vv, c)
		}
	}
}

C++: #include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

struct Edge
{
  int from;
  int to;

  friend bool operator==(const Edge &l, const Edge &r)
  {
    return l.from == r.from && l.to == r.to;
  }
};

int main()
{
  int n, m, v1, v2;
  scanf("%d%d", &n, &m);
  vector<Edge> v;

  for (int i = 0; i < m; i++)
  {
    scanf("%d%d", &v1, &v2);
    v.push_back({v1, v2});
  }

  int group[n];
  for (int i = 0; i < n; i++)
    group[i] = -1;

  int id = 0;
  while (!v.empty())
  {
    queue<Edge> q;
    q.push(v.front());
    while (!q.empty())
    {
      Edge edge = q.front();
      q.pop();
      group[edge.from] = id;
      group[edge.to] = id;
      v.erase(remove(v.begin(), v.end(), edge), v.end());
      // auto itr = find(v.begin(), v.end(), edge);
      // if (itr != v.end())
      //   v.erase(itr);
      for (auto const &e : v)
        if (e.from == edge.from || e.to == edge.from || e.from == edge.to || e.to == edge.to)
          q.push(e);
    }
    id++;
  }

  int q;
  scanf("%d", &q);

  for (int i = 0; i < q; i++)
  {
    scanf("%d%d", &v1, &v2);
    if (group[v1] != -1 && group[v1] == group[v2])
      printf("yes\n");
    else
      printf("no\n");
  }

  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <stack>
using namespace std;
#define maxn 10005
#define NTL -1
int color[maxn];
vector<int> g[maxn];
stack<int> s;
int n,m,q;
void tarjan(int r,int c)
{
    s.push(r);
    color[r]=c;
    while(!s.empty())
    {
        int u=s.top();
        s.pop();
        for(int i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            if(color[v]==NTL)
            {
                color[v]=c;
                s.push(v);
            }
        }
    }
}
void assigncolor()
{
    int id=0;
    for(int i=0;i<n;i++)
        color[i]=NTL;
    for(int u=0;u<n;u++)
    {
        if(color[u]==NTL)
            tarjan(u,id++);
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    assigncolor();
    scanf("%d",&q);
    for(int i=0;i<q;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        if(color[u]==color[v])
            printf("yes\n");
        else
            printf("no\n");
    }
    return 0;
}

C++: #include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<list>
#include<map>
#include<set>
using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef stack<int> SI;
typedef queue<int> QI;
typedef pair<int,int> PII;
typedef long long LL;

#define d(x)  cout<<#x<<" = "<<(x)<<endl;
#define c cout<<"#"<<endl;
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define REACH(i,c) for(typeof((c).rbegin()) i=(c).rbegin(); i!=(c).rend(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c,n) sort(c,c+n)
#define VSORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define DFOR(i,b,a) for(int i=(b)-1;i>=(a);--i)
#define DREP(i,n) DFOR(i,n,0)
#define INF 2000000000

const double EPS = 1e-10;
const double PI  = acos(-1.0);
////////////////////////////////////////////////
VVI a;
int n,b,d[100010],p[100010];
QI q;
int main()
{
	//??£????????????????????????
	cin>>n>>b;
	REP(i,n+1)
	{
		a.push_back({0});
	}
	REP(i,b)
	{
		int s,t;cin>>s>>t;s++;t++;
		a[s][0]++;
		a[s].push_back(t);
		a[t][0]++;
		a[t].push_back(s);
	}
	FOR(i,1,n+1)
	{
		sort(&a[i][1],&a[i][a[i][0]+1]);
	}
	
	REP(i,n+1)p[i]=1,d[i]=0;
	d[1]=1;
	int g=1;
	for(q.push(1);SZ(q)!=0;)
	{
		int u=q.front();
		q.pop();
		for(;p[u]<=a[u][0];)
		{
			int v=a[u][p[u]];p[u]++;
			if(v!=1&&d[v]==0)
			{
				d[v]=g;
				q.push(v);
			}
		}
		if(q.empty())
		{
			int i;
			for(i=2;d[i]!=0;i++);
			if(i==n+1)
			{
				break;
			}
			else
			{
				g++;
				q.push(i);
			}
		}
	}
	cin>>n;
	REP(i,n)
	{
		int first,second;
		cin>>first>>second;first++;second++;
		if(d[first]==d[second])cout<<"yes"<<endl;
		else cout<<"no"<<endl;
	}
	return 0;
}

C++: import sys
sys.setrecursionlimit(10000)
def dfs(s):
    global t
    if s == t:
        return True
    DP[s]=1
    for i in F[s]:
        if not DP[i]:
            if dfs(i):
                return True
    return False
    
n,m = [int(i) for i in input().split()]
F = [{} for i in range(n)]
for _ in range(m):
    i,j = [int(i) for i in input().split()]
    F[i][j] = 1
    F[j][i] = 1
q = int(input())
for i in range(q):
    DP = [0]*n
    s,t = [int(i) for i in input().split()]
    if dfs(s):
        print("yes")
    else:
        print("no")

C++: #include<iostream>
#include<vector>
#include<stack>
#include<set>
using namespace std;

bool DFS(vector<set<int> >& G, int a, int b) {
    if (G[a].size() == 0) return false;

    stack<pair<int, set<int>::iterator> > S;
    vector<bool> is_visited(G.size(), false);

    set<int>::iterator it = G[a].begin();
    do {
        if (it == G[a].end()) {
            int tmp = S.top().first;
            for (set<int>::iterator it2 = G[a].begin(); it2 != G[a].end(); it2++) {
                G[tmp].insert(*it2);
            }
            a   = S.top().first;
            it = S.top().second;
            S.pop();
            it++;
            continue;
        }
        if (*it == b) return true;
        if (!is_visited[*it]) {
            is_visited[*it] = true;
            if (G[a].find(b) != G[a].end()) return true;
            S.push(make_pair(a, it));
            a   = *it;
            it = G[a].begin();
            continue;
        }
        it++;
    } while (!S.empty());
    return false;
}


int main(){
    int n, m;
    cin >> n >> m;

    vector<set<int> > G(n);
// bool D[100000][100000];

    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        G[a].insert(b);
        G[b].insert(a);
    }

// for (int i = 0; i < n; i++) {
//     cout << i << " : ";
//     for (set<int>::iterator it = G[i].begin(); it != G[i].end(); it++){
//         cout << *it << " ";
//     }
//     cout << endl;
// }



    int q;
    cin >> q;
    for (int i = 0; i < q; i++) {
        int a, b;
        cin >> a >> b;
        if (DFS(G, a, b)) {
            cout << "yes" << endl;
        } else {
            cout << "no"  << endl;
        }
    }
    return 0;
}