Go: package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"container/list"
	"bytes"
)

const MaxNode int = 1e5

var graph [][] int
var color []int
var N int

func bfs(u, c int) {
	l := list.New()
	l.PushBack(u)
	for ;l.Len()!=0; {
		u = l.Front().Value.(int)
		color[u] = c
		l.Remove(l.Front())
		for i:=0; i<len(graph[u]); i++ {
			if color[graph[u][i]] == 0 {
				l.PushBack(graph[u][i])
			}
		}
	}
}

func assignColor() {
	id := 1
	for u:=0; u<N; u++ {
		if color[u] == 0 {
			bfs(u, id)
			id ++
		}
	}
}

func nextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	num, _ := strconv.Atoi(scanner.Text())
	return num
}


func buildGraph(scanner *bufio.Scanner) {
	N = nextInt(scanner)
	color = make([]int, N)
	graph = make([][]int, N)
	m := nextInt(scanner)
	for i:=0; i<m; i++ {
		n1 := nextInt(scanner)
		n2 := nextInt(scanner)
		graph[n1] = append(graph[n1], n2)
		graph[n2] = append(graph[n2], n1)
	}
}

func answer(scanner *bufio.Scanner) {
	var outBuffer bytes.Buffer
	cnt := nextInt(scanner)
	for i:=0; i<cnt; i++ {
		n1 := nextInt(scanner)
		n2 := nextInt(scanner)
		if color[n1] == color[n2] {
			outBuffer.WriteString("yes\n")
		} else {
			outBuffer.WriteString("no\n")
		}
	}
	fmt.Printf("%s", outBuffer.String())
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buildGraph(scanner)
	assignColor()
	answer(scanner)
}

C++: #include <stdio.h>
int ancestor[100000];
int find(int x){
    if(ancestor[x]==x)return x;
    return ancestor[x]=find(ancestor[x]);
}
int min(int a,int b){
    if(a<b)return a;
    return b;
}
int max(int a,int b){
    if(a>b)return a;
    return b;
}
int main(){
    int n,q,m,temp,x,y;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)ancestor[i]=i;
    for(int i=0;i<m;i++){
        scanf("%d%d",&x,&y);
        temp=find(x);
        q=find(y);
        ancestor[max(temp,q)]=min(temp,q);
    }
    scanf("%d",&q);
    for(int i=0;i<q;i++){
        scanf("%d%d",&x,&y);
        if(find(x)!=find(y))printf("no\n");
        else printf("yes\n");
    }
}

C++: #include <iostream>
#include <vector>
#include <stack>
using namespace std;
static const int MAX = 100000;
static const int NIL = -1;

int n;
vector<int> G[MAX];
int color[MAX];

void dfs(int r, int c)
{
    stack<int> S;
    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] == NIL)
            {
                color[v] = c;
                S.push(v);
            }
        }
    }
}

void assignColor()
{
    int id = 1;
    for(int i=0; i<n; i++) color[i] = NIL;
    for(int u=0; u<n; u++)
    {
        if(color[u] == NIL) dfs(u, id++);
    }
}



