hdu 5039 hash+树形结构按子树对应到线段+线段树

首先明确亦或的一个性质:就是xor(u,v) = xor(u,1) ^ xor(v,1) 因为lca(u,v)上面的都算了两遍,相当于没操作

预处理出xor(u,1)

然后一遍dfs将子树对应到线段,用线段树维护sum(xor==1的点)和sum(xor==0的点),更新的时候只需交换两个值

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#define MAX 60007

using namespace std;

typedef long long LL;

int t,n,m;

char name[MAX][15];
int w[MAX];
int fdfn[MAX];

struct Edge
{
    int v,id,next,w,x;
}e[MAX];

int g[MAX];
int head[MAX];
int cc;

vector<int> v[MAX];

int hash ( char s[] )
{
    int len = strlen ( s );
    int ret = 0;
    for ( int i = 0 ; i < len ; i++ )
        ret = (ret + s[i]*s[i])%MAX;
    return ret;
}

int get ( char s[] )
{
    int id = hash ( s );
    int len = v[id].size();
    for ( int i = 0 ; i < len ; i++ )
        if ( !strcmp ( name[v[id][i]] , s ) )
            return v[id][i];
}

void add ( int u , int v ,int w , int x )
{
    e[cc].v = v;
    e[cc].w = w;
    e[cc].x = x;
    e[cc].next = head[u];
    head[u] = cc++;
}

int dfn[MAX],back[MAX],depth;

void dfs ( int u , int p )
{
    dfn[u] = ++depth;
    fdfn[depth] = u;
    for ( int i = head[u] ; ~i ; i = e[i].next )
    {
        int v = e[i].v;
        if ( v == p ) continue;
        g[e[i].x] = v;
        w[v] = e[i].w^w[u];
        dfs ( v , u );
    }
    back[u] = depth;
}

struct Tree
{
    int l,r,sum[2],lazy;
}tree[MAX<<2];

void push_up ( int u )
{
    for ( int i = 0 ; i < 2 ;i ++ )
        tree[u].sum[i] = tree[u<<1].sum[i] + tree[u<<1|1].sum[i];
}

void push_down ( int u )
{
    int lazy = tree[u].lazy;
    if ( lazy%2 )
    {
        tree[u].lazy = 0;
        tree[u<<1].lazy += lazy;
        tree[u<<1|1].lazy += lazy;
        swap ( tree[u<<1].sum[0] , tree[u<<1].sum[1] );
        swap ( tree[u<<1|1].sum[0] , tree[u<<1|1].sum[1] );
    }
}

void build ( int u  , int l , int r )
{
    tree[u].l = l , tree[u].r = r;
    tree[u].lazy = 0;
    if ( l == r )
    {
        tree[u].sum[0] = tree[u].sum[1] = 0;
        tree[u].sum[w[fdfn[l]]] = 1;
        return;
    }
    int mid = l + r >> 1;
    build ( u<<1 , l , mid );
    build ( u<<1|1 , mid+1 , r );
    push_up ( u );
}

void update ( int u , int left , int right )
{
    int l = tree[u].l , r = tree[u].r;
    if ( left <= l && r <= right )
    {
        tree[u].lazy++;
        swap ( tree[u].sum[0] , tree[u].sum[1] );
        return;
    }
    push_down ( u );
    int mid = l + r >> 1;
    if ( left <= mid && right >= l ) update ( u<<1 , left , right );
    if ( left <= r && right > mid ) update ( u<<1|1 , left , right );
    push_up ( u );
}

LL query ( )
{
 //  cout << " Query : " << tree[1].sum[0] << 
//           "  " << tree[1].sum[1] << endl;
   return (LL)(tree[1].sum[0])*(LL)(tree[1].sum[1])*2;
}

int main ( )
{
    int c = 1;
    scanf ( "%d" , &t );
    char s[15];
    while ( t-- )
    {
        scanf ( "%d" , &n );
        for ( int i = 1 ; i <= n ; i++ )
        {
            scanf ( "%s" , name[i] );
            v[hash(name[i])].push_back ( i );
        }
        memset ( head , -1 , sizeof ( head ) );
        cc = 0;
        for ( int i = 1 ; i < n ; i++ )
        {
            scanf ( "%s" , s );
            int u = get ( s );
            scanf ( "%s" , s );
            int v = get ( s );
            int w;
            scanf ( "%d" , &w );
            add ( u , v , w , i );
            add ( v , u , w , i );
        }
        w[1] = 0;
        depth = 0;
        dfs ( 1 , -1 );
        /*cout << "_______________________________" << endl;
        for ( int i = 1 ; i <= n ; i++ )
            cout << dfn[i] << " " << back[i] << endl;*/
       // cout << "_______________________________" << endl;
       // for ( int i = 1 ; i <= n ; i++ )
      //      cout << w[i] <<endl;
        build ( 1 , 1 , n );
        scanf ( "%d" , &m );
        printf ( "Case #%d:\n" , c++ );
        int value;
        while ( m-- )
        {
            scanf ( "%s" , s );
            if ( s[0] == 'Q' ) printf ( "%lld\n", query ( ) );
            else 
            {
                scanf ( "%d" , &value );
                value = g[value];
               // cout << "value" << endl;
               // cout << dfn[value] << " " << back[value] << endl;
                update ( 1 , dfn[value] , back[value] );
            }
        }
    }
}