我果断想错了时间复杂度，所以就没敲出来。

有两种解法，一种是线段树，两棵线段树，一棵维护每种指令用了多少次，一棵维护每段被怎么更新，时间复杂度都是nlogn级别的，可是我算错了五个数量级，昨天晚上比赛没敢写……

另一种方法是扫描法，O(n)级别，很简单，编码复杂度也比线段树解法小得多。
扫描法

view code
 1 #include <cstdio>
 2 #define LL long long
 3 const int maxn = 100100;
 4 LL a[maxn], b[maxn], d[maxn], ll[maxn], rr[maxn], c[maxn];
 5 int l, r, n, m, k;
 6 int main(){
 7     scanf("%d%d%d", &n, &m, &k);
 8     for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
 9     for (int i = 1; i <= m; i++) scanf("%I64d%I64d%I64d", &ll[i], &rr[i], &d[i]);
10     for (int i = 1; i <= k; i++){
11         scanf("%d%d", &l, &r);
12         c[l - 1] += 1; c[r] -= 1;
13     }
14     LL t = 0;
15     for (int i = 0; i <= m; i++){
16         d[i] *= t;
17         t += c[i];
18     }
19     t = 0;
20     for (int i = 0; i <= m; i++){
21         b[ll[i] - 1] += d[i];
22         b[rr[i]] -= d[i];
23     }
24     for (int i = 0; i <= n; i++){
25         a[i] += t; t += b[i];
26     }
27     for (int i = 1; i<= n; i++) printf("%I64d ", a[i]);
28     printf("\n");
29     return 0;
30 

view code
 1 #include <cstdio>
 2 #include <cstring>
 3 #define lson l, m, rt << 1
 4 #define rson m + 1, r, rt << 1 | 1
 5 #define LL long long
 6 const int maxn = 101000;
 7 struct seg{
 8     LL sum[maxn << 2], add[maxn << 2];
 9     void PushUp(int rt){
10         sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
11     }
12     void PushDown(int rt, int m){
13         if (add[rt]){
14             add[rt << 1] += add[rt];
15             add[rt << 1 | 1] += add[rt];
16             sum[rt << 1] += add[rt] * (m - (m >> 1));
17             sum[rt << 1 | 1] += add[rt] * (m >> 1);
18             add[rt] = 0;
19         }
20     }
21     void build(int l, int r, int rt){
22         add[rt] = 0;
23         if (l == r){
24             scanf("%I64d", &sum[rt]);
25             return;
26         }
27         int m = (l + r) >> 1;
28         build(lson);
29         build(rson);
30         PushUp(rt);
31     }
32     void update(int ll, int rr, LL c, int l, int r, int rt){
33         if (ll <= l && rr >= r){
34             sum[rt] += c * (r - l + 1);
35             add[rt] += c;
36             return;
37         }
38         PushDown(rt, r - l + 1);
39         int m = (l + r) >> 1;
40         if (ll <= m) update(ll, rr, c, lson);
41         if (rr > m) update(ll, rr, c, rson);
42         PushUp(rt);
43     }
44     LL query(int x, int l, int r, int rt){
45         if (l == r) return sum[rt];
46         PushDown(rt, r - l + 1);
47         int m = (l + r) >> 1;
48         if (x <= m) return query(x, lson);
49         else return  query(x, rson);
50     }
51 };
52 struct chg{
53     int l, r;
54     LL d;
55     void get(){
56         scanf("%d%d%I64d", &l, &r, &d);
57     }
58 }x[maxn];
59 seg a, b;
60 int main(){
61     int n, m, k;
62     while (~scanf("%d%d%d", &n, &m, &k)){
63         a.build(1, n, 1);
64         memset(b.sum, 0, sizeof(b.sum));
65         memset(b.add, 0, sizeof(b.add));
66         for (int i = 1; i <= m; i++) x[i].get();
67         for (int i = 1; i <= k; i++){
68             int l, r;
69             scanf("%d%d", &l, &r);
70             b.update(l, r, 1, 1, m, 1);
71         }
72         for (int i = 1; i <= m; i++){
73             LL tt = b.query(i, 1, m, 1);
74             a.update(x[i].l, x[i].r, x[i].d * tt, 1, n, 1);
75         }
76         for (int i = 1; i <= n; i++){
77             LL ans = a.query(i, 1, n, 1);
78             printf("%I64d ", ans);
79         }
80         printf("\n");
81     }
82     return 0;
83 

线段树单点更新+区间合并，特殊的地方就是合并的时候考虑两个相邻的数是否符合条件，判断一下再决定是否合并

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 using namespace std;
 6 #define lson l, m, rt<<1
 7 #define rson m + 1, r, rt<<1|1
 8 const int maxn = 111111;
 9 int llci[maxn<<2], rlci[maxn<<2], mlci[maxn<<2];
10 int a[maxn];
11 void PushUp(int l, int r, int rt){
12     llci[rt] = llci[rt<<1];
13     rlci[rt] = rlci[rt<<1|1];
14     mlci[rt] = max(mlci[rt<<1], mlci[rt<<1|1]);
15     int m = (l + r) >> 1;
16     if (a[m] < a[m + 1]){
17         if (llci[rt] == m - l + 1) llci[rt] += llci[rt<<1|1];
18         if (rlci[rt] == r - m) rlci[rt] += rlci[rt<<1];
19         mlci[rt] = max(mlci[rt], llci[rt<<1|1] + rlci[rt<<1]);
20     }
21 }
22 void build(int l, int r, int rt){
23     if (l == r){
24         llci[rt] = rlci[rt] = mlci[rt] = 1;
25         return;
26     }
27     int m = (l + r) >> 1;
28     build(lson);
29     build(rson);
30     PushUp(l, r, rt);
31 }
32 void update(int x, int c, int l, int r, int rt){
33     if (l == r){
34         a[l] = c;
35         return;
36     }
37     int m = (l + r) >> 1;
38     if (x <= m) update(x, c, lson);
39     else update(x, c, rson);
40     PushUp(l, r, rt);
41 }
42 int query(int ll, int rr, int l, int r, int rt){
43     if (ll == l && rr == r) return mlci[rt];
44     int m = (l + r) >> 1;
45     if (rr <= m) return query(ll, rr, lson);
46     else if (ll > m) return query(ll, rr, rson);
47     else{
48         int x = query(ll, m, lson);
49         int y = query(m + 1, rr, rson);
50         int z = 0;
51         if (a[m] < a[m + 1]){
52             z += min(llci[rt<<1|1], rr - m);
53             z += min(rlci[rt<<1], m - ll + 1);
54         }
55         return max(x, max(y, z));
56     }
57 }
58 int main(){
59     int t;
60     scanf("%d", &t);
61     while (t--){
62         int n, m;
63         scanf("%d%d", &n, &m);
64         for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
65         build(1, n, 1);
66         char op[2]; int x, y;
67         while (m--){
68             scanf("%s%d%d", op, &x, &y);
69             x += 1;
70             if (op[0] == 'U') update(x, y, 1, n, 1);
71             else{
72                 y += 1;
73                 int ans = query(x, y, 1, n, 1);
74                 printf("%d\n", ans);
75             }
76         }
77     }
78     return 0;
79 

我感觉这道题给那个那个差的比较就是坑爹的……我按着差写了大半天结果WA了个各种惨啊……

好吧，这道题是按照权值建立线段树，意思就是把每一个点加入到它应有的大小范围内，线段树上面每一个点维护的是该区间内有多少个点，这样很容易就能查出来比某一个元素大的元素有多少个。而且，还得先对所有的点排序，主排序应该是把s从小到大排序，当s相等的时候，e从大到小排序，这样就必须记录每个元素原来的位置，这样每次插入一个新的元素的时候，在它之前插入的所有的元素s上都是满足条件的，换言之，线段树中只需要维护e的情况就行了。其实……e符合条件了差值自然也就符合条件了。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <algorithm>
 4 #include <cstring>
 5 using namespace std;
 6 #define lson l, m, rt << 1
 7 #define rson m + 1, r, rt << 1 | 1
 8 const int maxn = 100100;
 9 struct data{
10     int s, e, i;
11     friend bool operator < (const data &a, const data &b){
12         if (a.s != b.s) return a.s < b.s;
13         return a.e > b.e;
14     }
15 }cow[maxn];
16 int num[maxn << 2], ans[maxn];
17 void build(int l, int r, int rt){
18     num[rt] = 0;
19     if (l == r) return;
20     int m = (l + r) >> 1;
21     build(lson);
22     build(rson);
23 }
24 void update(int x, int l, int r, int rt){
25     num[rt] += 1;
26     if (l == r) return;
27     int m = (l + r) >> 1;
28     if (x <= m) update(x, lson);
29     else update(x, rson);
30 }
31 int query(int ll, int rr, int l, int r, int rt){
32     if (ll <= l && rr >= r) return num[rt];
33     int m = (l + r) >> 1;
34     int ret = 0;
35     if (ll <= m) ret += query(ll, rr, lson);
36     if (rr > m) ret += query(ll, rr, rson);
37     return ret;
38 }
39 int main(){
40     int n;
41     while (~scanf("%d", &n) && n){
42         memset(ans, 0, sizeof(ans));
43         int m = 0;
44         for (int i = 0; i < n; i++){
45             scanf("%d%d", &cow[i].s, &cow[i].e);
46             cow[i].s += 1; cow[i].e += 1;
47             m = max(cow[i].e, m);
48             cow[i].i = i;
49         }
50         sort(cow, cow + n);
51         build (1, m, 1);
52         for (int i = 0; i < n; i++){
53             if (i && cow[i].s == cow[i - 1].s && cow[i].e == cow[i - 1].e){
54                 ans[cow[i].i] = ans[cow[i - 1].i];
55                 update(cow[i].e, 1, m, 1);
56             }
57             else{
58                 ans[cow[i].i] = query(cow[i].e, m, 1, m, 1);
59                 update(cow[i].e, 1, m, 1);
60             }
61         }
62         for (int i = 0; i < n; i++){
63             printf("%d", ans[i]);
64             if (i != n-1) printf(" ");
65             else printf("\n");
66         }
67     }
68     return 0;
69 

大意就是给一个动态的序列，每次询问序列中第k个元素是啥，询问完以后，就删除这个元素，同时可以在结尾添加元素，如果当前位置没有元素，就输出“none”。

这道题可以说唯一一个捉急的地方就是带删除序列的，所以树上维护的东西就应该是当前区间内还有多少个元素没被删除，这样当询问到某一棵子树的时候，如果左子树的元素个数大于k，那么元素必定在左子树当中，否则就在右子树当中，在左子树当中固然好，就是左子树区间内第k个，在右子树的话就应该是第k减去左子树元素个数个，同时在叶子结点维护元素值，当即搞定。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 200100;
11 int num[maxn << 2], id[maxn << 2], ans;
12 void PushUp(int rt){
13     num[rt] = num[rt << 1] + num[rt << 1 | 1];
14 }
15 void build(int l, int r, int rt){
16     num[rt] = 0; id[rt] = -1;
17     if (l == r) return;
18     int m = (l + r) >> 1;
19     build(lson);
20     build(rson);
21 }
22 void update(int x, int c, int l, int r, int rt){
23     if (l == r){
24         num[rt] = 1;
25         id[rt] = c;
26         return;
27     }
28     int m = (l + r) >> 1;
29     if (x <= m) update(x, c, lson);
30     else update(x, c, rson);
31     PushUp(rt);
32 }
33 void query(int k, int l, int r, int rt){
34     num[rt] -= 1;
35     if (l == r){
36         ans = id[rt]; id[rt] = -1;
37         return;
38     }
39     int m = (l + r) >> 1;
40     if (num[rt << 1] >= k) query(k, lson);
41     else{
42         k -= num[rt << 1];
43         query(k, rson);
44     }
45 }
46 int main(){
47     int t;
48     scanf("%d", &t);
49     for (int p = 1; p <= t; p++){
50         int n, m;
51         scanf("%d%d", &n, &m);
52         int nn = n + m;
53         build(1, nn, 1);
54         printf("Case %d:\n", p);
55         for (int i = 1; i <= n; i++){
56             int x; scanf("%d", &x);
57             update(i, x, 1, nn, 1);
58         }
59         while (m--){
60             char s[2]; int x;
61             scanf("%s%d", s, &x);
62             if (s[0] == 'a'){
63                 n += 1;
64                 update(n, x, 1, nn, 1);
65             }
66             else{
67                 query(x, 1, nn, 1);
68                 if (ans == -1) printf("none\n");
69                 else printf("%d\n", ans);
70             }
71         }
72     }
73     return 0;
74 }
75 

线段树比较基础的题目，比较捉急的就是离散化，离散化就是将大的区间映射到小的区间中，具体的看代码吧，这个是傻崽大神的代码，本菜的话决计写不出来这么巧妙的代码，不过不得不说，这次受益匪浅，以后我想我会记住这些东西……

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 11111;
11 bool hash[maxn];
12 int li[maxn], ri[maxn];
13 int X[maxn * 3];
14 int col[maxn << 4];
15 int cnt;
16 void PushDown(int rt){
17     if (col[rt] != -1){
18         col[rt << 1] = col[rt << 1 | 1] = col[rt];
19         col[rt] = -1;
20     }
21 }
22 void update(int ll, int rr, int c, int l, int r, int rt){
23     if (ll <= l && rr >= r){
24         col[rt] = c;
25         return;
26     }
27     PushDown(rt);
28     int m = (l + r) >> 1;
29     if (ll <= m) update(ll, rr, c, lson);
30     if (rr > m) update(ll, rr, c, rson);
31 }
32 void query(int l, int r, int rt){
33     if (col[rt] != -1){
34         if (!hash[col[rt]]) cnt += 1;
35         hash[col[rt]] = true;
36         return;
37     }
38     if (l == r) return;
39     int m = (l + r) >> 1;
40     query(lson);
41     query(rson);
42 }
43 int Bin(int key, int n, int X[]){
44     int l = 0, r = n - 1;
45     while (l <= r){
46         int m = (l + r) >> 1;
47         if (X[m] == key) return m;
48         if (X[m] < key) l = m + 1;
49         else r = m - 1;
50     }
51 }
52 int main(){
53     int t;
54     scanf("%d", &t);
55     while (t--){
56         int n; scanf("%d", &n);
57         int nn = 0;
58         for (int i = 0; i < n; i++){
59             scanf("%d%d", &li[i], &ri[i]);
60             X[nn++] = li[i];
61             X[nn++] = ri[i];
62         }
63         sort(X, X + nn);
64         int m = 1;
65         for (int i = 1; i < nn; i++){
66             if (X[i] != X[i - 1]) X[m++] = X[i];
67         }
68         sort(X, X + m);
69         for (int i = m - 1; i > 0; i--){
70             if (X[i] != X[i - 1] + 1) X[m++] = X[i - 1] + 1;
71         }
72         sort(X, X + m);
73         memset(col, -1, sizeof(col));
74         for (int i = 0; i < n; i++){
75             int l = Bin(li[i], m, X);
76             int r = Bin(ri[i], m, X);
77             update(l, r, i, 0, m, 1);
78         }
79         cnt = 0;
80         memset(hash, 0, sizeof(hash));
81         query(0, m, 1);
82         printf("%d\n", cnt);
83     }
84     return 0;
85 

并查集合并小组，这个自然是不用说的，主要的问题是怎么求第K大值。

首先，线段树每一个结点存储的是组内元素的个数区间内有多少个组，初始化的时候所有的组中都是一个元素，所以当区间左端点为1的时候，结点的值为n，然后每次合并，原有小组的空间内结点值-1，合并后的新组空间内结点值+1，线段树这么维护完了以后，询问过程中，如果右子树的值大于k，那么第k大数一定在右子树当中。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 200010;
11 int sum[maxn << 2], n, q;
12 struct data{
13     int p, num;
14 }p[maxn];
15 void build(int l, int r, int rt){
16     if (l == 1) sum[rt] = n;
17     else sum[rt] = 0;
18     if (l == r) return;
19     int m = (l + r) >> 1;
20     build(lson);
21     build(rson);
22 }
23 void update(int x, int f, int l, int r, int rt){
24     if (!f) sum[rt] -= 1;
25     else sum[rt] += 1;
26     if (l == r) return;
27     int m = (l + r) >> 1;
28     if (x <= m) update(x, f, lson);
29     else update(x, f, rson);
30 }
31 void query(int k, int l, int r, int rt){
32     if (l == r){
33         printf("%d\n", l);
34         return;
35     }
36     int m = (l + r) >> 1;
37     if (sum[rt << 1 | 1] >= k) query(k, rson);
38     else query(k - sum[rt << 1 | 1], lson);
39 }
40 int find(int x){
41     if (p[x].p == x) return x;
42     int temp = p[x].p;
43     p[x].p = find(temp);
44     p[x].num = p[temp].num + p[x].num;
45     return p[x].p;
46 }
47 int main(){
48     while (~scanf("%d%d", &n, &q)){
49         for (int i = 0; i <= n; i++){
50             p[i].p = i; p[i].num = 1;
51         }
52         build(1, n, 1);
53         while (q--){
54             int op;
55             scanf("%d", &op);
56             if (op == 0){
57                 int x, y;
58                 scanf("%d%d", &x, &y);
59                 x = find(x);
60                 y = find(y);
61                 if (x == y) continue;
62                 update(p[x].num, 0, 1, n, 1);
63                 update(p[y].num, 0, 1, n, 1);
64                 update(p[x].num + p[y].num, 1, 1, n, 1);
65                 p[y].p = x;
66                 p[x].num += p[y].num;
67             }
68             if (op == 1){
69                 int k;
70                 scanf("%d", &k);
71                 query(k, 1, n, 1);
72             }
73         }
74     }
75     return 0;
76 }
77 

既然题目中说Y坐标是升序给出，那么只需要维护到当前结点的小于X的值，这样很快能求出来所有的等级，然后就balabalabala……

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 32010;
11 int sum[maxn << 2], ans[15010];
12 void PushUp(int rt){
13     sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
14 }
15 void build(int l, int r, int rt){
16     sum[rt] = 0;
17     if (l == r) return;
18     int m = (l + r) >> 1;
19     build(lson);
20     build(rson);
21     PushUp(rt);
22 }
23 void update(int x, int l, int r, int rt){
24     if (l == r){
25         sum[rt] += 1;
26         return;
27     }
28     int m = (l + r) >> 1;
29     if (x <= m) update(x, lson);
30     else update(x, rson);
31     PushUp(rt);
32 }
33 int query(int ll, int rr, int l, int r, int rt){
34     if (ll <= l && rr >= r) return sum[rt];
35     int m = (l + r) >> 1;
36     int ret = 0;
37     if (ll <= m) ret += query(ll, rr, lson);
38     if (rr > m) ret += query(ll, rr, rson);
39     return ret;
40 }
41 int main(){
42     int n;
43     while (~scanf("%d", &n)){
44         build(0, maxn, 1);
45         int x, y;
46         for (int i = 0; i < n; i++){
47             scanf("%d%d", &x, &y);
48             int cnt = query(0, x, 0, maxn, 1);
49             ans[cnt] += 1;
50             update(x, 0, maxn, 1);
51         }
52         for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
53     }
54     return 0;
55 

裸裸的线段树，就是一个结点存储两个值，一个是区间内最大值，一个是区间内最小值，最后做个差了事儿～～这两天被很多题虐爆了，今天放松一下心情……

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 50010;
11 int MAX[maxn << 2], MIN[maxn << 2];
12 void PushUp(int rt)
13 {
14     MAX[rt] = max(MAX[rt << 1], MAX[rt << 1 | 1]);
15     MIN[rt] = min(MIN[rt << 1], MIN[rt << 1 | 1]);
16 }
17 void build(int l, int r, int rt)
18 {
19     if (l == r)
20     {
21         scanf("%d", &MAX[rt]);
22         MIN[rt] = MAX[rt];
23         return;
24     }
25     int m = (l + r) >> 1;
26     build(lson);
27     build(rson);
28     PushUp(rt);
29 }
30 int queryzg(int ll, int rr, int l, int r, int rt)
31 {
32     if (ll <= l && rr >= r) return MAX[rt];
33     int m = (l + r) >> 1;
34     int ret = 0;
35     if (ll <= m) ret = max(ret, queryzg(ll, rr, lson));
36     if (rr > m) ret = max(ret, queryzg(ll,rr, rson));
37     return ret;
38 }
39 int queryza(int ll, int rr, int l, int r, int rt)
40 {
41     if (ll <= l && rr >= r) return MIN[rt];
42     int m = (l + r) >> 1;
43     int ret = 210000000;
44     if (ll <= m) ret = min(ret, queryza(ll, rr, lson));
45     if (rr > m) ret = min(ret, queryza(ll, rr, rson));
46     return ret;
47 }
48 int main()
49 {
50     int n, q;
51     while (scanf("%d%d", &n, &q) != EOF)
52     {
53         build(1, n, 1);
54         while (q--)
55         {
56             int x, y;
57             scanf("%d%d", &x, &y);
58             int da = queryzg(x, y, 1, n, 1);
59             int xi = queryza(x, y, 1, n, 1);
60             int ans = da - xi;
61             printf("%d\n", ans);
62         }
63     }
64     return 0;
65 }
66 

貌似线段树的区间染色是一个非常常见的题型吧，但是不得不说。。我昨天刚刚碰到，而且统计每一种颜色占了多少个不连续区间的时候着实不会写，表示前面把树建出来和更新的步骤都是纯我自己写的，就是查找颜色个数那一步。。。不得不参考了，最后弄明白了。

如果一个区间没有染色或者有多种颜色，都会有标记，如果有了标记，就可以不用考虑这个结点了，直接找它的两个儿子就行了。如果证实某一个区间被染过色而且里面仅仅有一个颜色，那么就可以与其相邻子树比较然后再更新结果值（要求的是每种颜色占的不连续区间数量，相邻子树代表的是连续区间，所以就得这么比较），然后直接退出这个状态（都说了里面只有一个颜色，就没有找它儿子的必要了）。。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m, r, rt << 1 | 1
10 const int maxn = 8010;
11 int col[maxn << 2], temp, num[maxn];
12 void PushDown(int rt)
13 {
14     if (col[rt] >= 0)
15     {
16         col[rt << 1] = col[rt];
17         col[rt << 1 | 1] = col[rt];
18         col[rt] = -2;
19     }
20 }
21 void build(int l, int r, int rt)
22 {
23     col[rt] = -1;
24     if (l == (r - 1)) return;
25     int m = (l + r) >> 1;
26     build(lson);
27     build(rson);
28 }
29 void update(int ll, int rr, int c, int l, int r, int rt)
30 {
31     if (col[rt] == c) return;
32     if (ll <= l && rr >= r)
33     {
34         col[rt] = c;
35         return;
36     }
37     PushDown(rt);
38     int m = (l + r) >> 1;
39     if (ll < m) update(ll, rr, c, lson);
40     if (rr > m) update(ll, rr, c, rson);
41 }
42 void countt(int l, int r, int rt)
43 {
44     if (col[rt] != -1 && col[rt] != -2)
45     {
46         if (col[rt] != temp)
47         {
48             num[col[rt]]++;
49             temp = col[rt];
50         }
51         return;
52     }
53     int m = (l + r) >> 1;
54     if (l != (r - 1))
55     {
56         countt(lson);
57         countt(rson);
58     }
59     else temp = -1;
60 }
61 int main()
62 {
63     int t;
64     while (scanf("%d", &t) != EOF)
65     {
66         memset(num, 0, sizeof(num));
67         build(0, 8000, 1);
68         while (t--)
69         {
70             int x, y, z;
71             scanf("%d%d%d", &x, &y, &z);
72             update(x, y, z, 0, 8000, 1);
73         }
74         countt(0, 8000, 1);
75         for (int i = 0; i <= 8000; i++) if (num[i]) printf("%d %d\n", i, num[i]);
76         cout << endl;
77     }
78     return 0;
79 }
80 

真心不解释，如果加一个U操作简直可以跟前几天发的某一道题配对儿了。。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 100010;
11 int MIN[maxn << 2];
12 void PushUp(int rt)
13 {
14     MIN[rt] = min(MIN[rt << 1], MIN[rt << 1 | 1]);
15 }
16 void build(int l, int r, int rt)
17 {
18     if (l == r)
19     {
20         scanf("%d", &MIN[rt]);
21         return;
22     }
23     int m = (l + r) >> 1;
24     build(lson);
25     build(rson);
26     PushUp(rt);
27 }
28 int query(int ll, int rr, int l, int r, int rt)
29 {
30     if (ll <= l && rr >= r) return MIN[rt];
31     int m = (l + r) >> 1;
32     int ret = maxn;
33     if (ll <= m) ret = min(ret, query(ll, rr, lson));
34     if (rr > m) ret = min(ret, query(ll, rr, rson));
35     return ret;
36 }
37 int main()
38 {
39     int t;
40     scanf("%d", &t);
41     for (int i = 1; i <= t; i++)
42     {
43         printf("Case %d:\n", i);
44         int n, m; scanf("%d%d", &n, &m);
45         build(1, n, 1);
46         while (m--)
47         {
48             int x, y;
49             scanf("%d%d", &x, &y);
50             int ans = query(x, y, 1, n, 1);
51             printf("%d\n", ans);
52         }
53     }
54     return 0;
55 

被坑出翔了，本来刚刚学会了懒惰标记，以为这道题也用得上懒惰标记（每一个结点记录的是区间内1的个数，取反的话直接区间总长度减去当前权值），但是写完以后，debug了三个多小时都没有成功，最后才发现，由于用了懒惰标记，叶子结点从来没有被更新过，当取反偶数次，然后询问到某一个没有被更新过的叶子结点的时候，就相当于进行了第一次取反，这样一来就变成了奇数次取反，刚好相反啊亲……所以最终的结果就是这个想法宣告失败（如果不用懒惰标记而是每次都更新到底的话就能成功……但是这会使得程序非常蛋疼，万一超时了呢。。一会儿写写试试）

然后我接受了一个新的想法（是的，接受。。），就是除了叶子结点记录的是本身以外，其他的结点记录的都是一共取了多少次反，这样一来边往下找边加和最后对2取一个余数、、尼玛。。。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 100010;
11 char s[maxn];
12 int sum[maxn << 2];
13 void build(int l, int r, int rt)
14 {
15     if (l == r)
16     {
17         sum[rt] = s[l - 1] - '0';
18         return;
19     }
20     sum[rt] = 0;
21     int m = (l + r) >> 1;
22     build(lson);
23     build(rson);
24 }
25 void update(int ll, int rr, int l, int r, int rt)
26 {
27     if (ll <= l && rr >= r)
28     {
29         sum[rt]++;
30         return;
31     }
32     int m = (l + r) >> 1;
33     if (ll <= m) update(ll, rr, lson);
34     if (rr > m) update(ll, rr, rson);
35 }
36 void query(int p, int v, int l, int r, int rt)
37 {
38     v += sum[rt];
39     if (l == r)
40     {
41         printf("%d\n", v % 2);
42         return;
43     }
44     int m = (l + r) >> 1;
45     if (p <= m) query(p, v, lson);
46     else query(p, v, rson);
47 }
48 int main()
49 {
50     int t;
51     scanf("%d", &t);
52     for (int i = 1; i <= t; i++)
53     {
54         printf("Case %d:\n", i);
55         scanf("%s", s);
56         int n = strlen(s);
57         build(1, n, 1);
58         int m; scanf("%d", &m);
59         char c[2];
60         while (m--)
61         {
62             scanf("%s", c);
63             if (c[0] == 'I')
64             {
65                 int x, y;
66                 scanf("%d%d", &x, &y);
67                 update(x, y, 1, n, 1);
68             }
69             if (c[0] == 'Q')
70             {
71                 int x;
72                 scanf("%d", &x);
73                 query(x, 0, 1, n, 1);
74             }
75         }
76     }
77     return 0;
78 

求的是给定区间段的值，或者直接更新某一段的值，也就是线段树的成段更新，成段更新是需要一个懒惰标记的，也就是说，如果要更新某一个区间段，当更新到这个区间段的时候，就停止在这里，给这个区间段做一个标记，不往下更新，只有再次更新到这个区间的子区间的时候，才更新到下面，同时标记下放且原标记清零，如果询问的区间是这个区间的子区间，也标记下放且清零，这样一来大大地节省了时间消耗。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cmath>
 5 #include <algorithm>
 6 #include <cstring>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 100010;
11 long long sum[maxn << 2], add[maxn << 2];
12 void PushUp(int rt)
13 {
14     sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
15 }
16 void PushDown(int rt, int m)
17 {
18     if (add[rt])
19     {
20         add[rt << 1] += add[rt];
21         add[rt << 1 | 1] += add[rt];
22         sum[rt << 1] += add[rt] * (m - (m >> 1));
23         sum[rt << 1 | 1] += add[rt] * (m >> 1);
24         add[rt] = 0;
25     }
26 }
27 void build(int l, int r, int rt)
28 {
29     if (l == r)
30     {
31         scanf("%lld", &sum[rt]);
32         return;
33     }
34     int m = (l + r) >> 1;
35     build(lson);
36     build(rson);
37     PushUp(rt);
38 }
39 void update(int ll, int rr, int c, int l, int r, int rt)
40 {
41     if (ll <= l && rr >= r)
42     {
43         add[rt] += c;
44         sum[rt] += (long long)c * (r - l + 1);
45         return;
46     }
47     PushDown(rt, r - l + 1);
48     int m = (l + r) >> 1;
49     if (ll <= m) update(ll, rr, c, lson);
50     if (rr > m) update(ll, rr, c, rson);
51     PushUp(rt);
52 }
53 long long query(int ll, int rr, int l, int r, int rt)
54 {
55     if (ll <= l && rr >= r) return sum[rt];
56     PushDown(rt, r - l + 1);
57     int m = (l + r) >> 1;
58     long long ret = 0;
59     if (ll <= m) ret += query(ll, rr, lson);
60     if (rr > m) ret += query(ll, rr, rson);
61     return ret;
62 }
63 int main()
64 {
65     int m, n;
66     while(scanf("%d%d", &n, &m) != EOF)
67     {
68         build(1, n, 1);
69         char c[2];
70         while(m--)
71         {
72             scanf("%s", c);
73             if (c[0] == 'Q')
74             {
75                 int x, y;
76                 scanf("%d%d", &x, &y);
77                 long long ans = query(x, y, 1, n, 1);
78                 printf("%lld\n", ans);
79             }
80             if (c[0] == 'C')
81             {
82                 int x, y, z;
83                 scanf("%d%d%d", &x, &y, &z);
84                 update(x, y, z, 1, n, 1);
85             }
86         }
87     }
88     return 0;
89 

首先对我自己做一个无语的表情，考试周了我还在每天刷题，不过这个不是终点啦

题意就是dota里面的屠夫的钩人技能，每钩一个单位长度产生一定的伤害，初始伤害都是1，可以任意改，有三种钩子，金钩银钩铁钩子，三种钩子的单位伤害分别为3，2，1，可以将任意区间内的钩子替换，问最终的总伤害是多少。

裸的区间更新线段树，由于问的是最终的总伤害，只需要求出来根节点的权值就行啦。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <cstdlib>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 100010;
11 int sum[maxn << 2], col[maxn << 2];
12 void PushUp(int rt)
13 {
14     sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
15 }
16 void PushDown(int rt, int m)
17 {
18     if (col[rt])
19     {
20         col[rt << 1] = col[rt << 1 | 1] = col[rt];
21         sum[rt << 1] = col[rt] * (m - (m >> 1));
22         sum[rt << 1 | 1] = col[rt] * (m >> 1);
23         col[rt] = 0;
24     }
25 }
26 void build(int l, int r, int rt)
27 {
28     col[rt] = 0;
29     if (l == r)
30     {
31         sum[rt] = 1;
32         return;
33     }
34     int m = (l + r) >> 1;
35     build(lson);
36     build(rson);
37     PushUp(rt);
38 }
39 void update(int ll, int rr, int c, int l, int r, int rt)
40 {
41     if (ll <= l && rr >= r)
42     {
43         col[rt] = c;
44         sum[rt] = c * (r - l + 1);
45         return;
46     }
47     PushDown(rt, r - l + 1);
48     int m = (l + r) >> 1;
49     if (ll <= m) update(ll, rr, c, lson);
50     if (rr > m) update(ll, rr, c, rson);
51     PushUp(rt);
52 }
53 int main()
54 {
55     int t;
56     scanf("%d", &t);
57     for (int i = 1; i <= t; i++)
58     {
59         int n, m;
60         scanf("%d%d", &n, &m);
61         build(1, n, 1);
62         while(m--)
63         {
64             int x, y, z;
65             scanf("%d%d%d", &x, &y, &z);
66             update(x, y, z, 1, n, 1);
67         }
68         printf("Case %d: The total value of the hook is %d.\n", i, sum[1]);
69     }
70     return 0;
71 

题目一看好高深啊，不过还好，AC。。

这道题如果正着看，那么每一个人的地方都有可能变动，但是如果倒着看，每一个只要入队了，他的位置就不再改变，这样的话就是一道赤裸裸的线段树单点更新了，每一个结点存储的是该区间内还有多少个空位，每一次遇到一个人的时候，都把他插入到正确的位置，至于怎么算正确的位置，如果当前结点左子树权值大于pos，那么就往左边放，否则就往右边放，放不进去左边的时候，pos要减去左边的空位数，否则的话有可能右边也放不进去，最后根本放不到叶子结点里面。每进入一个区间，该区间的空位数就减少一个，这个千万不要忘了处理。最后用一个数组来存储插入进去以后的最终位置。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 200010;
11 int sum[maxn << 2], pos[maxn], val[maxn], ans[maxn], id;
12 void PushUp(int rt)
13 {
14     sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
15 }
16 void build(int l, int r, int rt)
17 {
18     if (l == r)
19     {
20         sum[rt] = 1;
21         return;
22     }
23     int m = (l + r) >> 1;
24     build(lson);
25     build(rson);
26     PushUp(rt);
27 }
28 void query(int p, int l, int r, int rt)
29 {
30     sum[rt]--;
31     if (l == r)
32     {
33         id = l;
34         return;
35     }
36     int m = (l + r) >> 1;
37     if (p <= sum[rt << 1]) query(p, lson);
38     else
39     {
40         p -= sum[rt << 1];
41         query(p, rson);
42     }
43 }
44 int main()
45 {
46     int n;
47     while (scanf("%d", &n) != EOF)
48     {
49         build(1, n, 1);
50         for (int i = 1; i <= n; i++) scanf("%d%d", &pos[i], &val[i]);
51         for (int i = n; i >= 1; i--)
52         {
53             query(pos[i] + 1, 1, n, 1);
54             ans[id] = val[i];
55         }
56         for (int i = 1; i <= n; i++)
57         {
58             printf("%d", ans[i]);
59             if (i == n) printf("\n");
60             else printf(" ");
61         }
62     }
63     return 0;
64