Egyptian Collegiate Programming Contest (ECPC 2015) C题 Connecting Graph

　　这题上次用的是线性求LCA过的，数据比较水，当时没有被T掉（不过线性的做法是在线的）。现在重新的分析一下这个问题。在所有的操作都进行完毕以后，这个图形肯定会变成一棵树，而我们的要求是在这棵树上的一条链上求出边权值t的最大值，那么很显然的可以使用树链剖分来解决这个问题（在做这题之前我还不知道LCA也可以获得一条链上的最值）。然后再看这个问题，因为不论是LCA还是树链剖分，都不能够动态的修改树的形状然后维护最值，因此，这样的做法只能够采用离线的做法。最后需要注意的一点是，因为最后求得的这棵树，在时间i的时候已经把后面的操作也加上了，也就是说如果这条链上的最值大于时间i，那么在这个时刻i实际上这两点是没有被联通的。

　　代码如下（LCA）：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;
const int N = 1e5 + 10;
const int log_N = 20 + 1;
typedef pair<int,int> pii;

int root[N];
int find(int x) {return x == root[x] ? x : root[x] = find(root[x]);}

int n,m,T;
int par[log_N][N];
int dep[N];
int op[N],uu[N],vv[N];
vector<pii> G[N];
int mx[log_N][N];
void dfs(int u,int fa,int d)
{
    par[0][u] = fa;
    dep[u] = d;
    for(int i=0;i<G[u].size();i++)
    {
        pii e = G[u][i];
        int v = e.first, w = e.second;
        if(v != fa)
        {
            mx[0][v] = w;
            dfs(v, u, d + 1);
        }
    }
}
void init_lca()
{
    memset(par[0], -1, sizeof(par[0]));
    memset(mx,0,sizeof(mx));
    for(int i=1;i<=n;i++) if(par[0][i] == -1) dfs(i, -1, 0);
    for(int k=0;k+1<log_N;k++)
    {
        for(int u=1;u<=n;u++)
        {
            if(par[k][u] < 0) par[k+1][u] = -1;
            else par[k + 1][u] = par[k][par[k][u]], mx[k + 1][u] = max(mx[k][u], mx[k][par[k][u]]);
        }
    }
}

void solve_lca(int u,int v,int i)
{
    if(find(u) != find(v)) puts("-1");
    else
    {
        int ans = -1;
        if(dep[u] > dep[v]) swap(u, v);
        for(int k=0;k<log_N;k++)
        {
            if((dep[v] - dep[u]) >> k & 1)
            {
                ans = max(ans, mx[k][v]);
                v = par[k][v];
            }
        }
        if(u == v) printf("%d
",ans > i ? -1 : ans);
        else
        {
            for(int k = log_N - 1; k >= 0; k--)
            {
                if(par[k][u] != par[k][v])
                {
                    ans = max(ans, mx[k][u]);
                    ans = max(ans, mx[k][v]);
                    u = par[k][u];
                    v = par[k][v];
                }
            }
            ans = max(ans, max(mx[0][u], mx[0][v]));
            printf("%d
",ans > i ? -1 : ans);
        }
    }
}

void solve()
{
    init_lca();
    for(int i=1;i<=m;i++)
    {
        if(op[i] == 2)
        {
            solve_lca(uu[i], vv[i], i);
        }
    }
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) G[i].clear(), root[i] = i;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",op+i,uu+i,vv+i);
            if(op[i] == 1)
            {
                int rx = find(uu[i]), ry = find(vv[i]);
                if(rx == ry) continue;
                root[ry] = rx;
                G[uu[i]].push_back(pii(vv[i], i));
                G[vv[i]].push_back(pii(uu[i], i));
            }
        }
        solve();
    }
    return 0;
}