【点分治】【路径小于等于k的条数】【路径恰好等于k是否存在】

POJ1741:Tree

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 29574		Accepted: 9915

Description

Give a tree with n vertices,each edge has a length(positive integer less than 1001). 
Define dist(u,v)=The min distance between node u and v. 
Give an integer k,for every pair (u,v) of vertices is called valid if and only if dist(u,v) not exceed k. 
Write a program that will count how many pairs which are valid for a given tree. 

Input

The input contains several test cases. The first line of each test case contains two integers n, k. (n<=10000) The following n-1 lines each contains three integers u,v,l, which means there is an edge between node u and v of length l. 
The last test case is followed by two zeros. 

Output

For each test case output the answer on a single line.

Sample Input

5 4
1 2 3
1 3 1
1 4 2
3 5 1
0 0

Sample Output

8

Source

LouTiancheng@POJ

求树上路径距离小于等于k的条数。

点分治即是将树拆开，dfs处理每棵子树的过程。每次找到当前子树的重心，从重心开始分治（即是放弃父亲，不再管之前的祖先。

这道题可以用容斥计算贡献。先统计出当前整棵树的答案，减去每棵子树重复计算的不成立的答案。【注意】这里的答案都是指经过当前树的根节点的路径。

如图，如果k是4,，直接统计子树1的答案，会把1到3和1到4这条路径统计进去，而这是不成立的，所以在统计子树2多余答案时，先把1到2这条边权加进2的dis，再统计子树2中满足条件的点对，减去即可。

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

int bal, asize, sum, n, k, ans;

int tov[], nex[], h[], stot, w[];

void add ( int u, int v, int s ) {
    tov[++stot] = v;
    w[stot] = s;
    nex[stot] = h[u];
    h[u] = stot;
}

int siz[], vis[];

void find_root ( int u, int f ) {
    siz[u] = ;
    int res = ;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( v == f || vis[v] ) continue;
        find_root ( v, u );
        siz[u] += siz[v];
        res = max ( res, siz[v] );
    }
    res = max ( res, sum - siz[u] );
    if ( res < asize ) {
        asize = res, bal = u;
    }
}

int dep[], dis[];

void get_dep ( int u, int f ) {
    dep[++dep[]] = dis[u];
    siz[u] = ;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( v == f || vis[v] ) continue;
        dis[v] = dis[u] + w[i];
        get_dep ( v, u );
        siz[u] += siz[v];
    }
}

int cal ( int u, int now ) {
    dis[u] = now; dep[] = ;
    get_dep ( u,  );
    sort ( dep + , dep + dep[] +  );
    int tmp = , l = , r = dep[];
    while ( l < r ) {
        if ( dep[l] + dep[r] <= k ) {
            tmp += r - l; l ++;
        } else r --;
    }
    return tmp;
}

void work ( int u ) {
    ans += cal ( u,  );
    vis[u] = ;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( vis[v] ) continue;
        ans -= cal ( v, w[i] );
        sum = siz[v];
        asize = 0x3f3f3f3f;
        find_root ( v, u );
        work ( bal );
    }
}

int main ( ) {
    while ( scanf ( "%d%d", &n, &k ) ==  ) {
        if ( n ==  && k ==  ) break;
        asize = 0x3f3f3f3f;
        stot = ; ans = ;
        memset ( h, , sizeof ( h ) );
        memset ( dis, , sizeof ( dis ) );
        memset ( vis, , sizeof ( vis ) );
        for ( int i = ; i < n; i ++ ) {
            int a, b, c;
            scanf ( "%d%d%d", &a, &b, &c );
            add ( a, b, c );
            add ( b, a, c );
        }
        sum = n;
        find_root ( ,  );
        work ( bal );
        printf ( "%d\n", ans );
    }
    return ;
}

洛谷P3806： 【模板】点分治1

题目背景

感谢hzwer的点分治互测。

题目描述

给定一棵有n个点的树

询问树上距离为k的点对是否存在。

输入输出格式

输入格式：

n,m 接下来n-1条边a,b,c描述a到b有一条长度为c的路径

接下来m行每行询问一个K

输出格式：

对于每个K每行输出一个答案，存在输出“AYE”,否则输出”NAY”(不包含引号)

输入输出样例

输入样例#1： 复制

2 1
1 2 2
2

输出样例#1： 复制

AYE

说明

对于30%的数据n<=100

对于60%的数据n<=1000,m<=50

对于100%的数据n<=10000,m<=100,c<=1000,K<=10000000

这道题和上一道实质一样，不过我换了种写法。在统计当前树答案时，进入每棵子树，先把这棵子树的答案与之前计算过的子树答案（exist）进行比对，如果可以就更新答案，再更新exist数组，这样可以保证不会出现上面图示情况，因为计算当前子树时，不会出现子树内部互相更新的情况。

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

int n, m, qus[];

int stot, tov[], nex[], h[], w[];
void add ( int u, int v, int s ) {
    tov[++stot] = v;
    w[stot] = s;
    nex[stot] = h[u];
    h[u] = stot;
}

int siz[], asize, size, root, vis[], maxp[];
void findroot ( int u, int f ) {
    siz[u] = ;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( v == f || vis[v] ) continue;
        findroot ( v, u );
        siz[u] += siz[v];
        maxp[u] = max ( maxp[u], siz[v] );
    }
    maxp[u] = max ( maxp[u], size - siz[u] );
    if ( maxp[u] < maxp[root] ) root = u;
}

int dep[], dis[];
void getdis ( int u, int f ) {
    dep[++dep[]] = dis[u];
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( v == f || vis[v] ) continue;
        dis[v] = dis[u] + w[i];
        getdis ( v, u );
    }
}

bool judge[], exist[];
int q[], p;
void count ( int u ) {
    int p = ;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( vis[v] ) continue;

        dep[] = ; dis[v] = w[i];
        getdis ( v, u );

        for ( int j = dep[]; j; j -- )
            for ( int k = ; k <= m; k ++ )
                if ( qus[k] >= dep[j] )
                judge[k] |= exist[qus[k]-dep[j]];

        for ( int j = dep[]; j; j -- )
            q[++p] = dep[j], exist[dep[j]] = ;
    }
    for ( int i = ; i <= p; i ++ )
        exist[q[i]] = ;
}

void work ( int u ) {
    vis[u] = ; exist[] = ;
    count ( u );
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( vis[v] ) continue;
        size = siz[v]; root = ;
        findroot ( v,  );
        work ( root );
    }
}

int main ( ) {
    freopen ( "a.in", "r", stdin );
    freopen ( "a.out", "w", stdout );
    scanf ( "%d%d", &n, &m );
    for ( int i = ; i < n; i ++ ) {
        int a, b, c;
        scanf ( "%d%d%d", &a, &b, &c );
        add ( a, b, c );
        add ( b, a, c );
    }

    for ( int i = ; i <= m; i ++ )
        scanf ( "%d", &qus[i] );

    size = n; maxp[root] = n;
    findroot ( ,  );
    work ( root );

    for ( int i = ; i <= m; i ++ )
        if ( judge[i] )
            printf ( "AYE\n" );
        else    printf ( "NAY\n" );
    return ;
}