spoj 375 AND bzoj 1036 树链剖分

树链剖分的入门题目，自己写了下感觉还是挺好写的，不过真的有点长...

spoj 375 边有权值：

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

const int INF = -999999999;
const int N = 10001;
int head[N];
int sz[N];
int depth[N];
int num[N];
int top[N];
int dfn[N];
int hc[N];
int fa[N];
int n, e, dfs_clock;

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

struct Edge 
{
    int v, w, next;
} edge[N << 1];

void addEdge( int u, int v, int w )
{
    edge[e].v = v;
    edge[e].w = w;
    edge[e].next = head[u];
    head[u] = e++;
}

void dfs1( int u, int pre, int dep )
{
    sz[u] = 1;
    fa[u] = pre;
    depth[u] = dep;
    hc[u] = -1;
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        if ( v == pre ) continue;
        dfs1( v, u, dep + 1 );
        sz[u] += sz[v];
        if ( hc[u] == -1 || sz[v] > sz[hc[u]] )
        {
            hc[u] = v;
        }
    }
}

void dfs2( int u, int tp )
{
    top[u] = tp;
    dfn[u] = ++dfs_clock;
    if ( hc[u] != -1 )
    {
        dfs2( hc[u], tp );
    }
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        if ( v == fa[u] ) continue;
        if ( v == hc[u] )
        {
            num[dfn[v]] = edge[i].w;
        }
        else
        {
            dfs2( v, v );
            num[dfn[v]] = edge[i].w;
        }
    }
}

struct Node 
{
    int l, r, maxn;
} node[N << 2];

void pushup( int i )
{
    node[i].maxn = max( node[i << 1].maxn, node[i << 1 | 1].maxn );
}

void build( int i, int l, int r )
{
    node[i].l = l, node[i].r = r;
    if ( l == r )
    {
        node[i].maxn = num[l];
        return ;
    }
    int mid = ( l + r ) >> 1;
    build( i << 1, l, mid );
    build( i << 1 | 1, mid + 1, r );
    pushup(i);
}

void update( int i, int pos, int val )
{
    if ( node[i].l == pos && node[i].r == pos )
    {
        node[i].maxn = val;
        return ;
    }
    int mid = ( node[i].l + node[i].r ) >> 1;
    if ( pos <= mid )
    {
        update( i << 1, pos, val );
    }
    else
    {
        update( i << 1 | 1, pos, val );
    }
    pushup(i);
}

int query( int i, int l, int r )
{
    if ( node[i].l == l && node[i].r == r ) 
    {
        return node[i].maxn;
    }
    int mid = ( node[i].l + node[i].r ) >> 1;
    if ( r <= mid )
    {
        return query( i << 1, l, r );
    }
    else if ( l > mid )
    {
        return query( i << 1 | 1, l, r );
    }
    else
    {
        return max( query( i << 1, l, mid ), query( i << 1 | 1, mid + 1, r ) );
    }
}

struct Data
{
    int u, v;
} d[N];

int tree_query( int x, int y )
{
    int ans = INF;
    while ( top[x] != top[y] )
    {
        if ( depth[top[x]] < depth[top[y]] )
        {
            swap( x, y );
        }
        ans = max( ans, query( 1, dfn[top[x]], dfn[x] ) );
        x = fa[top[x]];
    }
    if ( x != y )
    {
        if ( depth[x] > depth[y] ) swap( x, y );
        ans = max( ans, query( 1, dfn[x] + 1, dfn[y] ) );
    }
    return ans;
}

void tree_update( int x, int y )
{
    int u = d[x].u, v = d[x].v;
    if ( depth[u] < depth[v] ) u = v;
    update( 1, dfn[u], y );
}

int main ()
{
    int t;
    scanf("%d", &t);
    while ( t-- )
    {
        scanf("%d", &n);
        init();
        for ( int i = 1; i < n; i++ )
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            addEdge( u, v, w );
            addEdge( v, u, w );
            d[i].u = u, d[i].v = v;
        }
        dfs1( 1, -1, 1 );
        dfs2( 1, 1 );
        build( 1, 2, n );
        char op[11];
        int x, y;
        while ( 1 )
        {
            scanf("%s", op);
            if ( op[0] == 'D' ) break;
            scanf("%d%d", &x, &y);
            if ( op[0] == 'Q' )
            {
                printf("%d
", tree_query( x, y ));
            }
            else
            {
                tree_update( x, y );
            }
        }
    }
    return 0;
}

bzoj 1036 点有权值：

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

const int INF = -9999999;
const int N = 30001;
int c[N];
int head[N];
int sz[N];
int depth[N];
int num[N];
int top[N];
int dfn[N];
int hc[N];
int fa[N];
int n, e, dfs_clock;

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

struct Edge 
{
    int v, next;
} edge[N << 1];

