poj 1741 Tree | 树分治

本来就没打算弄树分治，不过进爷挂专题挂了这题上去，正好看到，感觉还是可以写的。

完全是参考别人的代码才写出来的，一直在想，会不会超时呢，结果还是不会的。

参考自：

1. http://blog.sina.com.cn/s/blog_6e63f59e0101brf9.html

2. 国家集训队漆子超的论文。

题意：

给你一棵树，边上带权。询问两两节点的距离<=k有多少对。

思路：

因基本参考别人的代码，所以就对别人代码的思路阐述一下，所以，推荐先看论文。

之前看论文的时候看到：不过根的直接递归解决；

我以为是在递归的时候另外计算。现在看来，递归的时候已经把不过根的都转化为了过根的（与根相连的也可认为是过根）来解决。

基本步骤：

1.首先从这棵树中找到一个重心，树形dp可以解决。（不懂重心赶紧去翻论文= =）

2.找到重心后，分别进入从该重心出发的子树。把各子树内d[i] + d[j] <= k 的对数求出来（此时的d[i]+d[j] <= k仅限于同一子树下），暂时记为sum吧。

3.再对该重心下所有的d[i]+d[j] <= k 再求一次总的对数（此时的i，j可以来自不同的子树），记为res。d[重心] = 0

  *d[i] + d[重心] <= k 也是符合条件的，应该加到res中。

4.res -= sum；（不知道为什么这样还是去翻论文= =）

5.把当前的重心删掉，递归进入子树，寻找新的重心，又回到第1步。

AC代码：（很乱= =）

#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <iostream>
using namespace std;
const int MAXN = 1e4+5;
int n, k;
int pp;
int head[MAXN];
struct Edge
{
        int v, len, next;
}edge[MAXN*2];
void addEdge(int u, int v, int len)
{
        edge[pp] = (Edge){v, len, head[u]};
        head[u] = pp++;
        edge[pp] = (Edge){u, len, head[v]};
        head[v] = pp++;
}
bool vis[MAXN];
int sum[MAXN], dis[MAXN];       //sum:
int size, root, rootNum;
void getRoot(int u)   //dfs 
{
        int next = head[u], tmp = 0;
        sum[u] = 1, vis[u] = true;                     //include it self;
        while(next != -1)
        {
                Edge &e = edge[next];
                if(!vis[e.v])
                {
                        getRoot(e.v);
                        sum[u] += sum[e.v];
                        tmp = max(tmp, sum[e.v]);
                }
                next = e.next;
        }
        tmp = max(tmp, size-sum[u]);            //Attention: size, no n;
        if(tmp < rootNum)
        {
                rootNum = tmp;
                root = u;
        }
        vis[u] = false;
}
int getAns(int l, int r)
{
        int res = 0;
        for(int i = l, j = r; i < j; i++)
        {
                while(dis[i] + dis[j] > k && j > i) j--;
                res += j-i;
        }
        return res;
}
void getDis(int u, int d, int &index)                       //dis
{
        int next = head[u];
        dis[index++] = d, vis[u] = true;
        while(next != -1)
        {
                Edge &e = edge[next];
                if(!vis[e.v])
                        getDis(e.v, d+e.len, index);
                next = e.next;
        }
        vis[u] = false;
}
int solve(int u)
{
        root = u, rootNum = size;
        getRoot(u);          //dp: find the root in current tree;
        vis[root] = true;
        int next = head[root];
        int index = 0, l = 0, res = 0;
        while(next != -1)               //enter the son tree;
        {
                Edge &e = edge[next];
                if(!vis[e.v])
                {
                        getDis(e.v, e.len, index);
                        sort(dis+l, dis+index);
                        res -= getAns(l, index-1);
                        l = index;
                }
                next = e.next;
        }
        dis[index++] = 0;
        sort(dis, dis+index), l = 0;
        res += getAns(l, index-1);
        //I try to use for loop to travel the son node :)
        for(int i = head[root]; i != -1; i = edge[i].next)
        {
                int &v = edge[i].v;
                if(!vis[v])
                {
                        size = sum[v];
                        res += solve(v);
                }
        }
        return res;
}
int main()
{
        int u, v, len;
        while(scanf("%d%d", &n, &k), n+k)
        {
                //init
                pp = 0;
                memset(vis, false, sizeof(vis));
                memset(head, -1, sizeof(head));
                //
                for(int i = 0;i < n-1; i++)
                {
                        scanf("%d%d%d", &u, &v, &len);
                        addEdge(u, v, len);
                }
                //
                size = n;
                int res = solve(1);
                printf("%d\n", res);
        }
        return 0;
}