POJ1741 点分治

树分治算法详看 点击打开链接

算法过程：

1、找出当前树的重心点root

2、然后从这重心开始遍历、找出到树其他结点的距离，并且从小到大排序

（这里已经包括了root这个点，会产生<root,i>点对）

3、然后利用单调性解出“满足条件”的个数

4、但是上述求出的个数是有一些不满足的、例如有一些点对同处于root的某一个孩子树，所以要把同处于一个孩子树的点对数量给去掉~~

这里满足dist[i]+dist[j]<=k的情况由三种~~~  <root,D>、<A,E>A、E并不在同一个子树、<B,C>B、C在同一个子树

第三种情况是不符合的。所以这里要减去第三种情况，即黑色路径的情况~~

总的来说就是对当前根节点满足的条件数量为：=满足dist[i]+dist[j]<=k的数量-满足dist[i]+dist[j]<=k的数量且i、j在根节点的同一孩子树的数量~~~

#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for0(a,b) for(int a=0;a<=b;a++)//0---(b-1)
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
#define cnt_one(i) __builtin_popcount(i)
#define stl(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c,__ll &d){READ(m);READ(a);READ(b);READ(c);read(d);}
template < class T > inline  void out(T a){if(a>9)out(a/10);putchar(a%10+'0');}
template < class T > inline  void outln(T a){if(a>9)out(a/10);putchar(a%10+'0');puts("");}
template < class T > inline  void out(T a,T b){out(a);putchar(' ');out(b);}
template < class T > inline  void outln(T a,T b){out(a);putchar(' ');outln(b);}
template < class T > inline  void out(T a,T b,T c){out(a);putchar(' ');out(b);putchar(' ');out(c);}
template < class T > inline  void outln(T a,T b,T c){out(a);putchar(' ');outln(b);putchar(' ');outln(b);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int cnt_edge=20100;  //修改啊
const int cnt_v=10100;
int head[cnt_v],cnt_e;
struct EDGE
{int u,v,next,cost;}edge[cnt_edge];
void init()
{cnt_e=0;memset(head,-1,sizeof(head));}
void addedge(int u,int v,int cost=0)
{edge[cnt_e].u=u;edge[cnt_e].v=v;edge[cnt_e].cost=cost;edge[cnt_e].next=head[u];head[u]=cnt_e++;}

int n,k;
int root,tot,ans;
int minn,size[10100];///minn：衡量某个节点是否能当重心，minn越小 就越可以当重心、size[i] i子树的大小
bool del[10100];///记录是否已经删除这个点...
int cnt,dist[10100];

void getroot(int u,int fa)
{
    size[u]=1;
    int maxn=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa||del[v])continue;///这里必须要加上del[v]
        getroot(v,u);
        size[u]+=size[v];
        maxn=max(maxn,size[v]);
    }
    maxn=max(maxn,tot-size[u]);
    if(maxn<minn)root=u,minn=maxn;
}
void getdist(int u,int fa,int len)
{
    dist[++cnt]=len;///这里只需要知道距离就好了，不需要明确是谁到root的距离~~
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa||del[v])continue;///这里必须要加上del[v]
        getdist(v,u,len+edge[i].cost);
    }
}
int cal(int u,int len)
{
    cnt=0;
    getdist(u,0,len);
    sort(dist+1,dist+1+cnt);
    int l=1,r=cnt;
    int ret=0;
    while(l<r)///利用单调性~~~
    {
        if(dist[l]+dist[r]<=k)ret+=r-l,l++;
        else r--;
    }
    return ret;
}
void word(int u)
{
    ans+=cal(u,0);   ///找出任意两点和<=k的对数
    del[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)  ///但是有一些违规的点对在同一个孩子子树里  要去掉~~~
    {
        int v=edge[i].v;
        if(del[v])continue;///已经访问过就不访问了~~
        ans-=cal(v,edge[i].cost);///去掉。这里距离记得是edge[i].cost 因为它是由root到达的....
        minn=INF,tot=size[v];  ///并且对这个孩子树进行分治
        getroot(v,u);
        word(root);
    }
}
int main()
{
    while(read(n,k),n+k)
    {
        init();
        for1(i,n-1)
        {
            int a,b,c;
            read(a,b,c);
            addedge(a,b,c);
            addedge(b,a,c);
        }                    ///读入
        ans=0;
        memset(del,0,sizeof del); ///做题初始化
        minn=INF,tot=n;
        getroot(1,0);      ///找到一棵树的重，tot为该树的大小....
        word(root);
        outln(ans);
    }
    return 0;
}