Go: package main

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

const (
	MAX = 100000
	NIL = -1
)

var (
	n     int
	G     [MAX][]int
	color [MAX]int
)

func DFS(r int, c int) {
	S := list.New()
	S.PushFront(r)
	color[r] = c
	for S.Len() != 0 {
		u := S.Remove(S.Front()).(int)
		for i := 0; i < len(G[u]); i++ {
			v := G[u][i]
			if color[v] == NIL {
				color[v] = c
				S.PushFront(v)
			}
		}
	}
}

func assignColor() {
	id := 1
	for i := 0; i < n; i++ {
		color[i] = NIL
	}
	for i := 0; i < n; i++ {
		if color[i] == NIL {
			id++
			DFS(i, id)
		}
	}
}

func main() {
	var s, t, m, q int
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Scan()
	n, _ = strconv.Atoi(scanner.Text())
	scanner.Scan()
	m, _ = strconv.Atoi(scanner.Text())
	for i := 0; i < m; i++ {
		scanner.Scan()
		s, _ = strconv.Atoi(scanner.Text())
		scanner.Scan()
		t, _ = strconv.Atoi(scanner.Text())
		if i == 0 {
			G[s] = make([]int, 0)
			G[t] = make([]int, 0)
		}
		G[s] = append(G[s], t)
		G[t] = append(G[t], s)
	}

	assignColor()
	scanner.Scan()
	q, _ = strconv.Atoi(scanner.Text())
	for i := 0; i < q; i++ {
		scanner.Scan()
		s, _ = strconv.Atoi(scanner.Text())
		scanner.Scan()
		t, _ = strconv.Atoi(scanner.Text())
		if color[s] == color[t] {
			fmt.Println("yes")
		} else {
			fmt.Println("no")
		}
	}
}

C++: #include <cstdio>
#include <iostream>
#include <cmath>
#include <ctype.h>
#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <map>
#include <queue>
#include <utility>
#include <vector>
#include <set>
#include <list>
#include <cstring>
#include <stack>

using namespace std;

#define mod 1000000007

class UF
{
private:
	vector<int> root;

public:
	UF(int n)
	{
		root = vector<int>(n + 1, -1);
	}

	int getroot(int n)
	{
		if(root[n] == -1) return n;
		else return root[n] = getroot(root[n]);
	}

	void add(int x, int y)
	{
		x = getroot(x);
		y = getroot(y);
		if(x == y) return;
		if(x > y) swap(x, y);
		root[y] = x;
		return;
	}
};

int main()
{
	int n, m;
	cin >> n >> m;
	UF uf(n);
	for(int i = 0; i < m; i++){
		int s, t;
		cin >> s >> t;
		uf.add(s, t);
	}
	int q;
	cin >> q;
	for(int i = 0; i < q; i++){
		int s, t;
		cin >> s >> t;
		if(uf.getroot(s) == uf.getroot(t)) cout << "yes" << endl;
		else cout << "no" << endl;
	}
	return 0;
}

C++: #include <cstdio>
#include <algorithm>
#include <unordered_map>
#include <vector>
int main(){
    int n;
    int m;
    std::scanf("%d", &n);
    std::scanf("%d", &m);

    std::unordered_map<int, int> map;
    for(int i = 0; i < m; ++i){
        int s;
        int t;
        std::scanf("%d", &s);
        std::scanf("%d", &t);
        if(map.find(s) == map.end() && map.find(t) == map.end()){
            int small = std::min(s, t);
            int large = std::max(s, t);
            map.insert(std::make_pair(small, small));
            map.insert(std::make_pair(large, small));
        } else if(map.find(s) == map.end()){
            int key = map[t];
            while(key != map[key]){
                key = map[key];
            }
            if(key <= s){
                map.insert(std::make_pair(s, key));
            } else {
                map[key] = s;
                map.insert(std::make_pair(s, s));
            }
        } else if(map.find(t) == map.end()){
            int key = map[s];
            while(key != map[key]){
                key = map[key];
            }
            if(key <= t){
                map.insert(std::make_pair(t, key));
            } else {
                map[key] = t;
                map.insert(std::make_pair(t, t));
            }
        } else {
            int keys = map[s];
            while(keys != map[keys]){
                keys = map[keys];
            }
            int keyt = map[t];
            while(keyt != map[keyt]){
                keyt = map[keyt];
            }
            int small = std::min(keys, keyt);
            int large = std::max(keys, keyt);
            map[large] = small;
        }
    }
    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);

	int keys = map[s];
        while(keys != map[keys]){
            keys = map[keys];
        }
        int keyt = map[t];
        while(keyt != map[keyt]){
            keyt = map[keyt];
        }
        if(keys == keyt){
            std::printf("yes\n");
        } else {
            std::printf("no\n");
        }
    }

    return 0;
}

