Problem:
Connected Components Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network. Input In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$. In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other). In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character. Output For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise. Constraints  $2 \leq n \leq 100,000$  $0 \leq m \leq 100,000$  $1 \leq q \leq 10,000$  Sample Input 10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3 Sample Output yes
yes
no

Solution (Python):
import sys
from collections import defaultdict

def main():
    lines = sys.stdin.readlines()
    n, m = map(int, lines[0].split())
    relation_lines = lines[1:1+m]

    relations = defaultdict(list)

    for idx, relation_line in enumerate(relation_lines):
        s, t = relation_line.split()
        relations[s].append(t)
        relations[t].append(s)

    group = {}
    for key in relations.keys():
        group[key] = -1
    group_num = 0

    
    for key, val in relations.items():
        if group[key] != -1:
            continue

        group[key] = group_num
        group_num += 1

        group_no = group[key]
        friends = [key]

        while len(friends) != 0:
            n_fs = relations[friends.pop()]
            for n_f in n_fs:
                if group[n_f] == -1:
                    group[n_f] = group_no
                    friends.append(n_f)

    q = int(lines[1+m])
    question_lines = lines[1+m+1:]
    answers = [None] * q
    for i, question in enumerate(question_lines):
        s, t = question.split()

        if s not in group or t not in group:
            answers[i] = 'no'
            continue
        elif group[s] == group[t]:
            answers[i] = 'yes'
        else:
            answers[i] = 'no'

    
    [print(ans) for ans in answers]
    return

main()

Solution (Python):
import sys
readline = sys.stdin.readline
write = sys.stdout.write
N, M = map(int, readline().split())
*p, = range(N)
def root(x):
    if x == p[x]:
        return x
    p[x] = x = root(p[x])
    return x
def unite(x, y):
    px = root(x); py = root(y)
    if px < py:
        p[py] = px
    else:
        p[px] = py


for i in range(M):
    s, t = map(int, readline().split())
    unite(s, t)
*_, = map(root, range(N))
Q = int(readline())
ans = []
for q in range(Q):
    s, t = map(int, readline().split())
    ans.append('yes' if p[s] == p[t] else 'no')
write("\n".join(ans))
write("\n")

Solution (Python):
def read_friends():
    n, m = [int(x) for x in input().split()]
    adj_list = [set() for _ in range(n)]

    for _ in range(m):
        s, t = [int(x) for x in input().split()]
        adj_list[s].add(t)
        adj_list[t].add(s)

    return n, adj_list


def divide_group(n, adj_list):
    group = [None] * n

    def visit(k, g):
        S = [k]

        while S:
            k = S.pop()
            group[k] = g
            for t in adj_list[k]:
                if group[t] is None:
                    S.append(t)

    for k in range(n):
        if group[k] is None:
            visit(k, k)

    return group


def answer_queries(group):
    q = int(input())

    for _ in range(q):
        s, t = [int(x) for x in input().split()]
        print("yes" if group[s] == group[t] else "no")


def main():
    n, adj_list = read_friends()
    group = divide_group(n, adj_list)
    answer_queries(group)


if __name__ == '__main__':
    main()

Solution (Python):
v, e = map(int, input().split())   
edge = [[] for _ in range(v)]      



for _ in range(e):                 
  s, t = map(int, input().split()) 
  edge[s].append(t)                
  edge[t].append(s)                

group = [-1]*v                     
cnt = 0                            



for i in range(v):
  if group[i] == -1:
    group[i] = cnt                 
    stack = [i]                    
    while stack:
      v = stack.pop()              
      for c in edge[v]:            
        if group[c] == -1:         
          group[c] = cnt          
          stack.append(c)          
    cnt += 1                       


for _ in range(int(input())):
  s, t = map(int, input().split())
  print('yes' if group[s] == group[t] else 'no')

Solution (Python):
from enum import Enum
import sys
import math

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001


V,E = map(int,input().split())

boss = [i for i in range(V)]
height = [0 for i in range(V)]

def get_boss(index):
    if index == boss[index]:
        return index
    else:
        boss[index] = get_boss(boss[index])
        return boss[index]


