[POI2014]Hotel

题目大意：
　　给你一颗$n(nle5000)$个点的树，选3个点使得它们两两距离相等，问共有几种选法。

思路：
　　首先我们不难发现一个性质：对于每3个符合条件的点，我们总能找到一个点使得这个点到那3个点距离相等。
　　我们不妨称之为“中转点”。
　　显然答案就是对于每个中转点，不同子树中到这个点距离相等的三元点对的数量。
　　我们可以先枚举每个点作为中转点的情况。
　　暴力求出以这个点的每个子结点为根的子树，不同深度的结点的数量（显然深度就是到这个中转点的距离）。
　　我们可以用calc[i][j]表示对于当前中转点，来自j个不同子树的深度为i的结点共有多少种不同的组合。
　　转移方程为calc[i][j]+=calc[i][j-1]*cnt[i]。

#include<cstdio>
#include<cctype>
#include<vector>
#include<cstring>
typedef long long int64;
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=5001;
std::vector<int> e[N];
inline void add_edge(const int &u,const int &v) {
    e[u].push_back(v);
    e[v].push_back(u);
}
int n,cnt[N];
int64 calc[N][4];
void dfs(const int &x,const int &par,const int &dep) {
    cnt[dep]++;
    for(unsigned i=0;i<e[x].size();i++) {
        const int &y=e[x][i];
        if(y==par) continue;
        dfs(y,x,dep+1);
    }
}
int main() {
    n=getint();
    for(register int i=1;i<n;i++) {
        add_edge(getint(),getint());
    }
    int64 ans=0;
    for(register int x=1;x<=n;x++) {
        memset(calc,0,sizeof calc);
        for(register int i=1;i<=n;i++) calc[i][0]=1;
        for(register unsigned i=0;i<e[x].size();i++) {
            memset(cnt,0,sizeof cnt);
            const int &y=e[x][i];
            dfs(y,x,1);
            for(register int j=3;j;j--) {
                for(register int i=0;i<=n;i++) {
                    calc[i][j]+=calc[i][j-1]*cnt[i];
                }
            }
        }
        for(register int i=1;i<=n;i++) {
            ans+=calc[i][3];
        }
    }
    printf("%lld
",ans);
    return 0;
} 　　现在考虑当$nle10^5$的情况。

　　考虑$nle10^5$的情况。
　　$f[i][j]$标示以$i$为根的子树中，与$i$距离为$j$的点数。$g[i][j]$标示以$i$为根的子树中，与$i$距离为$j$的点对数。则不难想到一种$O(n^2)$的转移：
　　$$
　　egin{align*}
　　&g[x][i-1]+=g[y][i]\
　　&g[x][i+1]+=f[x][i+1] imes f[y][i]\
　　&f[x][i+1]+=f[y][i]
　　end{align*}
　　$$
　　​边界为$f[x][0]=1$。
　　考虑优化这个转移，不难发现，若$y$是$x$枚举到的第一个子结点，则转移时只进行第一、第三个转移。因此我们可以考虑通过指针来实现，免去转移的过程。
　　将原树进行长链剖分，对于重边直接修改指针，对于轻边暴力转移，可以证明这样是$O(n)$的。

#include<list>
#include<cstdio>
#include<cctype>
typedef long long int64;
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=100001;
std::list<int> e[N];
int dep[N],bot[N];
int64 mem[N*6],ans,*f[N],*g[N],*ptr=mem;
inline void add_edge(const int &u,const int &v) {
    e[u].push_back(v);
    e[v].push_back(u);
}
void dfs(const int &x,const int &par) {
    dep[bot[x]=x]=dep[par]+1;
    for(std::list<int>::iterator i=e[x].begin();i!=e[x].end();i++) {
        const int &y=*i;
        if(y==par) continue;
        dfs(y,x);
        if(dep[bot[y]]>dep[bot[x]]) bot[x]=bot[y];
    }
    for(register std::list<int>::iterator i=e[x].begin();i!=e[x].end();i++) {
        const int &y=*i;
        if(y==par||(bot[y]==bot[x]&&x!=1)) continue;
        f[bot[y]]=ptr+=dep[bot[y]]-dep[x]+1;
        g[bot[y]]=++ptr;
        ptr+=(dep[bot[y]]-dep[x])*2+1;
    }
}
void dp(const int &x,const int &par) {
    for(std::list<int>::iterator i=e[x].begin();i!=e[x].end();i++) {
        const int &y=*i;
        if(y==par) continue;
        dp(y,x);
        if(bot[y]==bot[x]) {
            f[x]=f[y]-1;
            g[x]=g[y]+1;
        }
    }
    ans+=g[x][0];
    f[x][0]=1;
    for(register std::list<int>::iterator i=e[x].begin();i!=e[x].end();i++) {
        const int &y=*i;
        if(y==par||bot[y]==bot[x]) continue;
        for(register int i=0;i<=dep[bot[y]]-dep[x];i++) {
            ans+=f[x][i-1]*g[y][i]+g[x][i+1]*f[y][i];
        }
        for(register int i=0;i<=dep[bot[y]]-dep[x];i++) {
            g[x][i-1]+=g[y][i];
            g[x][i+1]+=f[x][i+1]*f[y][i];
            f[x][i+1]+=f[y][i];
        }
    }
}
int main() {
    const int n=getint();
    for(register int i=1;i<n;i++) {
        add_edge(getint(),getint());
    }
    dfs(1,0);
    dp(1,0);
    printf("%lld
",ans);
    return 0;
}