[POI2014]Hotel加强版【长链剖分】

题目链接 BZOJ 4543

---

给定一棵树，在树上选 3 个点，要求两两距离相等，求方案数。

这个真的不好想，真的好难好难哎。

首先，我们不妨看成固定两点求第三点这样的策略，使得计算答案变得略微方便处理一些。

固定一个二维点对(x, y)表示：

使得，x和y满足这样的条件：

我们不妨设也就是，我们知道这样的(x, y)点对，去寻找可能的z点的。z点有一个性质，就是距离u点的距离为j。

那么，我们需要记录二维点对的一个dp方程，还要一个记录点u深度为j的点的个数的这样的一个dp方程。

表示点u为子树的根结点中，距离它为j个单位长度的点的数量；

表示以u为子树的根结点中，合法点对(x, y)，且要找距离为j的点的，此时的合法点对的数量。

于是有方程：

这样，长链剖分的方程便列出来了。

  关于长链剖分的开空间，和空间分配，这里仍然需要特别处理，是比较好处理的，是因为它是顺序的，但是需要仔细处理了，尤其是空间分配。

  数组的内存，自然是顺序向下的，但是譬如说，v是u的重儿子，但是却容易发现，是反向的，同理也就是说，它实际上是反着分配空间的，所以要给足够提前量。

  然而，我们使用数组的时候却是正序向后，所以内存要预留两倍以上。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define eps 1e-8
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
int N, head[maxN], cnt;
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxN << 1];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
int len[maxN], Wson[maxN];
void pre_dfs(int u, int fa)
{
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa) continue;
        pre_dfs(v, u);
        if(len[v] > len[Wson[u]]) Wson[u] = v;
    }
    len[u] = len[Wson[u]] + 1;
}
ll ans = 0, tmp[maxN << 2], *f[maxN], *id, smp[maxN << 2], *g[maxN], *sd;
void dfs(int u, int fa)
{
    f[u][0] = 1;
    if(Wson[u])
    {
        f[Wson[u]] = f[u] + 1;
        g[Wson[u]] = g[u] - 1;
        dfs(Wson[u], u);
    }
    ans += g[u][0];
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa || v == Wson[u]) continue;
        f[v] = id;
        id += len[v];
        sd += (len[v] << 1) + 10;
        g[v] = sd;
        dfs(v, u);
        for(int j=0; j<len[v]; j++)
        {
            if(j) ans += f[u][j - 1] * g[v][j];
            ans += f[v][j] * g[u][j + 1];
        }
        for(int j=0; j<len[v]; j++)
        {
            if(j) g[u][j - 1] += g[v][j];
            g[u][j + 1] += f[v][j] * f[u][j + 1];
            f[u][j + 1] += f[v][j];
        }
    }
}
inline void init()
{
    cnt = 0;
    for(int i=1; i<=N; i++) head[i] = -1;
}
int main()
{
    scanf("%d", &N);
    init();
    for(int i=1, u, v; i<N; i++)
    {
        scanf("%d%d", &u, &v);
        _add(u, v);
    }
    pre_dfs(1, 0);
    id = tmp; sd = smp;
    f[1] = id;
    id += len[1];
    sd += (len[1] << 1) + 10;
    g[1] = sd;
    dfs(1, 0);
    printf("%lld\n", ans);
    return 0;
}