HDU 5039 Hilarity dfs序、线段树

【题目大意】

有一棵树，树的边权不是0，就是1。m次操作，操作分两种类型。M i：把输入的第i条边，边权取反。Q：输出有多少条简单路径，路径上所有边异或值为1。

【思路】

如果记g（u，v）为简单路径（u，v）上所有边的异或和。这题的关键就是想到g（u，v） == g（root，u）^ g（root，v）。

我们只需要维护所有的g（root，i）即可，ans == （ g（）== 1的个数）*（（ g（）== 0的个数））。

那么，考虑修改一个边，g（root，i）会怎么变化？很容易知道，这个边其下面的所有点的g（）值都将取反。而在dfs序上，“下面的点”是一个连续区间。这个操作可以转化为线段树区间取反的操作。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef long long LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF=100011122;
const double INFF=1e100;
const double eps=1e-8;
const int mod=1000000007;
const int NN=30010;
const int MM=1000010;
/* ****************** */

map<string,int>Mmap;
struct TR
{
    int l, r, sum0, sum1;
    bool fg;
    int mid()
    {
        return (l + r)>>1;
    }
}tr[NN*4];
struct G
{
    int u, v, next, w;
}E[NN*2];
int p[NN], T;
int tsp, anc[NN], ll[NN], rr[NN], a[NN];

void add(int u,int v,int w)
{
    E[T].u = u;
    E[T].v = v;
    E[T].w = w;
    E[T].next = p[u];
    p[u] =  T++;
}

void dfs(int u,int fa,int t)
{
    ll[u] = ++tsp;
    anc[u] = fa;
    a[tsp] = t;
    int i, v;
    for (i = p[u]; i + 1; i = E[i].next)
    {
        v = E[i].v;
        if(v == fa)continue;
        dfs(v, u, t^E[i].w);
    }
    rr[u] = tsp;
}
void push_up(int R)
{
    tr[R].sum0 = tr[R<<1].sum0 + tr[R<<1|1].sum0;
    tr[R].sum1 = tr[R<<1].sum1 + tr[R<<1|1].sum1;
}
void down(int R)
{
    tr[R].fg = !tr[R].fg;
    swap(tr[R].sum0, tr[R].sum1);
}
void push_down(int R)
{
    if(tr[R].fg)
    {
        down(R<<1);
        down(R<<1|1);
        tr[R].fg = false;
    }
}
void build(int l,int r,int R)
{
    tr[R].l = l;
    tr[R].r = r;
    tr[R].fg = false;
    if(l == r)
    {
        tr[R].sum0 = (a[tr[R].l]==0);
        tr[R].sum1 = (a[tr[R].l]==1);
        return;
    }
    int mid = tr[R].mid();
    build(l, mid, R<<1);
    build(mid+1, r, R<<1|1);
    push_up(R);
}
void update(int l,int r,int R)
{
    if(l <= tr[R].l && tr[R].r <= r)
    {
        down(R);
        return;
    }
    push_down(R);
    int mid = tr[R].mid();
    if(l <= mid)
        update(l, r, R<<1);
    if(r >= mid + 1)
        update(l, r, R<<1|1);
    push_up(R);
}

int main()
{
    int cas, ee = 0;
    int i, n, m, u, v, w;
    string temp;
    LL sum1;
    char ss[15];
    scanf("%d", &cas);
    while (cas--)
    {
        memset(p, -1, sizeof(p));
        T = 0;
        Mmap.clear();
        scanf("%d", &n);
        for (i = 1; i <= n; i ++)
        {
            scanf("%s", ss);
            temp.assign(ss);
            Mmap[temp] = i;
        }
        for (i = 1; i < n; i ++)
        {
            scanf("%s", ss);
            temp.assign(ss);
            u = Mmap[temp];
            scanf("%s", ss);
            temp.assign(ss);
            v = Mmap[temp];
            scanf("%d", &w);
            add(u, v, w);
            add(v, u, w);
        }

        tsp = 0;
        dfs(1, -1, 0);
        build(1, n, 1);

        printf("Case #%d:\n", ++ee);
        scanf("%d", &m);
        for (i = 0; i < m; i ++)
        {
            scanf("%s", ss);
            if(ss[0]=='Q')
            {
                sum1 = (LL)tr[1].sum0 * tr[1].sum1;
              //  cout<<"ans==";
                printf("%I64d\n", sum1*2);
            }
            else
            {
                scanf("%d", &v);
                v--;
                if(anc[ E[v*2].v ] == E[v*2].u)
                    u = E[v*2].v;
                else
                    u = E[v*2].u;
                update(ll[u], rr[u], 1);
            }
        }
    }
    return 0;
}