模块一：
线段树单点更新，区间最值。
http://acm.hdu.edu.cn/showproblem.php?pid=1166
线段树功能：update：单点更新，query:区间求和。
http://acm.hdu.edu.cn/showproblem.php?pid=1754
线段树功能：update:单点更新，query:区间最值。
PushUp(int rt) : 把当前节点的信息更新到父亲节点
PushDown(int rt) : 把父亲节点的信息更新到儿子节点。
1 /*************************************************************************
2 > File Name: hdu1754.cpp
3 > Author: syhjh
4 > Created Time: 2014年03月20日 星期四 21时52分56秒
5 ************************************************************************/
6 #include <iostream>
7 #include <cstdio>
8 #include <cstring>
9 #include <algorithm>
10 using namespace std;
11
12 #define lson rt << 1
13 #define rson rt << 1 | 1
14 const int MAXN = (200000 + 200);
15 template < class T > inline T getMax(const T &a, const T &b)
16 {
17 return a > b ? a : b;
18 }
19
20 int sum[MAXN << 2];
21 int N, M;
22
23 void PushUp(int rt)
24 {
25 sum[rt] = getMax(sum[lson], sum[rson]);
26 }
27
28 void Build(int L, int R, int rt)
29 {
30 if (L == R) {
31 scanf("%d", &sum[rt]);
32 return;
33 }
34 int M = (L + R) >> 1;
35 Build(L, M, lson);
36 Build(M + 1, R, rson);
37 PushUp(rt);
38 }
39
40 void Update(int L, int R, int rt, int p, int x)
41 {
42 if (L == R) {
43 sum[rt] = x;
44 return;
45 }
46 int M = (L + R) >> 1;
47 if (p <= M) {
48 Update(L, M, lson, p, x);
49 } else
50 Update(M + 1, R, rson, p, x);
51 PushUp(rt);
52 }
53
54 int Query(int L, int R, int rt, int l, int r)
55 {
56 if (l <= L && R <= r) {
57 return sum[rt];
58 }
59 int M = (L + R) >> 1;
60 int res = 0;
61 if (l <= M) res = getMax(res, Query(L, M, lson, l, r));
62 if (r > M) res = getMax(res, Query(M + 1, R, rson, l, r));
63 return res;
64 }
65
66 int main()
67 {
68 while (cin >> N >> M) {
69 Build(1, N, 1);
70 while (M--) {
71 char str[11];
72 int x, y;
73 scanf("%s", str);
74 if (str[0] == 'U') {
75 scanf("%d %d", &x, &y);
76 Update(1, N, 1, x, y);
77 } else if (str[0] == 'Q') {
78 scanf("%d %d", &x, &y);
79 int ans = Query(1, N, 1, x, y);
80 printf("%d\n", ans);
81 }
82 }
83 }
84 return 0;
85 }
View Code
http://acm.hdu.edu.cn/showproblem.php?pid=1394
可以先求开始序列的逆序数，一开始记录每个叶子节点的值为0，然后对于每个数，插入之后更新一下，对于当前的x[i],需要插叙[x[i], n - 1]之间的数已经出现了多少个。求出一开始的逆序数之后，就可以通过递推关系式以此找出后面的逆序数对。
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <iostream>
3 #include <cstdio>
4 #include <cstring>
5 #include <algorithm>
6 using namespace std;
7
8 #define lson rt << 1
9 #define rson rt << 1 | 1
10 const int MAXN = (5000 + 50);
11 template < class T > inline T getMIN(const T &a, const T &b)
12 {
13 return a < b ? a : b;
14 }
15 int sum[MAXN << 2];
16
17 void PushUp(int rt)
18 {
19 sum[rt] = sum[lson] + sum[rson];
20 }
21
22 void Build(int L, int R, int rt)
23 {
24 sum[rt] = 0;
25 if (L == R) return;
26 int M = (L + R) >> 1;
27 Build(L, M, lson);
28 Build(M + 1, R, rson);
29 }
30
31 void Update(int L, int R, int rt, int p)
32 {
33 if (L == R) {
34 sum[rt]++;
35 return;
36 }
37 int M = (L + R) >> 1;
38 if (p <= M) Update(L, M, lson, p);
39 else Update(M + 1, R, rson, p);
40 PushUp(rt);
41 }
42
43 int Query(int L, int R, int rt, int l, int r)
44 {
45 if (l <= L && R <= r) {
46 return sum[rt];
47 }
48 int M = (L + R) >> 1;
49 int ret = 0;
50 if (l <= M) ret += Query(L, M, lson, l, r);
51 if (r > M) ret += Query(M + 1, R, rson, l, r);
52 return ret;
53 }
54
55 int n, num[MAXN];
56 int main()
57 {
58 while (~scanf("%d", &n)) {
59 for (int i = 0; i < n; i++) {
60 scanf("%d", &num[i]);
61 }
62 Build(0, n - 1, 1);
63 int sum = 0;
64 for (int i = 0; i < n; i++) {
65 sum += Query(0, n - 1, 1, num[i], n - 1);
66 Update(0, n - 1, 1, num[i]);
67 }
68 int ans = sum;
69 for (int i = 0; i < n; i++) {
70 sum += (n - num[i] - 1) - num[i];
71 ans = getMIN(ans, sum);
72 }
73 printf("%d\n", ans);
74 }
75 return 0;
76 }
View Code
http://acm.hdu.edu.cn/showproblem.php?pid=2795
这题的本质是区间最大值，这是线段树的长处。
叶子节点x表示board的x行还能放的长度，于是对于区间[a, b]就是表示第a行到b行所能放的最大的长度，那么我们可以从根节点开始比较，如果当前长度小于跟节点的值，就往左子树走，否则就往右子树走，达到叶子节点的时候，len[rt] -= x表示在这一行放置了长度为x的广告，于是剩下的长度就要减少了，然后在update就可以了。
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <iostream>
3 #include <cstdio>
4 #include <cstring>
5 #include <algorithm>
6 using namespace std;
7
8 #define lson rt << 1
9 #define rson rt << 1 | 1
10 const int MAXN = (200000 + 20);
11 int h, w, n;
12 int len[MAXN << 2];
13
14 template< class T > inline T getMIN(const T &a, const T &b)
15 {
16 return a < b ? a : b;
17 }
18
19 template< class T > inline T getMAX(const T &a, const T &b)
20 {
21 return a > b ? a : b;
22 }
23
24 void PushUp(int rt)
25 {
26 len[rt] = getMAX(len[lson], len[rson]);
27 }
28
29 void Build(int L, int R, int rt)
30 {
31 len[rt] = w;
32 if (L == R) return;
33 int M = (L + R) >> 1;
34 Build(L, M, lson);
35 Build(M + 1, R, rson);
36 }
37
38 int Query(int L, int R, int rt, int x)
39 {
40 if (L == R) {
41 len[rt] -= x;
42 return L;
43 }
44 int M = (L + R) >> 1;
45 int ret = (len[lson] >= x ? Query(L, M, lson, x) : Query(M + 1, R, rson, x));
46 PushUp(rt);
47 return ret;
48 }
49
50 int main()
51 {
52 int x;
53 while (~scanf("%d %d %d", &h, &w, &n)) {
54 h = getMIN(h, n);
55 Build(1, h, 1);
56 for (int i = 1; i <= n; i++) {
57 scanf("%d", &x);
58 if (x > len[1]) {
59 puts("-1");
60 continue;
61 }
62 printf("%d\n", Query(1, h, 1, x));
63 }
64 }
65 return 0;
66 }
View Code
http://poj.org/problem?id=2828
采用倒序插入，pos的意义就是找到一个位置，它的前面刚好有pos个空位，用一个empty数组记录区间[l,r]之间有多少个空位，然后进来一个p，比较左右子树的空位数，如果坐标的空位数 >= p，那么说明p应该放在左子树，否则，p应该放右子树，并且p还要减去左子树的空位数，因为右子树的空位数也是从0开始的。
1 #define _CRT_SECURE_NO_WARNINGS
2 #include <iostream>
3 #include <cstdio>
4 #include <cstring>
5 #include <algorithm>
6 using namespace std;
7
8 #define lson rt << 1
9 #define rson rt << 1 | 1
10 const int MAXN = (200000 + 20);
11 int empty[MAXN << 2];
12 int n, index, pos[MAXN], id[MAXN], ans[MAXN];
13
14 void Build(int L, int R, int rt)
15 {
16 empty[rt] = R - L + 1;
17 if (L == R) return;
18 int M = (L + R) >> 1;
19 Build(L, M, lson);
20 Build(M + 1, R, rson);
21 }
22
23 void Update(int L, int R, int rt, int p)
24 {
25 empty[rt]--;
26 if (L == R) {
27 index = L;
28 return;
29 }
30 int M = (L + R) >> 1;
31 if (empty[lson] >= p) Update(L, M, lson, p);
32 else p -= empty[lson], Update(M + 1, R, rson, p);
33 }
34
35 int main()
36 {
37 while (~scanf("%d", &n)) {
38 for (int i = 1; i <= n; i++) {
39 scanf("%d %d", &pos[i], &id[i]);
40 }
41 Build(1, n, 1);
42 for (int i = n; i >= 1; i--) {
43 Update(1, n, 1, pos[i] + 1);
44 ans[index] = id[i];
45 }
46 for (int i = 1; i <= n; i++) {
47 printf(i == n ? "%d\n" : "%d ", ans[i]);
48 }
49 }
50 return 0;
51 }
View Code
http://poj.org/problem?id=2481
对n头牛先按S从小到大排序，在按E从大到小排序，这样每次计算一个，我们可以找比当前的e大的出现的数目，然后更新即可，线段树的查找和更新的复杂度均为n * log(n).
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 const int MAXN = (100000 + 100);
10 template< typename T > inline T getMAX(const T &a, const T &b)
11 {
12 return a > b ? a : b;
13 }
14
15 struct Node {
16 int s, e, id;
17 } node[MAXN];
18
19 int cmp(const Node &p, const Node &q)
20 {
21 if (p.s != q.s) {
22 return p.s < q.s;
23 }
24 return p.e > q.e;
25 }
26
27 int N;
28 int sum[MAXN << 2];
29
30 void PushUp(int rt)
31 {
32 sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
33 }
34
35 void Build(int L, int R, int rt)
36 {
37 sum[rt] = 0;
38 if (L == R) return;
39 int M = (L + R) >> 1;
40 Build(L, M, lson);
41 Build(M + 1, R, rson);
42 }
43
44 void Update(int L, int R, int rt, int p)
45 {
46 if (L == R) {
47 sum[rt]++;
48 return;
49 }
50 int M = (L + R) >> 1;
51 if (p <= M) Update(L, M, lson, p);
52 else Update(M + 1, R, rson, p);
53 PushUp(rt);
54 }
55
56 int Query(int L, int R, int rt, int l, int r)
57 {
58 if (l <= L && R <= r) {
59 return sum[rt];
60 }
61 int M = (L + R) >> 1;
62 int ret = 0;
63 if (l <= M) ret += Query(L, M, lson, l, r);
64 if (r > M) ret += Query(M + 1, R, rson, l, r);
65 return ret;
66 }
67
68
69 int ans[MAXN];
70 int MAX;
71 int main()
72 {
73 while (~scanf("%d", &N) && N) {
74 MAX = 0;
75 for (int i = 0; i < N; i++) {
76 scanf("%d %d", &node[i].s, &node[i].e);
77 MAX = getMAX(MAX, node[i].e);
78 node[i].id = i;
79 }
80 sort(node, node + N, cmp);
81 Build(1, MAX, 1);
82 ans[node[0].id] = 0;
83 Update(1, MAX, 1, node[0].e);
84 for (int i = 1; i < N; i++) {
85 if (node[i].s == node[i - 1].s && node[i].e == node[i - 1].e) {
86 ans[node[i].id] = ans[node[i - 1].id];
87 } else
88 ans[node[i].id] = Query(1, MAX, 1, node[i].e, MAX);
89 Update(1, MAX, 1, node[i].e);
90 }
91 for (int i = 0; i < N; i++) {
92 if (i == N - 1) printf("%d\n", ans[i]);
93 else printf("%d ", ans[i]);
94 }
95 }
96 return 0;
97 }
View Code
http://poj.org/problem?id=2182
len数组代表当前节点的区间还有的空位置，那么我们可以从后往前依次放位置，这样就能确定最后的序列了！
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 const int MAXN = (8000 + 80);
10 int len[MAXN << 2];
11 int num[MAXN], ans[MAXN], pos, N;
12
13 void Build(int L, int R, int rt)
14 {
15 len[rt] = R - L + 1;
16 if (L == R) return;
17 int M = (L + R) >> 1;
18 Build(L, M, lson);
19 Build(M + 1, R, rson);
20 }
21
22 void Update(int L, int R, int rt, int p)
23 {
24 len[rt]--;
25 if (L == R) {
26 pos = L;
27 return;
28 }
29 int M = (L + R) >> 1;
30 if (p <= len[lson]) Update(L, M, lson, p);
31 else Update(M + 1, R, rson, p - len[lson]);
32 }
33
34 int main()
35 {
36 while (~scanf("%d", &N)) {
37 num[1] = 0;
38 for (int i = 2; i <= N; i++) {
39 scanf("%d", &num[i]);
40 }
41 Build(1, N, 1);
42 for (int i = N; i >= 1; i--) {
43 Update(1, N, 1, num[i] + 1);
44 ans[i] = pos;
45 }
46 for (int i = 1; i <= N; i++) {
47 printf("%d\n", ans[i]);
48 }
49 }
50 return 0;
51 }
View Code
模块二：线段树成段更新。
http://acm.hdu.edu.cn/showproblem.php?pid=1698
col数组要来标记当前区间的值，一开始所有的区间都为0，然后我们更新的时候，如果当前的区间的col不为0，则说明该区间是纯的，此时，我们应该把这个区间的col往左右子树传，同时计算sum的值，由于是纯的，因此当前节点的左子树和当前节点的右子树的sum可以直接求得，然后在把当前的col改为0,表示当前节点覆盖的区间不纯。
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 const int MAXN = (100000 + 100);
10 int N, M;
11 int col[MAXN << 2], sum[MAXN << 2];
12
13 void PushDown(int rt, int len)
14 {
15 if (col[rt]) {
16 col[lson] = col[rson] = col[rt];
17 sum[lson] = (len - (len >> 1)) * col[rt];
18 sum[rson] = (len >> 1) * col[rt];
19 col[rt] = 0; //不纯洁
20 }
21 }
22
23 void PushUp(int rt)
24 {
25 sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
26 }
27
28
29 void Build(int L, int R, int rt)
30 {
31 col[rt] = 0;
32 sum[rt] = 1;
33 if (L == R) return;
34 int M = (L + R) >> 1;
35 Build(L, M, lson);
36 Build(M + 1, R, rson);
37 PushUp(rt);
38 }
39
40 void Update(int L, int R, int rt, int l, int r, int color)
41 {
42 if (l <= L && R <= r) {
43 col[rt] = color;
44 sum[rt] = (R - L + 1) * color;
45 return;
46 }
47 PushDown(rt, R - L + 1);
48 int M = (L + R) >> 1;
49 if (l <= M) Update(L, M, lson, l, r, color);
50 if (r > M) Update(M + 1, R, rson, l, r, color);
51 PushUp(rt);
52 }
53
54 int main()
55 {
56 int Cas, t = 1;
57 scanf("%d", &Cas);
58 while (Cas--) {
59 scanf("%d %d", &N, &M);
60 Build(1, N, 1);
61 for (int i = 0; i < M; i++) {
62 int a, b, c;
63 scanf("%d %d %d", &a, &b, &c);
64 Update(1, N, 1, a, b, c);
65 }
66 printf("Case %d: The total value of the hook is %d.\n", t++, sum[1]);
67 }
68 return 0;
69 }
View Code
http://poj.org/problem?id=3468
线段树成段更新，采用lazy思想，记录增量，更新的时候只更新到段，等到下次更新或者查询的时候，碰到已经被标记过的，往下顺延就行。
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 typedef long long ll;
10 const int MAXN = (100000 +100);
11 int N, Q;
12 ll sum[MAXN << 2], add[MAXN << 2];
13
14 void PushUp(int rt)
15 {
16 sum[rt] = sum[lson] + sum[rson];
17 }
18
19 void PushDown(int rt, int len)
20 {
21 if (add[rt]) {
22 add[lson] += add[rt];
23 add[rson] += add[rt];
24 sum[lson] += (len - (len >> 1)) * add[rt];
25 sum[rson] += (len >> 1) * add[rt];
26 add[rt] = 0;
27 }
28 }
29
30 void Build(int L, int R, int rt)
31 {
32 add[rt] = 0;
33 if (L == R) {
34 scanf("%lld", &sum[rt]);
35 return;
36 }
37 int M = (L + R) >> 1;
38 Build(L, M, lson);
39 Build(M + 1, R, rson);
40 PushUp(rt);
41 }
42
43 void Update(int L, int R, int rt, int l, int r, int lnc)
44 {
45 if (l <= L && R <= r) {
46 add[rt] += lnc;
47 sum[rt] += (R - L + 1) * lnc;
48 return;
49 }
50 PushDown(rt, R - L + 1);
51 int M = (L + R) >> 1;
52 if (l <= M) Update(L, M, lson, l, r, lnc);
53 if (r > M) Update(M + 1, R, rson, l, r, lnc);
54 PushUp(rt);
55 }
56
57 ll Query(int L, int R, int rt, int l, int r)
58 {
59 if (l <= L && R <= r) {
60 return sum[rt];
61 }
62 PushDown(rt, R - L + 1);
63 int M = (L + R) >> 1;
64 ll ret = 0;
65 if (l <= M) ret += Query(L, M, lson, l, r);
66 if (r > M) ret += Query(M + 1, R, rson, l, r);
67 return ret;
68 }
69
70 int main()
71 {
72 scanf("%d %d", &N, &Q);
73 Build(1, N, 1);
74 while (Q--) {
75 char str[2];
76 int a, b, c;
77 scanf("%s", str);
78 if (str[0] == 'Q') {
79 scanf("%d %d", &a, &b);
80 printf("%lld\n", Query(1, N, 1, a, b));
81 } else if (str[0] == 'C') {
82 scanf("%d %d %d", &a, &b, &c);
83 Update(1, N, 1, a, b, c);
84 }
85 }
86 return 0;
87 }
View Code
http://acm.cug.edu.cn/JudgeOnline/problem.php?id=1435
线段树成段更新，区间最值。
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 typedef long long ll;
10 const int MAXN = (100000 + 100);
11 template < typename T > inline T getMIN(const T &a, const T &b)
12 {
13 return a < b ? a : b;
14 }
15
16 int N, M;
17 ll MIN[MAXN << 2], add[MAXN << 2];
18
19 void PushDown(int rt)
20 {
21 if (add[rt]) {
22 add[lson] += add[rt];
23 add[rson] += add[rt];
24 MIN[lson] += add[rt];
25 MIN[rson] += add[rt];
26 add[rt] = 0;
27 }
28 }
29
30 void PushUp(int rt)
31 {
32 MIN[rt] = getMIN(MIN[lson], MIN[rson]);
33 }
34
35 void Build(int L, int R, int rt)
36 {
37 add[rt] = 0;
38 if (L == R) {
39 scanf("%lld", &MIN[rt]);
40 return;
41 }
42 int M = (L + R) >> 1;
43 Build(L, M, lson);
44 Build(M + 1, R, rson);
45 PushUp(rt);
46 }
47
48 void Update(int L, int R, int rt, int l, int r, int lnc)
49 {
50 if (l <= L && R <= r) {
51 add[rt] += lnc;
52 MIN[rt] += lnc;
53 return;
54 }
55 PushDown(rt);
56 int M = (L + R) >> 1;
57 if (l <= M) Update(L, M, lson, l, r, lnc);
58 if (r > M) Update(M + 1, R, rson, l, r, lnc);
59 PushUp(rt);
60 }
61
62 ll Query(int L, int R, int rt, int l, int r)
63 {
64 if (l <= L && R <= r) {
65 return MIN[rt];
66 }
67 PushDown(rt);
68 int M = (L + R) >> 1;
69 ll ans = 1LL << 60;
70 if (l <= M) ans = getMIN(ans, Query(L, M, lson, l, r));
71 if (r > M) ans = getMIN(ans, Query(M + 1, R, rson, l, r));
72 return ans;
73 }
74
75 int Judge(char *str)
76 {
77 int len = strlen(str), cnt = 0;
78 for (int i = 0; i < len; ) {
79 if (str[i] == ' ') {
80 cnt++;
81 while (i < len && str[i] == ' ') i++;
82 } else
83 i++;
84 }
85 return cnt;
86 }
87
88 int main()
89 {
90 while (~scanf("%d %d", &N, &M)) {
91 Build(0, N - 1, 1);
92 getchar();
93 while (M--) {
94 char str[22];
95 int a, b, c;
96 gets(str);
97 if (Judge(str) == 1) {
98 sscanf(str, "%d %d", &a, &b);
99 if (a <= b) {
100 printf("%lld\n", Query(0, N - 1, 1, a, b));
101 } else
102 printf("%lld\n", getMIN(Query(0, N - 1, 1, a, N - 1), Query(0, N - 1, 1, 0, b)));
103 } else if (Judge(str) == 2) {
104 sscanf(str, "%d %d %d", &a, &b, &c);
105 if (a <= b) {
106 Update(0, N - 1, 1, a, b, c);
107 } else {
108 Update(0, N - 1, 1, 0, b, c);
109 Update(0, N - 1, 1, a, N - 1, c);
110 }
111 }
112 }
113 }
114 return 0;
115 }
View Code
http://poj.org/problem?id=2528
线段树 + 离散化。
http://www.notonlysuccess.com/index.php/segment-tree-complete/大牛的博客讲得很清楚！
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 const int MAXN = (100000 + 100);
10 struct Node {
11 int l, r;
12 } node[MAXN];
13
14 bool Hash[MAXN];
15 int X[MAXN << 2];
16 int col[MAXN << 4];
17 int cnt, n, m;
18
19 void PushDown(int rt)
20 {
21 if (col[rt] != -1) {
22 col[lson] = col[rson] = col[rt];
23 col[rt] = -1;
24 }
25 }
26
27 void Update(int L, int R, int rt, int l, int r, int color)
28 {
29 if (l <= L && R <= r) {
30 col[rt] = color;
31 return;
32 }
33 PushDown(rt);
34 int M = (L + R) >> 1;
35 if (l <= M) Update(L, M, lson, l, r, color);
36 if (r > M) Update(M + 1, R, rson, l, r, color);
37 }
38
39 void Query(int L, int R, int rt)
40 {
41 if (col[rt] != -1) {
42 if (!Hash[col[rt]]) cnt++;
43 Hash[col[rt]] = true;
44 return;
45 }
46 if (L == R) return;
47 int M = (L + R) >> 1;
48 Query(L, M, lson);
49 Query(M + 1, R, rson);
50 }
51
52 int Binary_Search(int low, int high, int number)
53 {
54 while (low <= high) {
55 int mid = (low + high) >> 1;
56 if (X[mid] == number) return mid;
57 else if (X[mid] < number) low = mid +1;
58 else high = mid - 1;
59 }
60 return low;
61 }
62
63 int main()
64 {
65 int Cas;
66 scanf("%d", &Cas);
67 while (Cas--) {
68 scanf("%d", &m);
69 cnt = n = 0;
70 for (int i = 0; i < m; i++) {
71 scanf("%d %d", &node[i].l, &node[i].r);
72 X[n++] = node[i].l;
73 X[n++] = node[i].r;
74 }
75 sort(X, X + n);
76 n = unique(X, X + n) - X;
77 for (int i = n - 1; i > 0; i--) {
78 if (X[i] != X[i - 1] + 1) X[n++] = X[i - 1] + 1;
79 }
80 sort(X, X + n);
81 memset(col, -1, sizeof(col));
82 for (int i = 0; i < m; i++) {
83 int l = Binary_Search(0, n - 1, node[i].l);
84 int r = Binary_Search(0, n - 1, node[i].r);
85 Update(0, n - 1, 1, l, r, i);
86 }
87 memset(Hash, false, sizeof(Hash));
88 Query(0, n - 1, 1);
89 printf("%d\n", cnt);
90 }
91 return 0;
92 }
View Code
http://poj.org/problem?id=3225
线段树：区间异或，成段更新。
集合操作：
U: 把区间[l, r]覆盖成1
I: 把区间(-oo, l)和(r, +oo)覆盖成0
D：把区间(l, r) 覆盖成0
C: 把区间(-oo, l)和(r, +oo)覆盖成0，并且把[l, r]区间0、1互换
S: 把区间[l, r]0、1互换
0、1互换的过程实际上也就是异或的过程；
成段更新操作与之前的类似，不同的是异或的操作。
显然，当一个区间被覆盖后，不管之前有没有异或标记都没有意义了，因此应该把异或标记清0；
当一个节点得到异或标记的时候，应该先判断该节点的覆盖标记，如果该节点的覆盖标记为0/1(标记为-1,表示不是完全包含或者完全不包含)，直接改变覆盖标记，否则改变异或标记。
至于如果来区别开闭区间，我们可以将区间扩大两倍，即：
左闭：x - > 2 * x
左开： x - > 2 * x + 1
右闭：y - > 2 * y;
右开: y - > 2 * y - 1
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <algorithm>
5 using namespace std;
6
7 #define lson rt << 1
8 #define rson rt << 1 | 1
9 const int MAXN = (65537 << 1);
10 bool mark[MAXN];
11 int cover[MAXN << 2];
12 int XOR[MAXN << 2];
13
14 void FXOR(int rt)
15 {
16 if (cover[rt] != -1) {
17 cover[rt] ^= 1;
18 } else
19 XOR[rt] ^= 1;
20 }
21
22 void PushDown(int rt)
23 {
24 if (cover[rt] != -1) {
25 cover[lson] = cover[rson] = cover[rt];
26 XOR[lson] = XOR[rson] = 0;
27 cover[rt] = -1;
28 }
29 if (XOR[rt]) {
30 FXOR(lson);
31 FXOR(rson);
32 XOR[rt] = 0;
33 }
34 }
35
36 void Update(int L, int R, int rt, int l, int r, char ch)
37 {
38 if (l <= L && R <= r) {
39 if (ch == 'U') {
40 cover[rt] = 1;
41 XOR[rt] = 0;
42 } else if (ch == 'D') {
43 cover[rt] = 0;
44 XOR[rt] = 0;
45 } else if (ch == 'C' || ch == 'S') {
46 FXOR(rt);
47 }
48 return;
49 }
50 PushDown(rt);
51 int M = (L + R) >> 1;
52 if (l <= M) Update(L, M, lson, l, r, ch);
53 else if (ch == 'I' || ch == 'C') {
54 XOR[lson] = cover[lson] = 0;
55 }
56 if (r > M) Update(M + 1, R, rson, l, r, ch);
57 else if (ch == 'I' || ch == 'C') {
58 XOR[rson] = cover[rson] = 0;
59 }
60 }
61
62 void Query(int L, int R, int rt)
63 {
64 if (cover[rt] != -1) {
65 if (cover[rt] == 1) {
66 for (int i = L; i <= R; i++) {
67 mark[i] = true;
68 }
69 }
70 return;
71 }
72 PushDown(rt);
73 int M = (L + R) >> 1;
74 Query(L, M, lson);
75 Query(M + 1, R, rson);
76 }
77
78 int main()
79 {
80 cover[1] = XOR[1] = 0;
81 char ch, op1, op2;
82 int a, b;
83 memset(mark, false, sizeof(mark));
84 while (~scanf("%c %c%d,%d%c\n", &ch, &op1, &a, &b, &op2)) {
85 a <<= 1;
86 b <<= 1;
87 if (op1 == '(') {
88 a++;
89 }
90 if (op2 == ')') {
91 b--;
92 }
93 if (a > b) {
94 if (ch == 'I' || ch == 'C') {
95 cover[1] = XOR[1] = 0;
96 }
97 } else
98 Update(0, MAXN, 1, a, b, ch);
99 }
100 Query(0, MAXN, 1);
101 bool flag = false;
102 int st = -1, ed;
103 for (int i = 0; i <= MAXN; i++) {
104 if (mark[i]) {
105 if (st == -1) st = i;
106 ed = i;
107 } else {
108 if (st != -1) {
109 if (flag) printf(" ");
110 flag = true;
111 printf("%c%d,%d%c", st & 1 ? '(' : '[', st >> 1, (ed + 1) >> 1, ed & 1 ? ')' : ']');
112 st = -1;
113 }
114 }
115 }
116 if (!flag) printf("empty set");
117 puts("");
118 return 0;
119 }
View Code
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
