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 <bits/stdc++.h>
using namespace std;
#define MAX 100005

vector<vector<int> > G, R;
vector<int> ve;
queue<int> Q;
int choose[MAX];
int n, m, i, j;

int main(void) {
	cin >> n >> m;
	G.resize(n);
	int a, b;
	for (i = 0; i < m; i++) {
		cin >> a >> b;
		G[a].push_back(b);
		G[b].push_back(a);
	}
	for (i = 0; i < n; i++) {
		choose[i] = 0;
	}
	for (i = 0; i < n; i++) {
		if (choose[i] != 0)
			continue;
		Q.push(i);
		ve.clear();
		ve.push_back(i);
		choose[i] = 1;
		int now, cnt, next;
		while (!Q.empty()) {
			now = Q.front();
			Q.pop();
			for (cnt = 0; cnt < G[now].size(); cnt++) {
				next = G[now][cnt];
				if (choose[next] == 0) {
					Q.push(next);
					ve.push_back(next);
					choose[next] = 1;
				}
			}
		}
		R.push_back(ve);
		int dis = R.size() - 1;
		sort(R[dis].begin(), R[dis].end());
	}
	cin >> m;
	for (i = 0; i < m; i++) {
		cin >> a >> b;
		for (j = 0; j < R.size(); j++) {
			if (*(lower_bound(R[j].begin(), R[j].end(), a)) == a) {
				if (*(lower_bound(R[j].begin(), R[j].end(), b)) == b) 
					cout << "yes\n";
				else
					cout << "no\n";
			}
		}
	}
}

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

using namespace std;

vector<int> G[100001];
vector<int> color(100001, -1);
void init(int idx, int c){
  if(color[idx] >= 0) return;
  color[idx] = c;
  for(int to: G[idx])
	init(to, c);
}

int main(){
  int N, M; cin >> N >> M;

  for(int i=0;i<M;++i){
	int a, b; cin >> a >> b;
	G[a].push_back(b);
	G[b].push_back(a);
  }
  for(int i=0;i<N;++i){
	init(i, i);
  }

  int Q; cin >> Q;
  for(int q=0;q<Q;++q){
	int a, b; cin >> a >> b;
	cout << (color[a]==color[b]? "yes": "no") << endl;
  }

  return 0;
}

C++: #include <bits/stdc++.h>
 
using namespace std;

struct UnionFind {
	int sz;
	vector<int> par;
	UnionFind(int a) : sz(a), par(sz, -1) {}
	int root(int x) { return par[x] < 0 ? x : par[x] = root(par[x]);}
	bool same(int x, int y) { return root(x) == root(y);}
	bool unite(int x, int y) {
		x = root(x);
		y = root(y);
		if (x == y) return false;
		if (size(x) < size(y)) swap(x, y);
		par[x] += par[y];
		par[y] = x;
		return true;
	}
	int size(int x) { return -par[root(x)];}
	int size() { return sz;}
};

int main() {
    int n, m, q; cin >> n >> m;
    UnionFind U(n+1);
    while (m--) {
        int a, b; cin >> a >> b;
        U.unite(a, b);
    }
    cin >> q;
    while (q--) {
        int a, b; cin >> a >> b;
        if (U.same(a, b)) cout << "yes" << endl;
        else cout << "no" << endl;
    }
}

C++: #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) des(u,id++);
  }
 }
int main (){
  int s,t,q,m;

  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++: #include <iostream>
using namespace std;
  
int main() {
int d[100100];
int m,n,q;
cin>>n>>m;
for(int i=0;i<n;i++){
    d[i]=i;
}
for(int l=0;l<m;l++){
    int a,b;
    cin>>a>>b;
    int j ,h;
    j=a,h=b;
while(d[j]!=j && d[h]!=h){
    j=d[j];
    h=d[h];
}
if(d[j]==j){
	while(d[h]!=h){
		h=d[h];
	}
    d[j]=h;
    d[a]=h;
}
else{
	while(d[j]!=j){
		j=d[j];
	}
  d[h]=j;
    d[b]=j;
}
}
cin>>q;
for(int y=0;y<q;y++){
    int a,b;
    cin>>a>>b;
        int j ,h;
    j=a,h=b;
while(d[j]!=j || d[h]!=h){
    j=d[j];
    h=d[h];
}
    if(j==h){
        cout<<"yes"<<endl;
    }
    else{
        cout<<"no"<<endl;
    }
}
    return 0;
}

C++: #include <iostream>
#include <stdint.h>
#include <vector>

using namespace std;

#define GRAPH_MAX_SIZE 100000
#define WHITE -1

vector<uint32_t> vertexes[GRAPH_MAX_SIZE];
int32_t colors[GRAPH_MAX_SIZE];

void graph_connected_components_init()
{
  uint32_t i;
  for (i = 0; i < GRAPH_MAX_SIZE; i++) {
    vertexes[i].clear();
    colors[i] = WHITE;
  }
}

void graph_connected_components_add(uint32_t vertex, uint32_t connect_to)
{
  vertexes[vertex].push_back(connect_to);
  vertexes[connect_to].push_back(vertex);
}

uint32_t *graph_connected_components_connected_vertexes(uint32_t vertex)
{
  return &vertexes[vertex][0];
}

void colorize_connecting_vertex(vector<uint32_t> *connect_to, int32_t color)
{
  uint32_t i;
  for (i = 0; i < connect_to->size(); i++) {
    uint32_t index = (*connect_to)[i];
    if (colors[index] == WHITE) {
      colors[index] = color;
      colorize_connecting_vertex(&vertexes[index], color);
    }
  }
}

void graph_connected_components_colorize()
{
  int32_t i;
  for (i = 0; i < GRAPH_MAX_SIZE; i++) {
    if (colors[i] == WHITE) {
      colors[i] = i;
      vector<uint32_t> connect_to = vertexes[i];
      colorize_connecting_vertex(&connect_to, i);
    }
  }
}

bool graph_connected_components_is_connected(uint32_t index1, uint32_t index2)
{
  if (colors[index1] == colors[index2]) return true;
  return false;
}

#if !defined(TEST)
#include <iostream>
using namespace std;
int32_t main(void)
{
  graph_connected_components_init();

  int32_t users, connections;
  cin >> users >> connections;

  uint32_t i;
  for (i = 0; i < connections; i++) {
    uint32_t index, connection;
    cin >> index >> connection;
    graph_connected_components_add(index, connection);
  }
  graph_connected_components_colorize();

  int32_t questions;
  cin >> questions;
  for (i = 0; i < questions; i++) {
    uint32_t index1, index2;
    cin >> index1 >> index2;
    if (graph_connected_components_is_connected(index1, index2)) {
      cout << "yes" << endl;
    } else {
      cout << "no" << endl;
    }
  }

  return 0;
}
#endif

C++: #include <stdio.h>
#define N 100000

int A[N] = {0};

int serch(int x){
  if(x == A[x])
    return x;
  
  return A[x] = serch(A[x]);
}

int main(){
  int i, m, n, x, y, z;
  
  for(i=0; i<N; i++)
    A[i] = i;
  
  scanf("%d %d", &m, &n);
  
  for(i=0; i<n; i++){
    scanf("%d %d", &x, &y);
    if(serch(x) != serch(y))
      A[serch(y)] = serch(x);
  }
  
  scanf("%d", &z);
  
  for(i=0; i<z; i++){
    scanf("%d %d", &x, &y);
    if(serch(x) == serch(y))
      printf("yes\n");
    else
      printf("no\n");
  }
  
  return 0;
}