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 <unordered_set>

int main(){
    int n;
    int m;
    std::scanf("%d", &n);
    std::scanf("%d", &m);
    static std::unordered_set<int> relations[100000];
    int rCount = 0;
    for(int i = 0; i < m; ++i){
        int s;
        int t;
        std::scanf("%d", &s);
        std::scanf("%d", &t);
        bool find = false;
        for(int j = 0; j < rCount; ++j){
            if(relations[j].find(s) != relations[j].end()){
                if(relations[j].find(t) == relations[j].end()){
                    relations[j].insert(t);
                }
                find = true;
                break;
            } else if(relations[j].find(t) != relations[j].end()){
                if(relations[j].find(s) == relations[j].end()){
                    relations[j].insert(s);
                }
                find = true;
                break;
            }
        }
        if(find == false){
            relations[rCount].insert(s);
            relations[rCount].insert(t);
            ++rCount;
        }
    }
    int q;
    std::scanf("%d", &q);
    for(int i = 0; i < q; ++i){
        int s;
        int t;
        std::scanf("%d", &s);
        std::scanf("%d", &t);
        bool find = false;
        for(int j = 0; j < rCount; ++j){
            if(relations[j].find(s) != relations[j].end() && relations[j].find(t) != relations[j].end()){
                find = true;
                break;
            }
        }
        if(find){
            std::printf("yes\n");
        } else {
            std::printf("no\n");
        }
    }

    return 0;
}

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

const int MAX = 100000;
vector<int> G[MAX];

class DisjointSet{
public:
    vector<int> rank, parent;
    DisjointSet();
    DisjointSet(int size){
        rank.resize(size,0);
        parent.resize(size,0);
        for (int i=0; i<size; i++) {
            makeSet(i);
        }
    }

//    bool same(int u,int v){
//        if (parent[u] == parent[v]) {
//            return true;
//        }else{
//            return false;
//        }
//    }
    bool same(int u,int v){
        int x = findSet(u); int y= findSet(v);
        return x==y;
    }
    
    void unite(int u,int v){
        int x = findSet(u);int y= findSet(v);
        if(rank[x]<rank[y]){
            parent[x] = y;
        }else{
            parent[y] = x;
            if(rank[x]==rank[y]){
                rank[x]++;
            }
        }
    }
    // ????????????????????????
    int findSet(int u){
        
        if(u!=parent[u])
            parent[u] = findSet(parent[u]);
        
        return parent[u];
    }
private:
    void makeSet(int i){
        rank[i] = 0;
        parent[i] = i;
    }
};
    
int main(int argc, const char * argv[]) {
    
    int n,m;
    cin >> n >> m;
    DisjointSet ds(n);
    
    for(int i=0;i<m;i++){
        int s,t;
        cin >> s >> t;
        ds.unite(s, t);
    }
    int q;
    cin >> q;
    for(int i=0;i<q;i++){
        int s,t;
        cin >> s >> t;
        if(ds.same(s, t)) cout << "yes" << endl;
        else cout << "no" << endl;
    }
    return 0;
}

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


int n;

string *color;

queue<int> q;

int *ans;

vector<int> g[10000];


void bfs(int x){
  color[x] = "gray";
  q.push(x);


  while(q.size() != 0){
    int u = q.front();
    q.pop();

    for(int i = 0; i < g[u].size(); i++){
      int v = g[u][i];
      if(color[v] == "white"){
        color[v] = "gray";
        q.push(v);
      }
    }

    color[u] = "black";
    ans[u] = x;


  }
  cout << x << endl;
  return;
}


int main(){

  cin >> n;

  color = new string[n];

  ans = new int[n];

  int m;

  cin >> m;


  int a, b;


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


  for(int i = 0; i < n; i++){
    color[i] = "white";
  }


  for(int j = 0; j < n; j++){
    if(color[j] == "white"){
      bfs(j);
    }
  }

  int q;

  cin >> q;

  for(int i = 0; i < q; i++){
    cin >> a >> b;
    if(ans[a] == ans[b]){
      cout << "yes" << endl;
    }
    else{
      cout << "no" << endl;
    }
  }

  return 0;
}

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

bool isReachable(int k, int l, vector<vector<int> > node) {
	int n=(int)node.size();
	int i;
	int m;
	queue<int> qnode;
	vector<int> visited;
	visited.resize(n);
	for(i=0; i<n; ++i) {
		visited[i]=0;
	}
	visited[k]=1;
	qnode.push(k);
	while(!qnode.empty()) {
		m=qnode.front();
		for(i=0; i<(int)node[m].size(); ++i) {
			if(node[m][i]==l) {
				return true;
			} else {
				if(visited[node[m][i]]==0) {
					qnode.push(node[m][i]);
					visited[node[m][i]]=1;
				}
			}
		}
		qnode.pop();
	}
	return false;
}

int main() {
	int m,n,k,l;
	int q;
	int i;
	vector<vector<int> > node;
	scanf("%d%d",&n,&m);
	node.resize(n);
	for(i=0; i<m; ++i) {
		scanf("%d%d",&k,&l);
		node[k].push_back(l);
		node[l].push_back(k);
	}
	scanf("%d",&q);
	for(i=0; i<q; ++i) {
		scanf("%d%d",&k,&l);
		printf((isReachable(k,l,node)?"yes\n":"no\n"));
	}
	return 0;
}