Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

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 in C (judge verdict: Runtime Error)

#include <stdio.h>          // printf(), scanf()
#include <stdlib.h>         // exit()

#define MAX_V 100000
#define MAX_E 100000
#define QUE_SIZE 100000

typedef struct edge_tbl
{
	int to;
	int next;
} edge;

const int nil = -1;
int g[MAX_V];
edge es[MAX_E];
int color[MAX_V];
int V;
int n_edge;

int queue[QUE_SIZE];
int que_in;
int que_out;

void
cleanup(int ecode)
{
	exit(ecode);
}

int
que_empty()
{
	return que_in == que_out;
}

void
que_push(int x)
{
	queue[que_in] = x;
	que_in = (que_in + 1) % QUE_SIZE;
	if (que_in == que_out)
	{
		fprintf(stderr, "Queue overflow. size:%d\n", QUE_SIZE);
		cleanup(1);
	}
}

void
que_pop()
{
	if (que_out == que_in)
	{
		fprintf(stderr, "Queue underflow\n");
		cleanup(1);
	}

	que_out = (que_out + 1) % QUE_SIZE;
}

int
que_front()
{
	return queue[que_out];
}

void
bfs(int u, int c)
{
	int v;
	int r;
	int l;

	color[u] = c;
	que_push(u);
	while (!que_empty())
	{
		r = que_front(); que_pop();
		for (l = g[r]; l != nil; l = es[l].next)
		{
			v = es[l].to;
			if (color[v] == nil)
			{
				color[v] = c;
				que_push(v);
			}
		}
	}
}

void
assign_color()
{
	int u;

	int id = 1;
	for (u = 0; u < V; ++u)
		color[u] = nil;

	for (u = 0; u < V; ++u)
	{
		if (color[u] == nil)
			bfs(u, id++);
	}
}

void
add_edge(int u, int v)
{
	es[n_edge].to = v;
	es[n_edge].next = g[u];
	g[u] = n_edge;
	n_edge++;
}

int
main(int argc, char** argv)
{
	int m;
	int q;
	int s, t;
	int i;

	n_edge = 0;
	que_in = 0;
	que_out = 0;

	scanf("%d %d", &V, &m);
	for (i = 0; i < V; ++i)
		g[i] = nil;

	for (i = 0; i < m; ++i)
	{
		scanf("%d %d", &s, &t);
		add_edge(s, t);
		add_edge(t, s);
	}

	assign_color();
	scanf("%d", &q);
	for (i = 0; i < q; ++i)
	{
		scanf("%d %d", &s, &t);
		printf("%s\n", (color[s] == color[t]) ? "yes" : "no");
	}

	return 0;
}