hdu 5029 Relief grain 树剖

题意:n个点的树,每次操作选择路径,给这条路径上的点一个值,m次操作后,问每个点被给的最多的那个值是什么,无则输出0

先是树剖预处理,然后注意到,答案是所有操作完的最终结果,即要离线处理出每个点被给的值情况.我们可以把每个操作看成对某几段连续区间的操作,那么每次更新就可以采用“头加尾减”的方式维护,至于维护的数据结构当然是线段树,但是注意的是,维护的是树剖完链上的点,对于查询,我们需要重新映射回原来的点上

还有注意的地方看代码注释.

#pragma comment(linker,"/STACk:10240000,10240000")  
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int N = 100010;

struct node{
    int v, nxt;
}e[N << 1], E[N << 3]	//存颜色要开的大一点;

int cnt, tot;
int h[N];
int H[N];
int pos[N];
int top[N];
int dep[N];
int son[N];
int pre[N];
int sz[N];
int idx[N];
int ans[N];
int n, m;

void init()
{
    sz[0] = dep[1] = 0;
    tot = cnt = 0;
    memset( h, -1, sizeof( h ) );
    memset( H, -1, sizeof( H ) );
}

void adde( int u, int v )
{
    e[cnt].v = v;
    e[cnt].nxt = h[u];
    h[u] = cnt++;
}

void add( int u, int v )
{
    E[cnt].v = v;
    E[cnt].nxt = H[u];
    H[u] = cnt++;
}

void dfs( int u )
{
    sz[u] = 1;
    son[u] = 0;
    for( int i = h[u]; ~i; i = e[i].nxt )
    {
        int v = e[i].v;
        if( v == pre[u] )
            continue;
        dep[v] = dep[u] + 1;
        pre[v] = u;
        dfs( v );
        sz[u] += sz[v];
        if( sz[v] > sz[ son[u] ] )
            son[u] = v;
    }
}

void rebuild( int u, int anc )
{
    pos[u] = ++tot;
    top[u] = anc;
    idx[tot] = u;    //知道线段树上的pos得到原来的pos
    if( son[u] )
        rebuild( son[u], anc );
    for( int i = h[u]; ~i; i = e[i].nxt )
    {
        int v = e[i].v;
        if( v != son[u] && v != pre[u] )
            rebuild( v, v );
    }
}

void mark( int x, int y, int z )
{
    while( top[x] != top[y] )
    {
        int f1 = top[x], f2 = top[y];
        if( dep[f1] > dep[f2] )
        {
            add( pos[f1], z );
            add( pos[x]+1, -z );
            x = pre[f1];
        }
        else
        {
            add( pos[f2], z );
            add( pos[y]+1, -z );
            y = pre[f2];
        }
    }
    if( dep[x] > dep[y] )
        swap( x, y );
    add( pos[x], z );
    add( pos[y]+1, -z );
}

struct seg{
    int l, r, x;
}tr[N << 2];

void build( int l, int r, int rt )
{
    tr[rt].l = l;
    tr[rt].r = r;
    tr[rt].x = 0;
    if( l == r )
        return;
    int mid = ( l + r ) >> 1;
    build( lson );
    build( rson );
}

void pushup( int rt )
{
    tr[rt].x = max( tr[ls].x, tr[rs].x );
}

void update( int rt, int p, int val )	//更新颜色p的次数val
{
    if( tr[rt].l == tr[rt].r )
    {
        tr[rt].x += val;
        return;
    }
    int mid = ( tr[rt].l + tr[rt].r ) >> 1;
    if( p <= mid )
        update( ls, p, val );
    else
        update( rs, p, val );
    pushup( rt );
}

int query( int rt )
{
    if( tr[rt].l == tr[rt].r )
        return tr[rt].l;
    if( tr[rt].x == tr[ls].x )
        return query( ls );
    else
        return query( rs );
}

int main()
{
    while(~scanf("%d%d", &n, &m) && ( n || m ) )
    {
        init();
        int u, v, w;
        for( int i = 1; i < n; ++i )
        {
            scanf("%d%d", &u, &v);
            adde( u, v );
            adde( v, u );
        }
        dfs( 1 );
        rebuild( 1, 1 );
        cnt = 0;
        for( int i = 1; i <= m; ++i )
        {
            scanf("%d%d%d", &u, &v, &w);
            mark( u, v, w );
        }
        build( 0, 100000, 1 );	//注意从0开始build
        for( int u = 1; u <= n; ++u )	//因为颜色更新的时候后面的颜色情况和当前节点无关,
					//而当前节点的情况,只与以当前为起点更新的颜色或者以前的点为起点更新的颜色情况有关,故for(1~n)即可
        {
            for( int i = H[u]; ~i; i = E[i].nxt )
            {
                v = E[i].v;    //col
                update( 1, abs(v), v/abs(v) );
            }
            ans[ idx[u] ] = query(1);
        }
        for( int i = 1; i <= n; ++i )
            printf("%d\n", ans[i]);
    }
    return 0;
}