（树形dp+LCA倍增法）CSU 1915

题意：

有一个棵树，现在让你找两个点连接起来，这样必然成为一个环，现在要求这些环长度的期望，也就是平均值。

分析：

第一次做LCA题，做多校的时候，瞎几把找了模板敲，敲了个八九不离十，只是姿势不太好，需要考虑很多细节。

其实我觉得这题最多只能算中等题。

因为一直没空，写题解也晚了，已经有很多人写了题解，都写的不错。反正比我厉害。

这题用倍增法比较好一些，因为会用到关键点，也就是当v和u处在同一棵子树中时，找到更高点的下面那个点，倍增法通过深度跳跃可以很快找到。处理起来比其他两个LCA算法都方便。

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>


using namespace std;

const int inf = 0x3f3f3f3f;
const int maxn = 100010;
const int DEG = 20;

#define fi first
#define se second

typedef long long ll;

vector<int>  g[maxn];

int fa[maxn][DEG];
int deg[maxn];

int n, q;
int u, v;

void bfs(int root) {
    queue<int> q;
    deg[root] = 0;
    fa[root][0] = root;
    q.push(root);
    while(!q.empty()) {
        int tmp = q.front();
        q.pop();
        for(int i = 1; i < DEG; i++) {
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for(int i = 0; i < g[tmp].size(); i++) {
            int v = g[tmp][i];
            if(v == fa[tmp][0])continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            q.push(v);
        }
    }
}

int LCA(int u, int v) {
    if(deg[u] > deg[v])swap(u, v);
    for(int det = deg[v] - deg[u], i = 0; det; det >>= 1, i++) {
        if(det & 1)v = fa[v][i];
    }
    if(u == v)return u;
    for(int i = DEG - 1; i >= 0; i--) {
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}

int len[maxn][2];
int son[maxn];

void dfs1(int u, int pre) {
    son[u] = 1;
    for(int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if(v == pre)continue;
        dfs1(v, u);
        son[u] += son[v];
        len[u][0] += len[v][0] + son[v];
    }
    len[u][1] = len[u][0];
}

void dfs2(int u, int pre) {
    for(int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if(v == pre)continue;
        len[v][1] += (len[u][1] - len[v][0] - son[v] + n - son[v]);
        dfs2(v, u);
    }
}

int up(int x, int step) {
    for(int i = 0; i < DEG; i++) {
        if(step & (1 << i))x = fa[x][i];
    }
    return x;
}

void init() {
    memset(len, 0, sizeof(len));
    memset(son, 0, sizeof(son));
    for(int i = 0; i < maxn; i++)g[i].clear();
}




int main() {
    while(~scanf("%d%d", &n, &q)) {
        init();
        for(int i = 0; i < n - 1; i++) {
            scanf("%d%d", &u, &v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        bfs(1);
        dfs1(1, 1);
        dfs2(1, 1);

        while(q--) {
            scanf("%d%d", &u, &v);
            if(deg[u] < deg[v])swap(u, v);
            int f = LCA(u, v);
            int dis = deg[u] + deg[v] - deg[f] * 2;
            if(f == v) {
                int core = up(u, deg[u] - deg[v] - 1);
                ll sum = (ll)son[u] * (n - son[core]);
                ll tolen = (ll)len[u][0] * (n - son[core]) + (ll)(len[v][1] - len[core][0] - son[core]) * son[u] + (ll)dis * sum + sum;
                printf("%f
", tolen * 1.0 / sum);
            } else {
                ll sum = (ll)son[v] * son[u];
                ll tolen = (ll)len[v][0] * son[u] + (ll)len[u][0] * son[v] + (ll)sum * dis + sum;
                printf("%f
", tolen * 1.0 / sum);
            }


        }

    }
    return 0;

}