int main() 
{
    ios::sync_with_stdio(false);
    
    int s, t, m, q;

    cin >> n >> m;

    for(int i=0; i<m; i++)
    {
        cin >> s >> t;
        G[s].push_back(t);
        G[t].push_back(t);
    }

    assignColor();

    cin >> q;

    for(int i=0; i<q; i++)
    {
        cin >> s >> t;
        if(color[s] == color[t])
        {
            cout << "yes" << endl;
        }
        else
        {
            cout << "no" << endl;
        }
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

int n, m;

bool frend(vector<vector<int>> &M, vector<int> &memo, int i, int t) {
  if (memo[i] == 1) return false;
  int cnt = M[i].size();
  for (int z = 0; z < cnt; z++) {
    if (M[i][z] == t) return true;
    memo[i] = 1;
    if (frend(M, memo, M[i][z], t)) { return true; }
  }
  return false;
}

int main() {
  cin >> n >> m;
  vector<vector<int>> M(n);

  for (int i = 0; i < m; i++) {
    int id, f;
    cin >> id >> f;
    M[id].push_back(f);
    M[f].push_back(id);
  }
  int qn;
  cin >> qn;
  vector<vector<int>> q(qn, vector<int>(2));
  for (int i = 0; i < qn; i++) {
    cin >> q[i][0] >> q[i][1];
  }

  for (int i = 0; i < qn; i++) {
    vector<int> memo(n);
    bool res = frend(M, memo, q[i][0], q[i][1]);
    if (res) {
      cout << "yes" << endl;
    } else {
      cout << "no" << endl;
    }
  }
}

C++: #include <cstdio>

int parent[100001];

int find(int k)
{
  if (parent[k] == k) return k;
  return parent[k] = find(parent[k]);
}

void Union(int a, int b)
{
  int pa = find(a);
  int pb = find(b);
  parent[pa] = pb;
}

int main()
{
  int n, m;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; i++)
  {
    parent[i] = i;
  }
  while (m--)
  {
    int a, b;
    scanf("%d%d", &a, &b);
    Union(a, b);
  }
  int q;
  scanf("%d", &q);
  while (q--)
  {
    int a, b;
    scanf("%d%d", &a, &b);
    if (find(a) == find(b))
    {
      printf("yes\n");
    }
    else
    {
      printf("no\n");
    }
  }
}

C++: #include<iostream>
#include<vector>
#include<stack>

struct node {
	std::vector<int> relation;
};

void dfs(std::vector<node> &n) {
	int d[100000];

	std::stack<int> s;
	for (size_t i = 0; i < n.size(); i++) {
		s.push(i);
		for (int k = 0; k < 100000; k++) {
			d[k] = 0;
		}
		while (s.size() != 0) {
			int num = s.top(); s.pop();
			d[num] = 1;
			for (std::vector<int>::iterator it = n[num].relation.begin(); it != n[num].relation.end(); it++) {
				if (d[*it] == 1) {
					n[num].relation.erase(it);
					it--;
				} else {
					s.push(*it);
					d[*it] = 1;
				}
			}
		}
	}
}

bool isconnect(std::vector<node> n, int from, int to) {
	std::stack<int> s;
	s.push(from);
	while(s.size() != 0) {
		from = s.top(); s.pop();
		for (std::vector<int>::iterator it = n[from].relation.begin(); it != n[from].relation.end(); it++) {
			if (to == *it) return true;
			s.push(*it);
		}
	}
	return false;
}

int main() {
	int people, relation;
	
	std::cin >> people >> relation;

	std::vector<node> n(people);

	for (int i = 0; i < relation; i++) {
		int from, to;
		std::cin >> from >> to;
		n[from].relation.push_back(to);
	}

	dfs(n);

	int question;
	std::cin >> question;

	for (int i = 0; i < question; i++) {
		int from, to;
		std::cin >> from >> to;
		if (isconnect(n, from, to)) {
			std::cout << "yes" << std::endl;
		} else {
			std::cout << "no" << std::endl;
		}
	}

	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int v[N]={0};

int main(){
	int n,m,q;
	cin >> n >> m;
	for(int i=0;i<n;i++){
		v[i]=i;
	}
	for(int i=0;i<m;i++){
		int k,l;
		cin >> k >> l;
		v[l]=v[k];
	}
	cin >> q;
	for(int i=0;i<q;i++){
		int k,l;
		cin >> k >> l;
		if(v[k]==v[l])cout << "yes" << endl;
		else cout << "no" << endl;
	}

    return 0;
}

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

struct UnionFind{
    vector<int> parent;
    UnionFind(int size): parent(size, -1) {}
    
    int root(int x){
        return parent[x]<0? x: parent[x] = root(parent[x]);
    }
    void uniteSet(int x, int y){
        x = root(x);
        y = root(y);
        if (x==y) return;
        if (parent[x]>parent[y]) swap(x,y);
        //parent[x] += parent[y];
        parent[y] = x;
    }
    bool findSet(int x, int y){
        return root(x) == root(y);
    }
};

int main(){cin.tie(0);ios::sync_with_stdio(false);
    
    int nb_v, nb_lines;
    cin >>nb_v
        >>nb_lines;
    UnionFind G(nb_v);
    for(int i=0; i<nb_lines; ++i){
        int v1, v2;
        cin >>v1
            >>v2;
        G.uniteSet(v1,v2);
    }

    cin >>nb_lines;
    for(int i=0; i<nb_lines; ++i){
        int v1, v2;
        cin >>v1
            >>v2;
        cout<<(G.findSet(v1, v2)? "yes\n":"no\n");
    }    
}