【CODEFORCES】 C. Civilization

C. Civilization

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Andrew plays a game called "Civilization". Dima helps him.

The game has n cities and m bidirectional roads. The cities are numbered from 1 to n. Between any pair of cities there either is a single (unique) path, or there is no path at all. A path is such a sequence of distinct cities v₁, v₂, ..., v_k, that there is a road between any contiguous cities v_i and v_i + 1 (1 ≤ i < k). The length of the described path equals to (k - 1). We assume that two cities lie in the same region if and only if, there is a path connecting these two cities.

During the game events of two types take place:

1. Andrew asks Dima about the length of the longest path in the region where city x lies.
2. Andrew asks Dima to merge the region where city x lies with the region where city y lies. If the cities lie in the same region, then no merging is needed. Otherwise, you need to merge the regions as follows: choose a city from the first region, a city from the second region and connect them by a road so as to minimize the length of the longest path in the resulting region. If there are multiple ways to do so, you are allowed to choose any of them.

Dima finds it hard to execute Andrew's queries, so he asks you to help him. Help Dima.

Input

The first line contains three integers n, m, q (1 ≤ n ≤ 3·10⁵; 0 ≤ m < n; 1 ≤ q ≤ 3·10⁵) — the number of cities, the number of the roads we already have and the number of queries, correspondingly.

Each of the following m lines contains two integers, a_i and b_i (a_i ≠ b_i; 1 ≤ a_i, b_i ≤ n). These numbers represent the road between cities a_iand b_i. There can be at most one road between two cities.

Each of the following q lines contains one of the two events in the following format:

• 1 x_i. It is the request Andrew gives to Dima to find the length of the maximum path in the region that contains city x_i (1 ≤ x_i ≤ n).
• 2 x_i y_i. It is the request Andrew gives to Dima to merge the region that contains city x_i and the region that contains city y_i (1 ≤ x_i, y_i ≤ n). Note, that x_i can be equal to y_i.

Output

For each event of the first type print the answer on a separate line.

Sample test(s)

input

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

output

4

题解：这一题给人的第一感觉是要用并查集，而且我需要知道并查集的直径（最长的路径）。现在假设有两个点X,Y且他们不属于一个集合，可以想到我如果知道了X和Y各自所在集合的直径，我又不用去关心如何合并，我一定可以求出X和Y这两个集合合并后集合的最大直径且使他最小。方程为 MAX(MAX(WAY[FATHER(X)],WAY[FATHER(Y)]),WAY[(FATHER(X)]+1)/2+WAY[FATHER(Y)]+1)/2+1 )  

后面那个之所以是+1在整除2是因为要上取整，前面之所以求X和Y各自所在集合的最大值是因为集合本身可能有比合并后理想长度更大的路径。这样我们求出了方程，我们把每个集合的解记录在根上就可以了。

//求直径的时候参考了别人的方法- =    这是他的代码： http://xwk.iteye.com/blog/2130688

并查集要优化，不然超时.....

#include <iostream>
#include <cstdio>
#include <vector>

using namespace std;

vector<int> c[300002];
int a,b,n,m,q,t,i,root,ans,x,y,way[300002],f[300002];


int father(int k)
{
    if (f[k]==k) return f[k];
    else return f[k]=father(f[k]);
}

void slove(int x,int y)
{
    int p,v,t,g,h;
    t=father(x); v=father(y);
    if (t==v) return;
    p=max(way[t],way[v]);
    g=way[t]; h=way[v];
    f[t]=v;
    way[v]=max(p,(++g)/2+(++h)/2+1);
}

void dfs(int k,int l,int d)
{
    f[k]=root;
    if (d>ans)
    {
        ans=d;
        t=k;
    }

    vector<int>::iterator it;
    for (it=c[k].begin();it!=c[k].end();it++)
        if (*it!=l) dfs(*it,k,d+1);
}

int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for (int i=0;i<=n;i++) c[i].clear();
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&a,&b);
        c[a].push_back(b);
        c[b].push_back(a);
    }
    // set
    for (int i=1;i<=n;i++) f[i]=i;
    for (int i=1;i<=n;i++)
        if (f[i]==i)
    {
        root=i;
        ans=-1;
        dfs(i,0,0);
        ans=-1;
        dfs(t,0,0);
        way[i]=ans;
    }
    for (int i=1;i<=q;i++)
    {
        scanf("%d",&a);
        if (a==1)
        {
            scanf("%d",&x);
            cout <<way[father(x)]<<endl;
        }
        else
        {
            scanf("%d%d",&x,&y);
            slove(x,y);
        }
    }
    return 0;
}