Go: package main

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

//util
var sc = bufio.NewScanner(os.Stdin)

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func printList(list []int) {
	n := len(list)
	buf := bufio.NewWriter(os.Stdout)
	for _, v := range list[0 : n-1] {
		buf.Write([]byte(fmt.Sprintf("%d ", v)))
	}
	buf.Write([]byte(fmt.Sprintf("%d\n", list[n-1])))
	buf.Flush()
}

func max(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func min(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

//solve
const (
	MAX = 100000
	NIL = -1
)

var (
	n, m, q, s, t 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() {
	sc.Split(bufio.ScanWords)
	n, m = nextInt(), nextInt()
	for i := 0; i < m; i++ {
		s, t = nextInt(), nextInt()
		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()
	q = nextInt()
	for i := 0; i < q; i++ {
		s, t = nextInt(), nextInt()
		if color[s] == color[t] {
			fmt.Println("yes")
		} else {
			fmt.Println("no")
		}
	}

}

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";
	}
}