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++: /*
** Connected Components
*/

# include <cstdio>
# include <vector>
# include <queue>
using namespace std;

const int MAX = 100000;

int n, m, q, c[MAX];
vector<int> g[MAX];

void init() {
    scanf("%d%d", &n, &m);
    int u, v;
    while (m--) {
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
}

void bfs(int u, int mark) {
    queue<int> que;
    que.push(u);
    c[u] = mark;

    while (!que.empty()) {
        int t = que.front();
        que.pop();
        for (int i = 0; i < g[t].size(); i++) {
            if (c[g[t][i]] == 0) {
                c[g[t][i]] = mark;
                que.push(g[t][i]);
            }
        }
    }
}

void set_c() {
    int mark = 1;
    for (int i = 0; i < n; i++) {
        c[i] = 0;
    }
    for (int i = 0; i < n; i++) {
        if (c[i] == 0) {
            bfs(i, mark++);
        }
    }
}

void solve() {
    init();
    scanf("%d", &q);
    set_c();
    int u, v;
    while (q--) {
        scanf("%d%d", &u, &v);
        if (c[u] == c[v]) {
            printf("yes\n");
        }
        else
        {
            printf("no\n");
        }
    }
}

int main() {
    // freopen("infile", "r", stdin);
    // freopen("outfile", "w", stdout);
    solve();
    return 0;
}

C++: #include<bits/stdc++.h>
//cout<<setprecision(1)<<fixed<<endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAX_N=100000;
const int INF = 0x3f3f3f3f;
#define eps 1e-7
int n,m;
int e;
int begin[301010];
int next[301010];
int to[301010];
int vis[301010];
void add(int x,int y){
	to[++e]=y;
	next[e]=begin[x];
	begin[x]=e;
}

bool search(int st,int ed){
	queue<int> q;
	q.push(st);
//	cout<<"push"<<st<<endl;
	vis[st]=1;
	while(!q.empty()){
		int now=q.front();
	//	cout<<q.size()<<endl;
		q.pop();
		int te=begin[now];
		while(te!=-1){
			if(to[te]==ed)
				return true;
			if(vis[to[te]]==0){
				q.push(to[te]);
		//		cout<<"push"<<to[te]<<endl;
				vis[to[te]]=1;
			}
			te=next[te];
		}
	}
	return false;
}
int main(){
	ios::sync_with_stdio(false);
	#ifdef Kongxiangzhouye
		freopen("in.txt","r",stdin);
		freopen("out.txt","w",stdout);
	#endif
	int n,m,q;
	while(cin>>n>>m){
		memset(begin,-1,sizeof(begin));
		memset(next,-1,sizeof(next));
		memset(to,-1,sizeof(to));
		e=0;
		for(int i=0;i<m;i++){
			int st,ed;
			cin>>st>>ed;
			add(st,ed);
			add(ed,st);
		}
		cin>>q;
		for(int i=0;i<q;i++){
			memset(vis,0,sizeof(vis));
			int st,ed;
			cin>>st>>ed;
			if(search(st,ed))
				cout<<"yes"<<endl;
			else
				cout<<"no"<<endl;
		}
	}

	return 0;
}

C++: #include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
#include <stack>
#include <string.h>
#define rep(i, n) for(int i=0;i<n;i++)
#define FOR(i, j, n) for(int i=j;i<n;i++)
#define NOT_FOUND 0
using namespace std;

vector<int> graph[100001];
int memo[100001];

int dfs(int start, int label) {
    stack<int> stack;
    stack.push(start);
    memo[start] = label;

    while(!stack.empty()) {
        int v = stack.top();
        stack.pop();
        vector<int> edges = graph[v];

        rep(i, edges.size()) {
            int next = edges[i];
            if (memo[next] == 0) {
                memo[next] = label;
                stack.push(next);
            }
        }
    }
    return 1;
}

int main() {
    int n, m;
    cin >> n >> m;

    for (int i = 0; i < m; i++) {
        int v, e;
        cin >> v >> e;
        graph[v].push_back(e);
        graph[e].push_back(v);
    }

    memset(memo, 0, sizeof(memo));
    int id = 1;
    rep(i, n) {
        if (memo[i] == 0) {
            dfs(i, id++);
        }
    }

    int q;
    cin >> q;
    rep(i, q) {
        int s, d;
        cin >> s >> d;
        if (memo[s] == memo[d]) {
            cout << "yes" << endl;
        } else {
            cout << "no" << endl;
        }
    }
    return 0;
}

C++: #include <iostream>
#include <cstdio>
#define MAX 100000

using namespace std;

int main(){
  int a[MAX]={};
  int n,m; cin>>n>>m;
  int s,t;
  int group=1;
  for(int i=0;i<m;i++){
    scanf("%d %d",&s,&t);
    if(a[s]==0 && a[t]==0){
      a[s]=a[t]=group;
      group++;
    }else if(a[s]==0){
      a[s]=a[t];
    }else if(a[t]==0){
      a[t]=a[s];
    }else{
      int tmp=a[t];
      a[t]=a[s];
      for(int j=0;j<n;j++){
        if(a[j]==tmp) a[j]=a[s];
      }
    }
  }

  int q; cin>>q;
  for(int i=0;i<q;i++){
    cin>>s>>t;
    if(a[s]==a[t]&&a[s]*a[t]!=0){
      printf("yes\n");
    }else{
      printf("no\n");
    }
  }

}

C++: /* 
 * ALDS1_11B.cpp
 */
#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;

using Friends = vector<int>;
using SNS = vector<Friends>;

int n, m, q;
bool visited[100000];
SNS sns;

int main(void) {

    scanf("%d %d", &n, &m);
    sns.resize(n);
    for (int i = 0, id, f; i < m; ++i) {
        scanf("%d %d", &id, &f);
        sns[id].push_back(f);
        sns[f].push_back(id);
    }

    scanf("%d", &q);
    for (int i = 0, id, f; i < q; ++i) {
        scanf("%d %d", &id, &f);
        memset(visited, 0, sizeof(bool)*n);
        queue<int> q;
        q.push(id);
        bool found = false;
        while (!q.empty()) {
            int per = q.front();
            q.pop();
            if (visited[per])
                continue;
            if (per == f) {
                found = true;
                break;
            }
            visited[per] = true;
            for (int j = 0; j < sns[per].size(); ++j) {
                q.push(sns[per][j]);
            }
        }
        if (found)
            printf("yes\n");
        else
            printf("no\n");
    }

    return 0;
}

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

bool search(vector<int> member,int x){
  for(int i=0; i<member.size(); i++){
    if(member[i] == x)
      return true;
  }
    return false;
}

int main(){
  int n,m,join[10000],s,t;
  vector<int> group[10000];
  cin >> n >> m;

  for(int i=0; i<n; i++)
    join[i] = i;
    
  for(int i=0; i<m; i++){
    bool flag = search(group[join[t]],s);

    if(!flag){
      group[join[s]].push_back(t);
      
      for(int j=0; j<group[t].size(); j++)
	join[group[t][j]]=join[s];
	  
      join[t] = join[s];
    }
  }

  int q;
  cin >> q;
  
  bool answer[10000];
  for(int i=0; i<q; i++){
    cin >> s >> t;
    
    if(join[s] == join[t])
      answer[i]=true;
    else
      answer[i]=false;
  }

  for(int i=0; i<q; i++){
    if(answer[i])
      cout << "yes\n";
    else
      cout << "no\n";
  }
}