C++: #include<iostream>
#include<vector>
using namespace std;
int cnt=1;
struct Point{
	int x;
	int y;
};

bool depth(vector< vector<int> > &vv,vector<int> &f,int num1,int num2){
	
	f[num1]=cnt;
	cnt++;
	
	for(int i=0; i<vv[num1].size(); i++){
		if(vv[num1][i]!=0 && f[i]==0){
			depth(vv,f,i,num2);
		}
	}

	if(f[num2]!=0){
		return 1;
	}else{
		return 0;
	}	

}
int main(){
	int n,m,l;
	cin>>n>>m;
	vector< vector<int> > v(n,vector<int> (n,0));
	for(int i=0; i<m; i++){
		Point a;
		cin>>a.x>>a.y;
		v[a.x][a.y]=1;
	}
	cin>>l;
	vector<string> ans(l);
	for(int i=0; i<l; i++){
		Point b;
		cin>>b.x>>b.y;
		vector<int> ft(n,0);
		if(depth(v,ft,b.x,b.y)){
			ans[i]="yes";
		}else{
			ans[i]="no";
		}
	}
	for(int i=0; i<l; i++){
		cout<<ans[i]<<endl;
	}
  return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#define Lens 100005
#define Nil -1

using namespace std;
int n, m, q;
queue<int> Q;
vector<int> A[Lens];
int c[Lens], d[Lens];

void bns(int k, int v)
{
	Q.push(k);
	c[k] = v;
	while (!Q.empty())
	{
		k = Q.front();
		Q.pop();
		c[k] = v;
		for (int i = 0; i < A[k].size(); i++)
		{
			int tmp = A[k][i];
			if (c[tmp] == Nil)
			{
				Q.push(tmp);
			}
		}
	}
}

int main()
{
	int v = 1;
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		int s, t;
		cin >> s >> t;
		c[s] = c[t] = Nil;
		A[s].push_back(t);
		A[t].push_back(s);
	}
	for (int i = 0; i < n; i++)
	{
		if (c[i] == Nil)
		{
			bns(i, v);
			v++;
		}

	}
	cin >> q;
	for (int i = 0; i < q; i++)
	{
		int s, t;
		cin >> s >> t;

		if (c[s] == c[t]&&c[s]!=Nil&&c[s]!=0)
			cout << "yes" << endl;
		else
			cout << "no" << endl;
	}
	return 0;
}

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

vector<int>graph[100001];
bool visit[100001];
int d[100001];
int n;
int tim;

void dfs(int now,int t){
  visit[now] = false;
  
  d[now] = t;
  for (int i = 0; i < graph[now].size() ; ++i) {
    if ( visit[graph[now][i]] ){
      dfs(graph[now][i],t);
    }
  }

  return;
}

main()
{
  int m, q;
  int s, t;
  
  scanf("%d %d", &n, &m);
  for ( int i = n; i < n*2 ; ++i) {
    d[i - n] = i;
    visit[i-n] = true;
  }

  for ( int i = 0; i < m ; ++i) {
    scanf("%d %d", &s, &t);
    graph[s].push_back(t);
    graph[t].push_back(s);
  }

  for ( int i = 0; i < n ; ++i) {
    if ( visit[i] ) {
      dfs(i,tim);
      tim++;
    }
  }
  
  scanf("%d", &q);
  for ( int i = 0; i < q ; ++i) {
    scanf("%d %d", &s, &t);
    if ( d[s] == d[t] ) {
      printf("yes\n");
    } else {
      printf("no\n");
    }
  }

  return (0);
}