Problem:
Score : 1400 points

Problem Statement

There is a tree with N vertices numbered 1 through N.
The i-th of the N-1 edges connects vertices a_i and b_i.

Initially, each edge is painted blue.
Takahashi will convert this blue tree into a red tree, by performing the following operation N-1 times:

Select a simple path that consists of only blue edges, and remove one of those edges.

Then, span a new red edge between the two endpoints of the selected path.

His objective is to obtain a tree that has a red edge connecting vertices c_i and d_i, for each i.

Determine whether this is achievable.

Constraints

2 ≤ N ≤ 10^5

1 ≤ a_i,b_i,c_i,d_i ≤ N

a_i ≠ b_i

c_i ≠ d_i

Both input graphs are trees.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}

Output

Print YES if the objective is achievable; print NO otherwise.

Sample Input 1

3
1 2
2 3
1 3
3 2

Sample Output 1

YES

The objective is achievable, as below:

First, select the path connecting vertices 1 and 3, and remove a blue edge 1-2. Then, span a new red edge 1-3.

Next, select the path connecting vertices 2 and 3, and remove a blue edge 2-3. Then, span a new red edge 2-3.

Sample Input 2

5
1 2
2 3
3 4
4 5
3 4
2 4
1 4
1 5

Sample Output 2

YES

Sample Input 3

6
1 2
3 5
4 6
1 6
5 1
5 3
1 4
2 6
4 3
5 6

Sample Output 3

NO

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
#define ls  (n<<1)
#define rs  (ls|1)
using namespace std;

const int N=100010;
struct edge{int s,t,n;}e[2*N],E[N];
int n,h[N],f[N],g[N],siz[N],hs[N],dfn[N],dep[N],t1[4*N],t2[4*N],tag[4*N],Xor[4*N];

void dfs(int x,int fa)
{
	f[x]=fa,siz[x]=1;
	for (int i=h[x],y; y=e[i].t,i; i=e[i].n)
		if (y!=fa)
			{
				dfs(y,x),siz[x]+=siz[y];
				if (siz[y]>siz[hs[x]])  hs[x]=y;
			}
}

void dfs2(int x,int gf)
{
	g[x]=gf,dfn[x]=++dfn[0],dep[x]=dep[f[gf]]+1;
	if (hs[x])  dfs2(hs[x],gf);
	for (int i=h[x],y; y=e[i].t,i; i=e[i].n)
		if ((y!=f[x])&&(y!=hs[x]))  dfs2(y,y);
}

void merge(int n)
{
	if (t1[ls]<t1[rs])  t1[n]=t1[ls],t2[n]=min(t2[ls],t1[rs]);
	else  if (t1[ls]>t1[rs])  t1[n]=t1[rs],t2[n]=min(t2[rs],t1[ls]);
	else  t1[n]=t1[ls],t2[n]=min(t2[ls],t2[rs]);
	t1[n]+=tag[n],t2[n]+=tag[n];
}

void modify(int n,int l,int r,int L,int R,int k)
{
	if ((L<=l)&&(r<=R))
		if (k>0)  Xor[n]^=k,t1[n]++,t2[n]++,tag[n]++;
		else  Xor[n]^=-k,t1[n]--,t2[n]--,tag[n]--;
	else
		{
			int mid=(l+r)>>1;
			if (L<=mid)  modify(ls,l,mid,L,R,k);
			if (mid<R)  modify(rs,mid+1,r,L,R,k);
			merge(n);
		}
}

int find(int n,int l,int r)
{
	if (tag[n]==1)  return Xor[n];
	int mid=(l+r)>>1;
	return (t1[ls]==1)||(t2[ls]==1)?find(ls,l,mid):find(rs,mid+1,r);
}

void modify(int x,int y,int k)
{
	while (g[x]!=g[y])
		{
			if (dep[x]<dep[y])  swap(x,y);
			modify(1,1,n,dfn[g[x]],dfn[x],k),x=f[g[x]];
		}
	if (dfn[x]>dfn[y])  swap(x,y);
	if (x!=y)  modify(1,1,n,dfn[x]+1,dfn[y],k);
}

void work()
{
	scanf("%d",&n);
	for (int i=1,u,v,tot=0; i<n; i++)
		{
			scanf("%d %d",&u,&v);
			e[++tot]=(edge){u,v,h[u]},h[u]=tot;
			e[++tot]=(edge){v,u,h[v]},h[v]=tot;
		}
	for (int i=1; i<n; i++)  scanf("%d %d",&E[i].s,&E[i].t);
	dfs(1,0),dfs2(1,1),memset(t2,127,sizeof(t2));
	for (int i=1; i<n; i++)  modify(E[i].s,E[i].t,i);
	for (int i=1,j; i<n; i++)
		if (t2[1]==1)  j=find(1,1,n),modify(E[j].s,E[j].t,-j);
		else  puts("NO"),exit(0);
	puts("YES");
}

int main()
{
	work();
	return 0;
}