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 <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <tuple>
#include <functional>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <map>
#include <random>
#include <cstdlib>
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
using namespace std;
typedef long long int ll;

static const int N = 100005;
vector<int> V[N], visit(N, 0), color(N, 0);
queue<int> Q;

void paint(int c) {
	while (Q.size() > 0) {
		int u = Q.front();
		Q.pop();
		color[u] = c;
		Loop(i, V[u].size()) {
			if (color[V[u][i]] == 0) {
				Q.push(V[u][i]);
			}
		}
	}
}

int main() {
	int n, m;
	cin >> n >> m;
	Loop(i, m) {
		int s, t;
		cin >> s >> t;
		V[s].push_back(t);
		V[t].push_back(s);
	}
	//color painting
	int c = 0;
	Loop(i, n) {
		if (color[i] == 0) {
			c++;
			Q.push(i);
			paint(c);
		}
	}
	//end
	int q;
	cin >> q;
	Loop(i, q) {
		int s, t;
		cin >> s >> t;
		if (color[s] == color[t]) cout << "yes" << endl;
		else cout << "no" << endl;
	}
}

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

int n;
int **connection;

bool isFriend(int s, int t){
    int i;
    int f[n];
    for(i=0;i<n;i++)f[i]=0;
    f[s]=1;
    int u;
    queue<int> q;
    q.push(s);
    while(!q.empty()){
        u=q.front();q.pop();
        for(i=0;i<n;i++){
            if(connection[u][i]&&f[i]==0){
                connection[u][i]=1;
                connection[i][u]=1;
                if(i==t)return true;
                f[i]=1;
                q.push(i);
            }
        }
    }
    return false;
}

int main(){
    int i, j, m, s, t, q;
    scanf("%d %d",&n,&m);
    connection = (int **)malloc(sizeof(int *)*n);
    for(i=0;i<n;i++){
        connection[i] = (int *)malloc(sizeof(int)*n);
        for(j=0;j<n;j++){
            connection[i][j]=0;
        }
    }
    for(i=0;i<m;i++){
        scanf("%d %d",&s,&t);
        connection[s][t]=1;
        connection[t][s]=1;
    }
    scanf("%d",&q);
    for(i=0;i<q;i++){
        scanf("%d %d",&s,&t);
        if(isFriend(s,t))printf("yes\n");
        else printf("no\n");
    }
    return 0;
}

C++: #include<cstdio>
#include<vector>
#include<algorithm>
#include<utility>
#include<numeric>
#include<iostream>
#include<array>
#include<string>
#include<sstream>
#include<stack>
#include<queue>
#include<list>
#define _USE_MATH_DEFINES

#include<math.h>
#include<map>

#define SENTINEL 1000000001

#define min(a,b) (a)>(b)?(b):(a)
#define max(a,b) (a)>(b)?(a):(b)

using namespace std;

int from[100000];
int to[100000];

bool checked[100000];

bool judge(int f, int t,int n)
{
	if (checked[f])
	{
		return false;
	}

	checked[f] = true;

	bool isFriend = false;
	for (int i = 0; i < n; i++)
	{
		if (from[i] == f)
		{
			if (to[i] == t)
			{
				isFriend = true;
			}
			else
			{
				isFriend = judge(to[i], t, n);
			}
			if (isFriend)
			{
				break;
			}
		}
		if (to[i] == f)
		{
			if (from[i] == t)
			{
				isFriend = true;
			}
			else
			{
				isFriend = judge(from[i], t, n);
			}
			if(isFriend)
			{
				break;
			}
		}
	}
	return isFriend;
}

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

	for (int i = 0; i < m; i++)
	{
		int f, t;
		cin >> f >> t;

		from[i] = f;
		to[i] = t;
	}

	int q;
	cin >> q;

	for (int i = 0; i < q; i++)
	{
		int f, t;
		cin >> f >> t;

		for (int i = 0; i < n; i++)
		{
			checked[i] = false;
		}

		printf(judge(f, t, n) ? "yes\n" : "no\n");
	}
	return 0;
}

C++: #include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
queue<int>Q; int x[200000], n, m, q, s, t; vector<int>a[100000];

bool bfs(int A,int B) {
	memset(x, 0, sizeof(x));
	x[A] = 1;
	while (!Q.empty()) {
		for (int k = 0; k < a[Q.front()].size(); k++) {
			if (x[a[Q.front()][k]] == 0) { Q.push(a[Q.front()][k]); x[a[Q.front()][k]] = 1; }
		}
	}
	if (x[B] == 1) {
		return true;
	}
	else {
		return false;
	}
}

int main() {
	cin >> n >> m;
	for (int i = 0; i < m; i++) {
		cin >> s >> t;
		a[s].push_back(t);
		a[t].push_back(s);
	}
	cin >> q;
	for (int i = 0; i < q; i++) {
		cin >> s >> t;
		if (bfs(s, t)) { cout << "yes" << endl; }
		else { cout << "no" << endl; }
	}
	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <bitset>
#include <climits>
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define RFOR(i,a,b) for (int i=(a)-1;i>=(b);i--)
#define ll long long
#define ull unsigned long long
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const int INF = 1e9;
const int MOD = 1e9 + 7;

using namespace std;

int color[(int)1e5 + 1];
vector<vector<int> > edge;
int cl;
void dfs(int v){
	color[v] = cl;
	REP(i,edge[v].size()){
		if(not color[edge[v][i]]){
			dfs(edge[v][i]);
		}
	}
}

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
	int n,m,q;
	cin>>n>>m;
	edge.resize(n,vector<int>());
	REP(i,m){
		int u,v;cin>>u>>v;
		edge[u].push_back(v);
		edge[v].push_back(u);
	}
	REP(i,n){
		cl = i+1;
		if(not color[i]){
			dfs(i);
		}
	}
	cin>>q;
	REP(i,q){
		int u,v;cin>>u>>v;
		if(color[u] == color[v]){
			cout << "yes" << endl;
		}else{
			cout << "no" << endl;
		}
	}
  return 0;
}

C++: #include<iostream>
#include<queue>
#include<vector>
using namespace std;
#define MAX_N 500000
vector<int>X[MAX_N]; queue<int>Q;
int COLOR[MAX_N], N, M, Q1, A, B;
int main() {
	cin >> N >> M;
	for (int i = 0; i < M; i++) { cin >> A >> B; X[A].push_back(B); X[B].push_back(A); }
	int cnt = 0;
	for (int i = 0; i < N; i++) {
		if (COLOR[i] == 0) {
			Q.push(i); cnt++; COLOR[i] = cnt;
			while (!Q.empty()) {
				int a = Q.front(); Q.pop();
				for (int j = 0; j < X[a].size(); j++) {
					int to = X[a][j];
					if (COLOR[to] == 0) {
						COLOR[to] = cnt;
						Q.push(to);
					}
				}
			}
		}
	}
	cin >> Q1;
	for (int i = 0; i < Q1; i++) {
		cin >> A >> B;
		if (COLOR[A] == COLOR[B]) {
			cout << "yes" << endl;
		}
		else {
			cout << "no" << endl;
		}
	}
	return 0;
}