Go: package main

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

// Node 頂点
type Node struct {
	gid  int   // グループID
	edge []int // 隣接辺
}

// NoID グループIDなし
const NoID = -1

// NewNode 頂点の生成
func NewNode() *Node {
	return &Node{gid: NoID, edge: []int{}}
}

func parseNode(nodes []*Node, gid int, queue []int) {
	if len(queue) == 0 {
		return
	}
	var nextQ []int
	for _, id := range queue {
		node := nodes[id]
		if node.gid == NoID {
			node.gid = gid
			for _, edge := range node.edge {
				nextQ = append(nextQ, edge)
			}
		}
	}
	parseNode(nodes, gid, nextQ)
	return
}
func digNode(nodes []*Node, id, gid int) {
	node := nodes[id]
	if node.gid != NoID {
		// 探索済み
		return
	}
	node.gid = gid
	for _, edge := range node.edge {
		digNode(nodes, edge, gid)
	}
	return
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	n, m := eGetInt2(scanner)

	nodes := make([]*Node, n)
	for i := 0; i < n; i++ {
		nodes[i] = NewNode()
	}

	for i := 0; i < m; i++ {
		a, b := eGetInt2(scanner)
		nodes[a].edge = append(nodes[a].edge, b)
		nodes[b].edge = append(nodes[b].edge, a)
	}

	for i := 0; i < n; i++ {
		// 幅優先探索
		// gid := i
		// queue := []int{i}
		// parseNode(nodes, gid, queue)

		// 深さ優先探索
		digNode(nodes, i, i)
	}

	q := eGetInt(scanner)
	for i := 0; i < q; i++ {
		a, b := eGetInt2(scanner)
		if nodes[a].gid == nodes[b].gid {
			fmt.Println("yes")
		} else {
			fmt.Println("no")
		}
	}
}

func eGetInt(scanner *bufio.Scanner) int {
	t := eAtoi(strings.Fields(eGetline(scanner)))
	return t[0]
}
func eGetInt2(scanner *bufio.Scanner) (int, int) {
	t := eAtoi(strings.Fields(eGetline(scanner)))
	return t[0], t[1]
}

func eGetline(p *bufio.Scanner) string {
	if !p.Scan() {
		if err := p.Err(); err != nil {
			log.Fatal(err.Error())
		}
		return ""
	}
	return p.Text()
}

func eAtoi(s []string) []int {
	ints := make([]int, len(s))
	var err error
	for i, e := range s {
		ints[i], err = strconv.Atoi(e)
		if err != nil {
			log.Fatal(err.Error())
		}
	}
	return ints
}

C++: #ifdef LOCAL_BUILD
#include "pch.h"
#define DLOG(msg) cout << "#" << __LINE__ << ":" << msg << endl;
#define DLOG_V(var) \
  cout << "#" << __LINE__ << ":" << #var << " : " << var << endl;
#else
#include <bits/stdc++.h>
#define DLOG(msg)
#define DLOG_V(var)
#endif
using namespace std;

struct Solver {
  explicit Solver(int n)
      : connected_(n, vector<bool>(n, false)), done_(n, false) {}
  void register_friend(int s, int t) {
    connected_[s][t] = connected_[t][s] = true;
  }
  bool can_reach(int s, int t) {
    if (s == t)
      return true;
    queue<int> q;
    q.push(s);
    while (!q.empty()) {
      auto v = q.front();
      q.pop();
      if (v == t)
        return true;
      if (done_[v])
        continue;
      done_[v] = true;
      auto& con = connected_[v];
      for (size_t i = 0; i < con.size(); ++i) {
        if (con[i]) {
          auto v2 = static_cast<int>(i);
          if (v2 == t)
            return true;
          if (!done_[v2]) {
            q.push(v2);
          }
        }
      }
    }
    return false;
  }

 private:
  vector<vector<bool>> connected_;
  vector<bool> done_;
};

int main() {
  int n, m;
  cin >> n >> m;
  Solver sol(n);
  for (int i = 0; i < m; ++i) {
    int s, t;
    cin >> s >> t;
    sol.register_friend(s, t);
  }
  int q;
  cin >> q;
  for (int i = 0; i < q; ++i) {
    int s, t;
    cin >> s >> t;
    auto ok = sol.can_reach(s, t);
    cout << (ok ? "yes" : "no") << endl;
  }
}

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 <bits/stdc++.h>
using namespace std;
const int N = 1000000;
const int CRL = -1;
int v[N]={0};
void ketugou(int k,int l,int n){
	int x,mn;
	x = max(v[k],v[l]);
	mn = min(v[k],v[l]);
	for(int i=0;i<n;i++){
		if(v[i]==x)v[i]=mn;
	}
}

int main(){
	int n,m,q;
	memset(v, CRL, sizeof(v));
	cin >> n >> m;
	for(int i=0;i<m;i++){
		int k,l;
		cin >> k >> l;
		if(v[k]==CRL && v[l]==CRL){
			v[k] = v[l] = min(k,l);
		}else if(v[k]!=CRL && v[l]!=CRL){
			ketugou(k,l,n);
		}else if(v[k]==CRL){
			v[k]=v[l];
		}else{
			v[l]=v[k];
		}
	}
	cin >> q;
	for(int i=0;i<q;i++){
		int k,l;
		cin >> k >> l;
		if(v[k]==CRL || v[l]==CRL) cout << "no" << endl;
		else if(v[k]==v[l])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++){
    cin>>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){
      cout<<"yes"<<endl;
    }else{
      cout<<"no"<<endl;
    }
  }

}

C++: #include <iostream>
#include "vector"
#include "stack"
using namespace std;
static const int mx=100000;
static const int nil=-1;

int n;
vector<int>g[mx];
int color[mx];

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 i=0;i<n;i++)
		if(color[i]==nil)dfs(i,id++);
}
int main(int argc, char *argv[]) {
	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;
}