分治入门——树分治

分治思想：划分子问题，解决子问题，合并子问题

题目：POJ1741
题意：给定一棵含有n个节点的无向带权树，满足距离≤k的两点共有多少对？（n≤1e4）

题解：
（1）首先找到树A的重心，（重心指的是一个节点，将该节点删去之后剩下的最大子树的节点数最小）将其作为树A的根。在数列的分治之中我们是直接去区间的中间为分界线，但是这里，如果随意将某个点删去，最坏的情况可能是这棵树退化成一条链，递归的深度变成了O(n)。而将重心删去后，剩余子树中的最大子树大小≤n/2（必然），递归深度为O(logn)。

（2）找到树A重心为根节点之后，将其划分为以儿子为根的众多子树，再添加一个只有一个节点子树，该节点直接连接根节点且边权为0。计算满足答案且经过根节点的（i，j）的对数（前面添加的单节点子树就是计算根节点到其余节点的答案）累加到ans。但是这里面得到的答案包含了来自同一棵子树的（i，j），因为他们经过了根节点的路径并不是最短路，而在后续的子问题解决中还会计算到，因此在这里需要减去来自同一棵子树的（i，j）的答案数。

（3）将根节点删去之后，分治解决子树相同问题

源码如下：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define pb push_back

using namespace std;
const int maxn = 10005, inf = 0x3f3f3f3f;

struct Edge
{
    int to, next, dist;
}edge[maxn<<1];
int head[maxn], cnt;

void addedge(int u, int v, int w)
{
    edge[cnt].to = v;
    edge[cnt].dist = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

int n, k, ans;
int num[maxn];//num[i]表示以i为根的树 的节点数
int dp[maxn];//一维滚动。dp[i]将i删去后 当前树的最大联通块的大小

int Stack[maxn], top1;//栈
bool vis[maxn] ;//true表删除
int size;//当前树的节点数
int root;//根节点

void get_root(int u, int fa)//深搜遍历的同时找寻树的重心root
{
    dp[u] = 0;
    num[u] = 1;//初始化

    for(int i = head[u]; ~i; i  = edge[i].next)
    {
        int v = edge[i].to;
        if(v!=fa && !vis[v] )
        {//保证不回溯
            get_root(v, u);
            num[u] += num[v];//加上儿子的节点数就是根的节点数
            dp[u] = max(num[v], dp[u]);//最大联通块大小可能是子树大小
        }
    }
    //最大联通块还有可能是当前树删除子树u之后的树大小
    dp[u] = max(dp[u] , size - num[u]);
    //最后跟目前的重心对比
    if(dp[u]<dp[root])  root = u;
}

int dist[maxn];//到根节点的距离
inline bool cmp(int i, int j)
{
    return dist[i] < dist[j];
}

void Find_dist(int u, int fa , int d)
{//计算当前树的所有节点到根的距离，并将点入栈
    Stack[++top1] = u;
    dist[u] = d;
    for(int i = head[u]; ~i ; i = edge[i].next)
    {
        int v = edge[i].to;
        if(vis[v] || v==fa) continue ;
        Find_dist(v, u, d+edge[i].dist);
    }
}

int calc(int l, int r)//计算满足距离≤k的（i，j）个数
{
    int j = r, Ans = 0;//此时stack中l到r是按照dist升序排好的，ij一前一后往中间扫
    for(int i = l; i <= r; i ++)
    {
        while(dist[Stack[i]]+dist[Stack[j]]>k && j>i) j--;
        if(i==j)    break ;
        Ans += j-i;
        //Stack[i+1]~Stack[j]都是满足条件的
    }
    return Ans;
}

void solve(int u, int fa)
{
    dp[0] = maxn;
    size = num[u];
    root = 0;

    get_root(u, fa);//找到重心并将之转换为当前树的根

    top1 = 0;
    int top2 = 0;
    for(int i = head[root]; ~i; i = edge[i].next)
    {
        int v = edge[i].to;
        if(vis[v])  continue;
        top2 = top1;
        Find_dist(v, root, edge[i].dist);
        //top2+1 到top1+1为子树v的所有节点
        sort(Stack+top2+1, Stack+top1+1, cmp);
        ans -= calc(top2+1, top1);//减去在同一棵子树且经过根节点（即非最短距离）的答案数
    }

    Stack[++top1] = root;
    dist[root ] = 0;
    sort(Stack+1, Stack+top1+1, cmp);
    ans += calc(1, top1);

    vis[root] = 1;

    for(int i = head[root]; ~i; i = edge[i].next)
        if(!vis[edge[i].to])
            solve(edge[i].to, root);//分治解决
}

void init()
{
    memset(head, -1, sizeof head);
    memset(vis, 0, sizeof vis);
    ans = 0;
    cnt = 0;
}

int main()
{
    while(scanf("%d %d", &n, &k), n&&k)
    {
        init();
        for(int i = 1; i < n; i ++)
        {
            int u, v, d;
            scanf("%d %d %d", &u, &v, &d);
            addedge(u, v, d);
            addedge(v, u, d);
        }
        num[1] = n;
        solve(1, 0);
        printf("%d\n", ans);
    }
    return 0;
}