【CF650E】 Clockwork Bomb

题目

题目描述
My name is James diGriz, I’m the most clever robber and treasure hunter in the whole galaxy. There are books written about my adventures and songs about my operations, though you were able to catch me up in a pretty awkward moment.

I was able to hide from cameras, outsmart all the guards and pass numerous traps, but when I finally reached the treasure box and opened it, I have accidentally started the clockwork bomb! Luckily, I have met such kind of bombs before and I know that the clockwork mechanism can be stopped by connecting contacts with wires on the control panel of the bomb in a certain manner.

I see n n contacts connected by n-1 n−1 wires. Contacts are numbered with integers from 1 1 to n n . Bomb has a security mechanism that ensures the following condition: if there exist k>=2 k>=2 contacts c_{1},c_{2},…,c_{k} c
1
​
,c
2
​
,…,c
k
​
forming a circuit, i. e. there exist k k distinct wires between contacts c_{1} c
1
​
and c_{2} c
2
​
, c_{2} c
2
​
and c_{3} c
3
​
, … … , c_{k} c
k
​
and c_{1} c
1
​
, then the bomb immediately explodes and my story ends here. In particular, if two contacts are connected by more than one wire they form a circuit of length 2 2 . It is also prohibited to connect a contact with itself.

On the other hand, if I disconnect more than one wire (i. e. at some moment there will be no more than n-2 n−2 wires in the scheme) then the other security check fails and the bomb also explodes. So, the only thing I can do is to unplug some wire and plug it into a new place ensuring the fact that no circuits appear.

I know how I should put the wires in order to stop the clockwork. But my time is running out! Help me get out of this alive: find the sequence of operations each of which consists of unplugging some wire and putting it into another place so that the bomb is defused.

输入格式
The first line of the input contains n n ( 2<=n<=500000 2<=n<=500000 ), the number of contacts.

Each of the following n-1 n−1 lines contains two of integers x_{i} x
i
​
and y_{i} y
i
​
( 1<=x_{i},y_{i}<=n 1<=x
i
​
,y
i
​
<=n , x_{i}≠y_{i} x
i
​


​
=y
i
​
) denoting the contacts currently connected by the i i -th wire.

The remaining n-1 n−1 lines contain the description of the sought scheme in the same format.

It is guaranteed that the starting and the ending schemes are correct (i. e. do not contain cicuits nor wires connecting contact with itself).

输出格式
The first line should contain k k ( k>=0 k>=0 ) — the minimum number of moves of unplugging and plugging back some wire required to defuse the bomb.

In each of the following k k lines output four integers a_{i} a
i
​
, b_{i} b
i
​
, c_{i} c
i
​
, d_{i} d
i
​
meaning that on the i i -th step it is neccesary to unplug the wire connecting the contacts a_{i} a
i
​
and b_{i} b
i
​
and plug it to the contacts c_{i} c
i
​
and d_{i} d
i
​
. Of course the wire connecting contacts a_{i} a
i
​
and b_{i} b
i
​
should be present in the scheme.

If there is no correct sequence transforming the existing scheme into the sought one, output -1.

题意翻译
给出两棵n个节点的树，每次操作可以把第一棵树的一条边删掉然 后连另外两个点，且必须满足每次操作完之后仍是一棵树

问最少需要多少步操作才能把第一棵树变成第二棵树(是完全相 同,并不是同构),并输出方案

n ≤ 500000

输入输出样例
输入 #1 复制
3
1 2
2 3
1 3
3 2
输出 #1 复制
1
1 2 1 3
输入 #2 复制
4
1 2
2 3
3 4
2 4
4 1
1 3
输出 #2 复制
3
1 2 1 3
4 3 4 1
2 3 2 4
说明/提示
Picture with the clarification for the sample tests:

思路

首先答案显然是[n-1-两棵树共有的边]
那么我们把这些边用并查集合并缩点
考虑这样一个过程，每次找到第一棵树的叶子x，把x和父亲的边删掉，然后连上第二棵树上的x和父亲，这样做显然不会出现环
这个东西也可以用并查集维护。
复杂度O(nα(n))

代码

#include<bits/stdc++.h>
#define rg register
using namespace std;
template < typename T > void read(T& s) {
    s = 0; int f = 0; char c = getchar();
    while (!isdigit(c)) f |= (c == '-'),c = getchar();
    while (isdigit(c)) s = s * 10 + (c ^ 48),c = getchar();
    s = f ? -s : s;
}

const int N = 500000 + 10;

int n,ff[2][N],fa[N];
vector < int > e[2][N];
struct node{ int a,b,c,d; };
vector < node > ans;

int findd(int x) { return fa[x] == x ? x : findd(fa[x]); }

void dfs(int x,int u,int f) {
    for (rg int v : e[x][u]) {
        if (v == f) continue;
        ff[x][v] = u,dfs(x,v,u);
    }
}

void dfss(int u,int f) {
    for (rg int v : e[0][u]) {
        if (v == f) continue; dfss(v,u);
        if (u != ff[1][v] && v != ff[1][u])
            ans.pushNback((node) { v,u,findd(v),ff[1][findd(v)] });
    }
}

int main()
{
    read(n);
    for (rg int u,v,i = 1; i < n; ++i) read(u),read(v),e[0][u].pushNback(v),e[0][v].pushNback(u);
    for (rg int u,v,i = 1; i < n; ++i) read(u),read(v),e[1][u].pushNback(v),e[1][v].pushNback(u);
    dfs(0,1,0);
    dfs(1,1,0);
    for (rg int i = 2; i <= n; ++i)
	{
        int u = ff[1][i];
        if (u == ff[0][i] || i == ff[0][u])
            fa[i] = u;
        else
            fa[i] = i;
    }
    dfss(1,0);
    printf("%d\n",(int) ans.size());
    for (rg node x : ans) printf("%d %d %d %d\n",x.a,x.b,x.c,x.d);
    return 0;
}