Go: package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	nNodes := scanInt(sc)
	nConns := scanInt(sc)

	graph := make([][]int, nNodes)
	for i := 0; i < nConns; i++ {
		a, b := scanInt(sc), scanInt(sc)
		graph[a] = append(graph[a], b)
		graph[b] = append(graph[b], a)
	}

	groups := make([]int, nNodes)

	var setGroups func(int, int)
	setGroups = func(u int, groupId int) {
		if groups[u] > 0 {
			return
		}
		groups[u] = groupId

		for _, v := range graph[u] {
			setGroups(v, groupId)
		}
	}
	for i := 0; i < nNodes; i++ {
		setGroups(i, i+1)
	}

	nQuestions := scanInt(sc)

	w := bufio.NewWriter(os.Stdout)
	var ans string
	for i := 0; i < nQuestions; i++ {
		a, b := scanInt(sc), scanInt(sc)
		if groups[a] == groups[b] {
			ans = "yes"
		} else {
			ans = "no"
		}
		fmt.Fprintln(w, ans)
	}
	w.Flush()
}

func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	v, _ := strconv.Atoi(sc.Text())
	return v
}

C++: #include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <climits>
using namespace std;

int n;

vector<int> uf;

void initialize(int n)
{
  uf = vector<int>(n);
  for (int i = 0; i < n; i++)
    uf[i] = i;
}

int root(int i)
{
  if (uf[i] == i) return i;
  return uf[i] = root(uf[i]);
}

void unite(int i, int j)
{
  int ri = root(i);
  int rj = root(j);
  if (ri != rj)
    uf[rj] = ri;
}

bool same(int i, int j)
{
  return root(i) == root(j);
}

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

  initialize(n);
  for (int i = 0; i < m; i++) {
    int u, v; cin >> u >> v;
    unite(u, v);
  }

  cin >> q;
  for (int i = 0; i < q; i++) {
    int u, v; cin >> u >> v;
    cout << (same(u, v)?"yes":"no") << endl;
  }

  return EXIT_SUCCESS;
}

C++: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <utility>
#include <queue>
#include <stack>
#include <string>
#include <climits>
using namespace std;

#define MAX_N  100000
#define MAX_M  100000
#define MAX_Q  10000

int n, m, q, k, kind[MAX_N] = {};
queue<int> Q;

void bf(vector<vector<int> >& sns, int s)
{
    Q.push(s);
    while (!Q.empty()) {
        s = Q.front();
        Q.pop();
        kind[s] = k;
        for (int i = 0; i < sns[s].size(); i++) {
            if (!kind[sns[s][i]]) Q.push(sns[s][i]);
        }
    }
}

int main()
{
    cin >> n >> m;
    vector<vector<int> > sns(n);
    int s, d;
    while (m--) {
        cin >> s >> d;
        sns.at(s).push_back(d);
        sns.at(d).push_back(s);
    }
    k = 0;
    for (int s = 0; s < n; s++) {
        if (!kind[s]) {
            k++;
            bf(sns, s);
        }
    }
    cin >> q;
    while (q--) {
        cin >> s >> d;
        cout << (kind[s] == kind[d] ? "yes" : "no") << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
void search(vector<vector<int> > &G, int *color, int s, int id)
{
    color[s] = id; //sは訪問済み
    stack<int> q;
    q.push(s);
    while (q.empty() == false)
    {
        int p = q.top();
        q.pop();
        rep(i, 0, G[p].size())
        {
            int new_p = G[p][i];
            if (color[new_p] == 0)
            {
                color[new_p] = id;
                q.push(new_p);
            }
        }
    }
}
int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int> > G(n, vector<int>(0));
    int color[n] = {};
    int s, t;
    rep(i, 0, m)
    {
        scanf("%d %d", &s, &t);
        G[s].push_back(t);
        G[t].push_back(s);
    }
    int id(0);
    rep(i, 0, n)
    {
        if (color[i] == 0)
        {
            search(G, color, i, ++id);
        }
    }
    int q;
    cin >> q;
    rep(i, 0, q)
    {
        scanf("%d %d", &s, &t);
        if (color[s] == color[t])
            printf("yes\n");
        else
            printf("no\n");
    }
}

C++: #include<iostream>
#include<vector>
#include<stack>
#define MAX 999999
#define NIL -1
using namespace std;


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 assign()
{
  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);
    }

  assign();

  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 main(){
  int n,m,s,t,d[100000];
  vector<int>l[100000];
  cin>>n>>m;
  for(int i=0;i<n;i++)d[i]=-1;
  for(int i=0;i<m;i++){
    cin>>s>>t;
    l[s].push_back(t);
    l[t].push_back(s);
  }
  queue<int> q;
  for(int i=0;i<n;i++){
    if(d[i]==-1){
      q.push(i);
      while(!q.empty()){
	int from=q.front();
	q.pop();
	if(d[from]==-1){
	  d[from]=i;
	  for(int j=0;j<l[from].size();j++)q.push(l[from][j]); 
	}
      }
    }    
  }
  int Q;
  cin>>Q;
  for(int i=0;i<Q;i++){
    cin>>s>>t;
    if(d[s]==d[t])cout<<"yes"<<endl;
    else cout<<"no"<<endl;
  }
  return 0;
}

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

using namespace std;

int main(){
	int n, m, s, t, q, i, j;
	int id, color = 0;
	bool answer_yes = false;

	// enter
	cin >> n >> m;
	vector< vector<int> > Adj(n);
	vector<int> Stack;
	vector<int> Check(n, 0);
	vector<int>::iterator it, itend;
	for (i = 0; i < m; i++) {
		cin >> s >> t;
		Adj[s].push_back(t);
		Adj[t].push_back(s);
	}
	/*for (i = 0; i < n; i++) {
		cout << "\n" << i << " : " << flush;
		for (auto it2 = Adj[i].begin(); it2 != Adj[i].end(); it2++) {
			cout << *it2 << " " << flush;
		}
	}
	cout << endl;*/

	// calculate
	for (i = 0; i < n; i++) {
		if (Check[i] == 0) {
			color++;
			Stack.push_back(i);
			Check[i] = color;
			while (!Stack.empty()) {
				id = Stack.back();
				//cout << "\nid : " << id << " color : " << color << endl;
				itend = Adj[id].end();
				for (it = Adj[id].begin(); it != itend; it++) {
					if (!Check[*it]) {
						Stack.push_back(*it);
						Check[*it] = color;
						break;
					}
				}
				if (it == itend) {
					Stack.pop_back();
				}
			}
		}
	}

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

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