Codeforces 804D Expected diameter of a tree（树的直径 + 二分 + map查询）

题目链接 Expected diameter of a tree

题目意思就是给出一片森林，

若把任意两棵树合并（合并方法为在两个树上各自任选一点然后连一条新的边）

求这棵新的树的树的直径的期望长度。

我们对每棵独立的树，对于这棵树的每一个点$u$，求出$f[u]$

$f[u]$为这棵树上离$u$最远的点到$u$的距离。

同时我们求出每棵树上的树的直径的长度

现在合并两棵树$A$和$B$的时候，合成的新的树的直径$C$其实有三种情况。

对$A$树中的某点$x$，$B$树中的某点$y$

1、可能是$A$树中树的直径，长度为$d[A]$

2、可能是$B$树中树的直径，长度为$d[B]$

3、可能是：离$A$树中点$x$最远的点$-->x-->y-->$离$B$树中点$y$最远的点

长度为$f[x] + f[y] + 1$

三种情求最大值即可

在枚举所有情况的时候，对每个点x枚举y

我们要求的是$max(f[x] + f[y] + 1, d[A], d[B])$

其中令$max(d[A], d[B]) = Z$

那么我们要求的就是$max(f[x] + f[y] + 1, Z)$

我们两两枚举$x$和$y$显然是要超时的，怎么优化呢？

我们可以在两棵树中选一棵规模较小的树，枚举这棵树上的每个点$x$

对于另一棵树$B$，二分一个临界值，在这个临界值两边

我分别取较大的$f[x] + f[y] + 1$ 或是 $Z$

这道题数据规模比较大，询问的时候的给出两个点，一个点在$A$树上，一个点在$B$树上

所以他如果不友好一点，在某两棵点很多的树上选很多不同的点对来构成很多次询问。

但事实上他们的本质是同一个询问，这个时候还是有可能超时。

那么我们就把每棵独立的树编号，每次处理完一个询问，把答案塞到map里面

那么下一次处理到本质相同的询问的时候，就可以直接拿出来了。

（这道题真的很锻炼代码能力，当初做的时候调了好几个小时……）

 #include <bits/stdc++.h>

 using namespace std;

 #define rep(i, a, b)    for (int i(a); i <= (b); ++i)
 #define dec(i, a, b)    for (int i(a); i >= (b); --i)

 typedef long long LL;

 const int N = ;

 int n, m, q, L, R, nowdep, treenum = ;
 int father[N], tr[N], c[N], f[N], d_max[N];
 vector <int> v[N], tree[N], dis[N], g[N];

 set < int > st;
 map < int, int  > mp;
 map < pair<int, int> , double > ans;
 map < pair<int, int> , int    > flag;

 int getfather(int x){
     return father[x] ? father[x] = getfather(father[x]) : x;
 }

 void dfs(int x, int fa, int dep){
     f[x] = max(f[x], dep);
     for (auto u : v[x]){
         if (u == fa) continue;
         dfs(u, x, dep + );
     }
 }    

 void dfs1(int x, int fa, int dep){
     if (dep > nowdep){
         L = x;
         nowdep = dep;
     }

     for (auto u : v[x]){
         if (u == fa) continue;
         dfs1(u, x, dep + );
     }
 }

 void dfs2(int x, int fa, int dep){
     if (dep > nowdep){
         R = x;
         nowdep = dep;
     }

     for (auto u : v[x]){
         if (u == fa) continue;
         dfs2(u, x, dep + );
     }
 }

 int main(){

     scanf("%d%d%d", &n, &m, &q);
     memset(father, , sizeof father);
     rep(i, , m){
         int x, y;
         scanf("%d%d", &x, &y);
         v[x].push_back(y);
         v[y].push_back(x);
         int fa = getfather(x), fb = getfather(y);
         if (fa != fb) father[fa] = fb;
     }

     rep(i, , n) st.insert(getfather(i));

     for (auto u : st){
         mp[u] = ++treenum;
         tr[treenum] = u;
     }

     rep(i, , n){
         int x = getfather(i);
         tree[mp[x]].push_back(i);
         c[i] = mp[x];
     }

     memset(f, , sizeof f);

     rep(i, , treenum){
         L = ; nowdep = -;
         dfs1(tree[i][], , );
         R = , nowdep = -;
         dfs2(L, , );
         dfs(L, , );
         dfs(R, , );
         for (auto u : tree[i]) dis[i].push_back(f[u]);
         sort(dis[i].begin(), dis[i].end());
         rep(j, , (int)tree[i].size() - ){
             if (j == ) g[i].push_back(dis[i][j]);
             else g[i].push_back(g[i][j - ] + dis[i][j]);
         }
         d_max[i] = dis[i][(int)tree[i].size() - ];
     }

     ans.clear();
     flag.clear();

     for (; q--; ){
         int x, y;
         scanf("%d%d", &x, &y);
         if (c[x] == c[y]){
             puts("-1");
             continue;
         }
         int na = c[x], nb = c[y];
         if ((int) tree[na].size() > (int) tree[nb].size()) swap(na, nb);
         if (flag[{na, nb}]){
             printf("%.12f\n", ans[{na, nb}]);
             continue;
         }

         LL X = ;
         LL Y = (LL) tree[na].size() * tree[nb].size();
         LL Z = max(d_max[na], d_max[nb]);
         for (auto u1 : tree[na]){
             LL A = lower_bound(dis[nb].begin(), dis[nb].end(), Z -  - f[u1]) - dis[nb].begin();
             X += (LL) A * Z +
                              (LL) (g[nb][(int)tree[nb].size() - ] +  (int)tree[nb].size() - A - (A ? g[nb][A - ] : )) +
                              (f[u1]) * ((LL) tree[nb].size() - A);
         }

                 double cnt_ans = (double) X / (double) Y;
         printf("%.12f\n", cnt_ans);

         flag[{na, nb}] = ;
         ans[{na, nb}] = cnt_ans;
     }

     return ;
 }