Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	n := getNextInt(scanner)
	m := getNextInt(scanner)
	nodes := make([]Node, n)

	for i := 0; i < n; i++ {
		nodes[i].list = make([]int, 0)
	}

	for i := 0; i < m; i++ {
		s := getNextInt(scanner)
		t := getNextInt(scanner)
		nodes[s].list = append(nodes[s].list, t)
		nodes[t].list = append(nodes[t].list, s)
	}

	c := 1
	for i := 0; i < n; i++ {
		if nodes[i].c == 0 {
			traverse(nodes, i, c)
			c++
		}
	}

	q := getNextInt(scanner)

	for i := 0; i < q; i++ {
		s := getNextInt(scanner)
		t := getNextInt(scanner)
		if nodes[s].c == nodes[t].c {
			fmt.Fprintln(writer, "yes")
			continue
		}
		fmt.Fprintln(writer, "no")
	}

	writer.Flush()
}

// Node ...
type Node struct {
	list []int
	c    int
}

func traverse(nodes []Node, r, c int) {
	nodes[r].c = c
	for _, i := range nodes[r].list {
		if nodes[i].c != 0 {
			continue
		}
		traverse(nodes, i, c)
	}
}

C++: #include "bits/stdc++.h"
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(){
	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(s);
	}

	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++: //ALDS1_11D
#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(){
 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(s);
 }
 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++: // ALDS1_11_D.cpp
// Graph I - Connected Components

#include <iostream>
#include <vector>
using namespace std;

void dfs(vector<vector<int>> &sns, vector<int> &arrived, int x, int y)
{
    if (arrived[y] != 0 && arrived[x] == 2) return;
    arrived[x]++;
    for (int i = 0; i < sns[x].size(); i++) {
        int next = sns[x][i];
        if (arrived[next] == 0) {
            dfs(sns, arrived, next, y);
        }
    }
    arrived[x]++;
}

int main()
{
//    freopen("ALDS1_11_D_in22.txt", "r", stdin);
//    freopen("out22.txt", "w", stdout);
    int m, n, q;
    cin >> n >> m;
    vector<vector<int> > sns(n, vector<int>());
    int x, y;
    for (int i = 0; i < m; i++) {
        cin >> x >> y;
        sns[x].push_back(y);
        sns[y].push_back(x);
    }

    cin >> q;
    while (q--) {
        vector<int> arrived(n);
        cin >> x >> y;
        dfs(sns, arrived, x, y);
        if (arrived[y]) cout << "yes" << endl;
        else cout << "no" << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;

void dfs(const vvi &to, vi &id, int u, int val) {
    id[u] = val;
    for (int v: to[u]) {
        if (id[v] < 0) dfs(to, id, v, val);
    }
};

int main() {
    int n, m, s, t, q, u, v;
    cin >> n >> m;
    vvi to(n);
    for (int i=0; i<m; ++i) {
        cin >> s >> t;
        to[s].push_back(t);
        to[t].push_back(s);
    }
    vi id(n, -1);
    for (int i=0; i<n; ++i) {
        if (id[i] < 0) dfs(to, id, i, i);
    }
    cin >> q;
    for (int i=0; i<q; ++i) {
        cin >> u >> v;
        cout << (id[u] == id[v] ? "yes" : "no") << endl;
    }
    return 0;
}

C++: #include <stdio.h>

#define MAX_USER (100000)

/*

1)initial state

	0    1    2    3    4    5...

2)create friendship 
	friend: 0 and 1
	friend: 2 and 3

	0    2    4
    |    |
	1    3

3)and more
	friend: 2 and 4

	0       2      5
	|      / \
	1     3---4

*/



struct UserInfo
{
	long uid;
	UserInfo* next;
	UserInfo* prev;
};

int examine_friendship( const UserInfo* user_info , long uid1 , long uid2 )
{
	UserInfo* uid_ptr = user_info[ uid1 ].next;

	while( uid_ptr->uid != uid1 )
	{
		if( uid_ptr->uid == uid2 )
		{
			return 1;
		}
		uid_ptr = uid_ptr->next;
	}
	return 0;
}

int main( int argc , char** argv )
{
	//read setting
	long user_count;
	long friendship_count;
	scanf( "%ld %ld" , &user_count , &friendship_count );

	//initialize
	UserInfo*  user_info = new UserInfo[ user_count ];
	for( long i = 0 ; i < user_count ; i++ )
	{
		user_info[ i ].uid = i;
		user_info[ i ].next = &user_info[ i ];
		user_info[ i ].prev = &user_info[ i ];
	}

	//read user friendship
	for( long i = 0 ; i < friendship_count ; i++ )
	{
		long uid1;
		long uid2;
		scanf( "%ld %ld" , &uid1 , &uid2 );

		//update internal data
		UserInfo* uid1_ptr = &user_info[ uid1 ];
		UserInfo* uid2_ptr = &user_info[ uid2 ];
		UserInfo* uid1_next_ptr = uid1_ptr->next;

		uid1_ptr->next = uid2_ptr;
		uid2_ptr->prev = uid1_ptr;

		uid1_next_ptr->prev = uid2_ptr;
		uid2_ptr->next = uid1_next_ptr;
	}

	//read number of question
	long question_count;
	scanf( "%ld" , &question_count );

	//process question
	for( long i = 0 ; i < question_count ; i++ )
	{
		long uid1;
		long uid2;
		scanf( "%ld %ld" , &uid1 , &uid2 );

		if( examine_friendship( user_info , uid1 ,uid2 ) )
		{
			printf( "yes\n" );
		}
		else
		{
			printf( "no\n" );
		}
	}

	return 0;
}

C++: #include<iostream>
#define MAX 100
using namespace std;

int main() {
	int i, n, m, q, a, b, gnum = 0, ptog[MAX] = {};

	cin >> n >> m;
	for (i = 0; i < m; i++) {
		cin >> a >> b;
		if (ptog[a] != 0)ptog[b] = ptog[a];
		else if (ptog[b] != 0)ptog[a] = ptog[b];
		else ptog[a] = ptog[b] = ++gnum;
	}

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