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 + ;
 const int log_N =  + ;
 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[][u] = fa;
     dep[u] = d;
     for(int i=;i<G[u].size();i++)
     {
         pii e = G[u][i];
         int v = e.first, w = e.second;
         if(v != fa)
         {
             mx[][v] = w;
             dfs(v, u, d + );
         }
     }
 }
 void init_lca()
 {
     memset(par[], -, sizeof(par[]));
     memset(mx,,sizeof(mx));
     for(int i=;i<=n;i++) if(par[][i] == -) dfs(i, -, );
     for(int k=;k+<log_N;k++)
     {
         for(int u=;u<=n;u++)
         {
             if(par[k][u] < ) par[k+][u] = -;
             else par[k + ][u] = par[k][par[k][u]], mx[k + ][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 = -;
         if(dep[u] > dep[v]) swap(u, v);
         for(int k=;k<log_N;k++)
         {
             if((dep[v] - dep[u]) >> k & )
             {
                 ans = max(ans, mx[k][v]);
                 v = par[k][v];
             }
         }
         if(u == v) printf("%d\n",ans > i ? - : ans);
         else
         {
             for(int k = log_N - ; k >= ; 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[][u], mx[][v]));
             printf("%d\n",ans > i ? - : ans);
         }
     }
 }

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

 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&n,&m);
         for(int i=;i<=n;i++) G[i].clear(), root[i] = i;
         for(int i=;i<=m;i++)
         {
             scanf("%d%d%d",op+i,uu+i,vv+i);
             if(op[i] == )
             {
                 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 ;
 }