void addEdge( int u, int v )
{
    edge[e].v = v;
    edge[e].next = head[u];
    head[u] = e++;
}

void dfs1( int u, int pre, int dep )
{
    sz[u] = 1;
    fa[u] = pre;
    depth[u] = dep;
    hc[u] = -1;
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        if ( v == pre ) continue;
        dfs1( v, u, dep + 1 );
        sz[u] += sz[v];
        if ( hc[u] == -1 || sz[v] > sz[hc[u]] )
        {
            hc[u] = v;
        }
    }
}

void dfs2( int u, int tp )
{
    top[u] = tp;
    dfn[u] = ++dfs_clock;
    num[dfn[u]] = c[u];
    if ( hc[u] != -1 )
    {
        dfs2( hc[u], tp );
    }
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        if ( v == fa[u] || v == hc[u] ) continue;
        dfs2( v, v );
    }
}

struct Node 
{
    int l, r;
    int maxn, sum;    
} node[N << 2];

void pushup( int i )
{
    node[i].maxn = max( node[i << 1].maxn, node[i << 1 | 1].maxn );
    node[i].sum = node[i << 1].sum + node[i << 1 | 1].sum;
}

void build( int i, int l, int r )
{
    node[i].l = l, node[i].r = r;
    if ( l == r )
    {
        node[i].maxn = node[i].sum = num[l];  
        return ;
    }
    int mid = ( l + r ) >> 1;
    build( i << 1, l, mid );
    build( i << 1 | 1, mid + 1, r );
    pushup(i);
}

void update( int i, int pos, int val )
{
    if ( node[i].l == pos && node[i].r == pos )
    {
        node[i].maxn = node[i].sum = val;
        return ;
    }
    int mid = ( node[i].l + node[i].r ) >> 1;
    if ( pos <= mid )
    {
        update( i << 1, pos, val );
    }
    else
    {
        update( i << 1 | 1, pos, val );
    }
    pushup(i);
}

int query_max( int i, int l, int r )
{
    if ( node[i].l == l && node[i].r == r ) 
    {
        return node[i].maxn;
    }
    int mid = ( node[i].l + node[i].r ) >> 1;
    if ( r <= mid )
    {
        return query_max( i << 1, l, r );
    }
    else if ( l > mid )
    {
        return query_max( i << 1 | 1, l, r );
    }
    else
    {
        return max( query_max( i << 1, l, mid ), query_max( i << 1 | 1, mid + 1, r ) );
    }
}

int query_sum( int i, int l, int r )
{
    if ( node[i].l == l && node[i].r == r ) 
    {
        return node[i].sum;
    }
    int mid = ( node[i].l + node[i].r ) >> 1;
    if ( r <= mid )
    {
        return query_sum( i << 1, l, r );
    }
    else if ( l > mid )
    {
        return query_sum( i << 1 | 1, l, r );
    }
    else
    {
        return query_sum( i << 1, l, mid ) + query_sum( i << 1 | 1, mid + 1, r );
    }
}

int tree_query_max( int x, int y )
{
    int ans = INF;
    while ( top[x] != top[y] )
    {
        if ( depth[top[x]] < depth[top[y]] )
        {
            swap( x, y );
        }
        ans = max( ans, query_max( 1, dfn[top[x]], dfn[x] ) );
        x = fa[top[x]];
    }
    if ( depth[x] > depth[y] ) swap( x, y );
    ans = max( ans, query_max( 1, dfn[x], dfn[y] ) );
    return ans;
}

int tree_query_sum( int x, int y )
{
    int ans = 0;
    while ( top[x] != top[y] )
    {
        if ( depth[top[x]] < depth[top[y]] )
        {
            swap( x, y );
        }
        ans += query_sum( 1, dfn[top[x]], dfn[x] );
        x = fa[top[x]];
    }
    if ( depth[x] > depth[y] ) swap( x, y );
    ans += query_sum( 1, dfn[x], dfn[y] );
    return ans;
}

int main ()
{
    while ( scanf("%d", &n) != EOF )
    {
        init();
        for ( int i = 1; i < n; i++ )
        {
            int u, v;
            scanf("%d%d", &u, &v);
            addEdge( u, v );
            addEdge( v, u );
        }
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", c + i);
        }
        dfs1( 1, -1, 1 );
        dfs2( 1, 1 );
        build( 1, 1, n );
        char op[11];
        int m, x, y;
        scanf("%d", &m);
        while ( m-- )
        {
            scanf("%s%d%d", op, &x, &y);
            if ( op[1] == 'M' )
            {
                printf("%d
", tree_query_max( x, y ));
            }
            else if ( op[1] == 'S' )
            {
                printf("%d
", tree_query_sum( x, y ));
            }
            else
            {
                update( 1, dfn[x], y );
            }
        }
    }
    return 0;
}