HDU Hilarity (dfs序+线段树)

Problem Description

After June 1st, elementary students of Ted Land are still celebrating "The Sacred Day of Elementary Students”. They go to the streets and do some elementary students stuff. So we call them "elementary students". There are N cities in Ted Land. But for simplicity, the mayor Matt only built N - 1 roads so that all cities can reach each other. Some of the roads are occupied by the "elementary students". They will put an celebration hat on everyone who goes through the road without one. But if someone goes through the road with a celebration hat on his head, "elementary students" will steal the hat for no reason. Since Matt doesn’t have a celebration hat, he wants to know how many different paths in his land that he can end up with a hat. Two paths are considered to be different if and only if they have different start city or end city. As the counsellor of the mayor Matt, you have to answer this question for him. The celebration elementary students are not stable: sometimes a new crowd of elementary students go to an empty road; sometimes the elementary students on a road will go back home and remain the road empty. Matt will send you the monitor about the change of elementary students on road and ask you the question above. You will be fired if you answer wrong.

 

Input

The first line of the input contains an integer T, denoting the number of testcases. Then T test cases follow.

For each test case, the first line contains N (1<=N<=30000) describing the number of cities.

Then N lines follow. The ith line of these contains the name of the ith city, it’s a string containing only letters and will not be longer than 10.

The following N - 1 lines indicate the N - 1 edges between cities. Each of these lines will contain two strings for the cities’ name and a integer for the initial status of the edge (0 for empty, 1 for crowded).

Then an integer M (1<=M<=60000) describes the number of queries. There are two kinds of query:

● "M i" means the status changing of the ith (starting from 1) road (0 to 1, 1 to 0);
● "Q" means that Matt asks you the number of different paths.

 

Output

For each test case, first output one line “Case #x:”, where x is the case number (starting from 1).

Then for each “Q” in input, output a line with the answer.

 

Sample Input

  
  

   
   1
5
a
b
c
d
e
a b 1
b c 0
c d 1
d e 1
7
Q
M 1
Q
M 3
Q
M 4
Q
  
  

 

Sample Output

  
  

   
   Case #1:
12
8
8
0
  
  

 

Source

2014 ACM/ICPC Asia Regional Beijing Online

 

题意：给定一棵边权为 0/1 的树，要求支持两类操作：1. 询问有多少条路径 xor 和为 1。2. 修改一条边的权值。

思路：把树形转换成线性的，又涨知识啦，参考官方提供的题解：因为只在乎奇偶性，可以看做求有多少条路径的xor值为1。 随便找个根dfs出根到每个节点路径的xor值d[x]，那么很明显路径的xor值就是两个端点的d[]的xor值。 这样这个问题就比较喜闻乐见了，而修改仅仅是翻转在dfs序上的一个区间，线段树就可以做了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#define lson(x) (x<<1)
#define rson(x) ((x<<1)|1)
typedef long long ll;
using namespace std;
const int maxn = 30005;

map<string, int> mp;
struct Edge {
	int u, v, c;
	Edge() {}
	Edge(int u, int v, int c) {
		this->u = u;
		this->v = v;
		this->c = c;
	} 
};
vector<Edge> edges;
vector<int> g[maxn];
int n, m, q, cnt;
int le[maxn], ri[maxn];
string sa, sb;
int cover[maxn<<2], val[maxn<<2], dep[maxn], ans[maxn<<2];

int id(string s) {
	if (mp.count(s) == 0)
		mp[s] = ++cnt;
	return mp[s];
}

void add(int u, int v, int c) {
	edges.push_back(Edge(u, v, c));
	edges.push_back(Edge(v, u, c));
	m = edges.size();
	g[u].push_back(m-2);
	g[v].push_back(m-1);
}

void dfs(int u, int fa, int va) {
	dep[u] = dep[fa] + 1;
	le[u] = ++cnt;
	val[cnt] = va;
	for (int i = 0; i < g[u].size(); i++) {
		Edge e = edges[g[u][i]];
		int v = e.v;
		int c = e.c;
		if (v == fa) continue;
		dfs(v, u, c^va);
	}
	ri[u] = cnt;
}

void pushup(int pos) {
	ans[pos] = ans[lson(pos)] + ans[rson(pos)];
}

void pushdown(int l, int r, int pos) {
	int m = l + r >> 1;
	if (cover[pos]) {
		cover[lson(pos)] ^= 1;
		cover[rson(pos)] ^= 1;
		ans[lson(pos)] = m - l + 1 - ans[lson(pos)];
		ans[rson(pos)] = r - m - ans[rson(pos)];
		cover[pos] = 0;
	}
}

void build(int l, int r, int pos) {
	if (l == r) {
		cover[pos] = 0;
		ans[pos] = val[l];
		return;
	}
	cover[pos] = 0;
	int m = l + r >> 1;
	build(l, m, lson(pos));
	build(m+1, r, rson(pos));
	pushup(pos);
}

void update(int l, int r, int pos, int L, int R) {
	if (L <= l && R >= r) {
		cover[pos] ^= 1;
		ans[pos] = r - l + 1 - ans[pos];
		return;
	}

	int m = l + r >> 1;
	pushdown(l, r, pos);
	if (L <= m)
		update(l, m, lson(pos), L, R);
	if (R > m)
		update(m+1, r, rson(pos), L, R);
	pushup(pos);
}

int main() {
	int t, cas = 1;
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);
		mp.clear();
		memset(dep, 0, sizeof(dep));
		cnt = 0;
		edges.clear();
		for (int i = 1; i <= n; i++) {
			g[i].clear();
			cin >> sa;
			id(sa);
		}

		for (int i = 0; i < n-1; i++) {
			int u, v, c;
			cin >> sa >> sb;
			scanf("%d", &c);
			u = id(sa);
			v = id(sb);
			add(u, v, c);
		}

		scanf("%d", &q);
		printf("Case #%d:\n", cas++);
		cnt = 0;
		dfs(1, 0, 0);

		build(1, n, 1);
		ll res = 0;
		while (q--) {
			cin >> sa;
			if (sa[0] == 'Q') {
				res = (ll) (n - ans[1]) * ans[1] * 2;
				printf("%lld\n", res);
			}
			else {
				int x;
				scanf("%d", &x);
				x--;
				x <<= 1;
				int u = edges[x].u;
				int v = edges[x].v;
				if (dep[u] < dep[v])
					swap(u, v);
				update(1, n, 1, le[u], ri[u]);
			}
		}
	}
	return 0;
}