def is_same_group(a,b):
    return get_boss(a) == get_boss(b)

def unite(x,y):
    boss_x = get_boss(x)
    boss_y = get_boss(y)

    if boss_x == boss_y:
        return

    if height[x] > height[y]:

        boss[boss_y] = boss_x

    elif height[x] < height[y]:

        boss[boss_x] = boss_y

    else:
        boss[boss_y] = boss_x
        height[x] += 1


for loop in range(E):
    A,B = map(int,input().split())
    unite(A,B)

num_query = int(input())

for loop in range(num_query):
    A,B = map(int,input().split())
    if is_same_group(A,B) == True:
        print("yes")
    else:
        print("no")

Solution (Python):
class Vertex:
	def __init__(self):
		self.c = 0
		self.vertices = []
	def add(self, u):
		self.vertices.append(u)

def dfs(vertices):
	c = 0
	for i in range(len(vertices)):
		c += 1
		if vertices[i].c == 0:
			vertices[i].c = c
			stack = []
			stack.append(i)
			while len(stack) != 0:
				cur = vertices[stack.pop()]
				for j in range(len(cur.vertices)):
					u = cur.vertices[j]
					if vertices[u].c == 0:
						vertices[u].c = c
						stack.append(u)
	return

n, m = map(int, input().split())
vertices = []
for i in range(n):
	vertices.append(Vertex())
for i in range(m):
	u1, u2 = map(int, input().split())
	vertices[u1].add(u2)
	vertices[u2].add(u1)

dfs(vertices)

q = int(input())
for i in range(q):
	u1, u2 = map(int, input().split())
	if vertices[u1].c == vertices[u2].c:
		print('yes')
	else:
		print('no')

Solution (Python):
def dfs(r, c, g, color):
    s = [r]
    color[r] = c
    while len(s) != 0:
        u = s.pop()
        for i in range(len(g[u])):
            v = g[u][i]
            if color[v] is None:
                color[v] = c
                s.append(v)


def assignColor(n, g, color):
    color_id = 1
    for u in range(n):
        if color[u] is None:
            dfs(u, color_id, g, color)
            color_id += 1


n, m = [int(v) for v in input().split()]
g = [[] for i in range(n)]
for i in range(m):
    s, t = [int(v) for v in input().split()]
    g[s].append(t)
    g[t].append(s)

color = [None] * n
assignColor(n, g, color)

q = int(input())

for i in range(q):
    s, t = [int(v) for v in input().split()]
    if color[s] == color[t]:
        print('yes')
    else:
        print('no')

Solution (Python):
n, m = map(int, input().split())
relations = [[] for _ in range(n)]
 
for i in range(m):
    s, t = map(int, input().split())
    relations[s] += [t]
    relations[t] += [s]
friend_id = [None] * n
for s, t in enumerate(relations):
    if t:
        queue = [s]
        while len(queue):
            k = queue.pop()
            friend_id[k] = s
            queue += relations[k]
            relations[k] = []
 
q = int(input())
for i in range(q):
    s, t = map(int, input().split())
    print('yes' if friend_id[s] != None and friend_id[s] == friend_id[t] else'no')

Solution (Python):

import array
from collections import deque
def groupify(length, adj_list):
    group = array.array('l', (-1 for _ in range(length)))
    g_id = 0
    dq = deque()
    for idx in range(length):
        if group[idx] == -1:
            group[idx] = g_id
            dq.append(idx)
            while len(dq):
                v = dq.popleft()
                for t in adj_list[v]:
                    if group[t] == -1:
                        group[t] = g_id
                        dq.append(t)
            g_id += 1
    return group

n,m = map(int, input().split())
adj_list = [set() for _ in range(n)]
for _ in range(m):
    i,j = map(int, input().split())
    adj_list[i].add(j)
    adj_list[j].add(i)
group = groupify(n, adj_list)

q = int(input())
for _ in range(q):
    s,t = map(int, input().split())
    if group[s] == group[t]: print('yes')
    else: print('no')