Poj 1741 Tree (树的分治)

题目链接：

　　Poj 1741 Tree

题目描述：

　　有一颗树，每个边都有权值，w问有多少点对(u,v)，满足从u直接或者间接到v的代价不超过k？

解题思路：

　　树上点的分治模板题。

　　分治要注意递归的深度，每次向下分治是要找到树的重心才能保证复杂度为O(logn)，否则复杂度能上升到O(n)。

　　所以用分治搞的童雪们，如果TLE了的话，就回去看看自己每次分治求得重心对不对咯。

　　每次分治对于路径就分为两种：

　　　　　　　　　　　　　　　　　　1：路径经过根节点。

　　　　　　　　　　　　　　　　　　2：路径经过根节点，但是在根节点的一个子树里。

　　分治时候只需要求出第一种路径减去第二种路径累加起来就好。

　　这个题目Tle的好苦啊，原来一直是树的重心没找对，Tle好长时间，终于对了，好感动.>_<.。(PS:Poj1987,树的分治做一送一大派送)

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int maxn = 10010;
struct node
{
    int to, w, next;
}edge[maxn*2];
int head[maxn], vis[maxn], size[maxn], mu[maxn];
int tot, n, k, ans, root, mini, d, dis[maxn];

void init ()
{
    tot = ans = 0;
    size[1] = n;//i为根节点的子树节点数目
    memset (head, -1, sizeof(head));
    memset (vis, 0, sizeof(vis));
}
void Add (int from, int to, int val)
{
    edge[tot].to = to;
    edge[tot].w = val;
    edge[tot].next = head[from];
    head[from] = tot ++;
}
void dfsroot (int u, int father)
{//寻找u所在子树的重心
    size[u] = 1;
    mu[u] = 0;
    for (int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if (!vis[v] && v!=father)
        {
            dfsroot (v, u);
            size[u] += size[v];
            mu[u] = max(mu[u], size[v]);
        }
    }
    mu[u] = max (mu[u], n-size[u]);
    if (mini > mu[u])
        {
            mini = mu[u];
            root = u;
        }
}
void dfsdist (int u, int father, int w)
{//统计路径长度
    dis[d ++] = w;
    for (int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if (!vis[v] && v!=father)
            dfsdist (v, u, w+edge[i].w);
    }
}
int calc (int u, int w)
{//计算以u为根节点的子树中合法路径数目
    int res = 0;
    d = 0;
    dfsdist (u, 0, w);
    sort (dis, dis+d);
    int i=0, j=d-1;
    while (i < j)
    {//相对搜索，复杂度O(n)
        while (dis[i] + dis[j] > k && i<j)
            j --;
        res += j - i;
        i ++;
    }
    return res;
}
void dfs (int u)
{//分治
    mini = n = size[u];//每次n一定要更新为当前子树的节点总数
    dfsroot (u, 0);
    ans += calc (root, 0);
    vis[root] = 1;
    for (int i=head[root]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if (!vis[v])
        {
            ans -= calc (v, edge[i].w);
            dfs (v);
        }
    }
}
int main ()
{
    while (scanf ("%d %d", &n, &k), n+k)
    {
        init ();
        for (int i=1; i<n; i++)
        {
            int u, v, w;
            scanf ("%d %d %d", &u, &v, &w);
            Add (u, v, w);
            Add (v, u, w);
        }
        dfs (1);
        printf ("%d
", ans);
    }
    return 0;
}

每次写递归都感觉很舒服，竟然有些喜欢树上的算法了