POJ 1741 Tree（树的点分治、树形dp、男人八题）

【题意】求树上距离小于等于K的点对有多少个

n有10000，所以必须卡到nlogn附近。变得尤为麻烦。

首先，一对符合要求的点，它们经过的路径中一定可以找到一个根节点。

每次我们都找以这个根为“中心”能形成多少点对。

所以假如我们把节点1作为整棵树的根，然后算通过“节点1”能形成多少点对，ans+之。再递归子树同样计算。但显然，这样很可能会重复计算。在根节点的子树中，如果有两个“孙子”节点能够通过该根节点形成符合要求的点对，那么在下一层它父亲的递归中（肯定也是符合要求的）会被多算一遍。所以我们在计算的时候，要减去同一子树下符合要求的点对。

在计算点对的时候，先把每个点到根的距离排序，利用尺取法可以O(N)解决。

以上步骤通过两次dfs可以解决。一次dfs求出每个根有多少点对，再一次算出答案

【必不可少的优化】

树的重心：所谓重心，就是子树节点数最大的最小的节点。

极端情况，树可能退化成一条链，复杂度变为 n*n*logn；不能接受

树的重心可以保证最多递归logn层就结束（证明略，差不多就是每次都2分的意思，所以是log2n），每次都从树的重心开始dfs，保证了复杂度最多为logn*n*logn。

只有树老司机才能A这题……

/* ***********************************************
Author        :angon

************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
#define lld %I64d
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scanl(d) scanf("%I64d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define scannl(n,m) scanf("%I64d%I64d",&n,&m)
#define mst(a,k)  memset(a,k,sizeof(a))
#define LL long long
#define N 10005
#define mod 1000000007
inline int read(){int s=0;char ch=getchar();for(; ch<'0'||ch>'9'; ch=getchar());for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';return s;}

struct Edge
{
    int to,len,next;
}edge[N*2];
int head[N],tot;

void addedge(int u,int v,int len)
{
    edge[tot].to = v;
    edge[tot].len = len;
    edge[tot].next = head[u];
    head[u] = tot++;
}
int n,k;
int vis[N];
int sonsize[N],sonmx[N];
int num,minc,root,ans;  //子树大小，子树最大 大小
int dis[N]; //子树距根的距离
void dfssize(int u,int fa)  //求子树大小
{
    sonsize[u]=1; sonmx[u]=0;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(vis[v] || v==fa) continue;
        dfssize(v,u);
        sonsize[u] += sonsize[v];  //  DP思想
        sonmx[u] = max(sonmx[u],sonsize[v]);  //保留最大
    }
}

void dfsroot(int r,int u,int fa) //求根为r的树的重心
{
    if(sonsize[r]-sonsize[u] > sonmx[u]) sonmx[u] = sonsize[r]-sonsize[u]; //u节点向上的子树
    if(sonmx[u]<minc) //子树最大的最小即为重心
    {
        minc=sonmx[u];
        root=u;
    }
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(vis[v] || v==fa) continue;
        dfsroot(r,v,u);
    }
}

void dfsdis(int u,int d,int fa) //子树节点到根的距离
{
    dis[num++] = d;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(vis[v] || v==fa) continue;
        dfsdis(v , d + edge[i].len , u);
    }
}

int cal(int u,int d)  //u为根的对数
{
    num=0;
    dfsdis(u,d,-1);
    sort(dis,dis+num);
    int ret=0, i=0,j=num-1;
    while(i<j)
    {
        while(dis[i]+dis[j]>k && i<j) j--;  //尺取
        ret += j-i;
        i++;
    }
    return ret;
}

void dfs1(int u,int fa) //logn
{
    minc=n;
    dfssize(u,fa);
    dfsroot(u,u,fa);
    ans += cal(root,0);   //logn
    vis[root]=1;
    for(int i=head[root]; ~i; i=edge[i].next)  //n
    {
        int v = edge[i].to;
        if(vis[v] || v==fa) continue;
        ans -= cal(v,edge[i].len);
        dfs1(v,root);

    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scann(n,k) && (n||k))
    {
        mst(head,-1); tot=0;
        REP(i,0,n-1)
        {
            int u,v,w;
            scann(u,v); scan(w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        ans=0;
        mst(vis,0);
        dfs1(1,-1);
        printf("%d\n",ans);
    }

    return 0;
}