POJ1741 树

链接

树

题解

点分治，思路很直接，递归求解过每棵子树的根节点的路径，长度不超过$k$的有多少条。为了强制使得路径经过根节点，就需要路径的端点不在根节点的同一棵子树上，因此需要记录信息子树中的每个节点对应的根节点的直接儿子节点是哪一个，根节点对应的是它本身，这样可以使得统计的时候不漏掉以根节点做端点的路径。统计路径条数有一些尺取法的思想，将子树内的节点都放到同一个数组里，按照到根节点的距离排序，那么满足$d[x]+d[y]\le k$的$x,y$始终是一段连续的区间，不断右移左端点，确定对应的右端点，统计路径条数。

代码

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const int maxn = 10000 + 100;
const int maxm = 20000 + 100;
const int maxt = 35 + 2;

typedef long long LL;
typedef pair<long long, long long> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const LL Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const double inf = 1e15;
const double pi = acos(-1.0);
const LL mod = 1000000007;

struct Edge
{
    int from, to, next, w;
} edge[maxm];

int n, lim, Ans;
int tot, head[maxn];
int root, mmax, Size[maxn];
int atot, a[maxn], cnt[maxn], dist[maxn], belong[maxn];
bool vis[maxn], del[maxn];

void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
}

void AddEdge(int u, int v, int w)
{
    edge[tot] = (Edge){u, v, head[u], w};
    head[u] = tot++;
}

void find_root(int u, int S)
{
    vis[u] = 1, Size[u] = 1;
    int Max = 0;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (vis[v] || del[v])
            continue;
        find_root(v, S);
        Max = max(Max, Size[v]);
        Size[u] += Size[v];
    }
    Max = max(Max, S - Size[u]);
    if (Max < mmax)
        mmax = Max, root = u;
}

void dfs(int u)
{
    vis[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(vis[v] || del[v])
            continue;
        a[++atot] = v;
        belong[v] = belong[u];
        cnt[belong[v]]++;
        dist[v] = dist[u] + edge[i].w;
        dfs(v);
    }
}

bool cmp(int i, int j)
{
    return dist[i] < dist[j];
}

void work(int u, int S)
{
    mmax = INF, atot = 0;
    memset(vis, false, sizeof(vis));
    find_root(u, S);
    memset(cnt, 0, sizeof(cnt));
    memset(dist, 0, sizeof(dist));
    memset(vis, false, sizeof(vis));
    // cout << root << endl;
    del[a[++atot] = belong[root] = root] = true;
    cnt[root]++;
    for(int i = head[root]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(vis[v] || del[v])
            continue;
        cnt[a[++atot] = belong[v] = v]++;
        dist[v] = edge[i].w;
        dfs(v);
    }
    sort(a + 1, a + atot + 1, cmp);
    int l = 1, r = atot;
    cnt[belong[a[1]]]--;
    while(l < r)
    {
        while(dist[a[l]] + dist[a[r]] > lim)
            cnt[belong[a[r]]]--, r--;
        Ans += r - l - cnt[belong[a[l]]];
        cnt[belong[a[++l]]]--;
    }
    int now = root;
    for(int i = head[now]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(del[v])
            continue;
        work(v, Size[v]);
    }
}

void solve()
{
    memset(del, false, sizeof(del));
    Ans = 0;
    work(1, n);
    cout << Ans << endl;
}

int main()
{
    ios::sync_with_stdio(false);
    while (cin >> n >> lim && (n || lim))
    {
        init();
        int u, v, w;
        for (int i = 0; i < n - 1; i++)
        {
            cin >> u >> v >> w;
            u++, v++;
            AddEdge(u, v, w);
            AddEdge(v, u, w);
        }
        solve();
    }
    return 0;
}