Codeforces 161.D. Distance in Tree-树分治(点分治，不容斥版)-树上距离为K的点对数量-蜜汁TLE (VK Cup 2012 Round 1)

D. Distance in Tree

time limit per test

3 seconds

memory limit per test

512 megabytes

input

standard input

output

standard output

A tree is a connected graph that doesn't contain any cycles.

The distance between two vertices of a tree is the length (in edges) of the shortest path between these vertices.

You are given a tree with n vertices and a positive number k. Find the number of distinct pairs of the vertices which have a distance of exactly k between them. Note that pairs (v, u) and (u, v) are considered to be the same pair.

Input

The first line contains two integers n and k (1 ≤ n ≤ 50000, 1 ≤ k ≤ 500) — the number of vertices and the required distance between the vertices.

Next n - 1 lines describe the edges as "ai bi" (without the quotes) (1 ≤ ai, bi ≤ n, ai ≠ bi), where ai and bi are the vertices connected by the i-th edge. All given edges are different.

Output

Print a single integer — the number of distinct pairs of the tree's vertices which have a distance of exactly k between them.

Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Examples

input

Copy

5 2
1 2
2 3
3 4
2 5

output

Copy

4

input

Copy

5 3
1 2
2 3
3 4
4 5

output

Copy

2

Note

In the first sample the pairs of vertexes at distance 2 from each other are (1, 3), (1, 5), (3, 5) and (2, 4).

这道题就是求树上距离为K的点对数量。以前写过<=K的点对数量，直接<=K的数量 - <K的数量，讲道理应该也是可以的，但是一直TLE11和TLE17样例。。。

最后换了一种写法，直接求，没有中间-子树的过程，最后过了，有点迷。。。

不容斥版的快，就这样。

代码:

//树分治-点分治
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
//#pragma GCC optimize(2)
//#define FI(n) FastIO::read(n)
const int inf=1e9+7;
const int maxn=1e5+10;
const int maxm=500+10;

int head[maxn<<1],tot;
int root,allnode,n,m,k;
bool vis[maxn];
int deep[maxn],dis[maxn],siz[maxn],maxv[maxn];//deep[0]子节点个数(路径长度)，maxv为重心节点
int num[maxm],cnt[maxm];
ll ans=0;

//namespace FastIO {//读入挂
//    const int SIZE = 1 << 16;
//    char buf[SIZE], obuf[SIZE], str[60];
//    int bi = SIZE, bn = SIZE, opt;
//    int read(char *s) {
//        while (bn) {
//            for (; bi < bn && buf[bi] <= ' '; bi++);
//            if (bi < bn) break;
//            bn = fread(buf, 1, SIZE, stdin);
//            bi = 0;
//        }
//        int sn = 0;
//        while (bn) {
//            for (; bi < bn && buf[bi] > ' '; bi++) s[sn++] = buf[bi];
//            if (bi < bn) break;
//            bn = fread(buf, 1, SIZE, stdin);
//            bi = 0;
//        }
//        s[sn] = 0;
//        return sn;
//    }
//    bool read(int& x) {
//        int n = read(str), bf;
//
//        if (!n) return 0;
//        int i = 0; if (str[i] == '-') bf = -1, i++; else bf = 1;
//        for (x = 0; i < n; i++) x = x * 10 + str[i] - '0';
//        if (bf < 0) x = -x;
//        return 1;
//    }
//};

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x;
}

struct node{
    int to,next,val;
}edge[maxn<<1];

void add(int u,int v,int w)//前向星存图
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    edge[tot].val=w;
    head[u]=tot++;
}

void init()//初始化
{
    memset(head,-1,sizeof head);
    memset(vis,0,sizeof vis);
    tot=0;
}

void get_root(int u,int father)//重心
{
    siz[u]=1;maxv[u]=0;
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].to;
        if(v==father||vis[v]) continue;
        get_root(v,u);//递归得到子树大小
        siz[u]+=siz[v];
        maxv[u]=max(maxv[u],siz[v]);//更新u节点的maxv
    }
    maxv[u]=max(maxv[u],allnode-siz[u]);//保存节点size
    if(maxv[u]<maxv[root]) root=u;//更新当前子树的重心
}

void get_dis(int u,int father)//获取子树所有节点与根的距离
{
    if(dis[u]>k) return ;
    ans+=num[k-dis[u]];
    cnt[dis[u]]++;//计数
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].to;
        if(v==father||vis[v]) continue;
        int w=edge[i].val;
        dis[v]=dis[u]+w;
        get_dis(v,u);
    }
}

void cal(int u,int now)
{
    for(int i=1;i<=k;i++){//初始化，清空
        num[i]=0;
    }
    num[0]=1;
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].to;
        if(vis[v]) continue;
        for(int j=0;j<=k;j++){//初始化
            cnt[j]=0;
        }
        dis[v]=now;
        get_dis(v,u);//跑路径
        for(int j=0;j<=k;j++){
            num[j]+=cnt[j];//计数
        }
    }
}

void solve(int u)//分治处理
{
    cal(u,1);
    vis[u]=1;
    for(int i=head[u];~i;i=edge[i].next){
        int v=edge[i].to;
        int w=edge[i].val;
        if(vis[v]) continue;
        allnode=siz[v];
        root=0;
        get_root(v,u);
        solve(root);
    }
}

int main()
{
//    FI(n);FI(k);
    n=read();k=read();
    init();
    for(int i=1;i<n;i++){
        int u,v,w;w=1;
//        FI(u);FI(v);
        u=read();v=read();
        add(u,v,w);
        add(v,u,w);
    }
    root=0;allnode=n;maxv[0]=inf;
    get_root(1,0);
    solve(root);
    printf("%lld
",ans);
    return 0;
}