Touching segments（数据结构）

题目链接

Problem Statement

Your Maths professor is a very nice guy, but he sometimes comes up with not so funny tasks. Today is one such day. The professor drew a bunch of parallel line segments on the board and asked the following question: "How many of these segments can be touched, even on their edges, by exactly two lines perpendicular to them?"

After a few seconds, he spoke again: "Let's make it more interesting. I will give you the starting and the ending points of N segments over the X's axis; today's homework will be to answer the question I asked you above for any set of such segments". Right after the professor's words, one guy asked: "Is there any restriction over the segments' location?", and the professor replied: "Not really, they are just segments, so they can overlap in all the ways you may imagine."

Everybody started thinking of the weird and unexpected task, without getting a convincing result. Some time later, the class got over and before leaving the classroom, the professor said: "Just to take this to the ultimate limits, your final qualification will depend entirely on this task. Good luck and please, don't try to cheat, I will know if you try to do so." So, that was it! Your final Maths qualification was hooked to some play on segments stuff.

Input Format

Input consists of several test cases. The first line in the input is an integer, T, denoting the number of test cases. T test cases follow, each one with the following format:

• A single line with an integer, N, denoting the number of segments.

• N lines, each defining a segment with two integers, a and b, separated by a single white space, meaning that there is a segment going from a to b.

Constraints
1≤T≤5 
1≤N≤105 
0≤a<b≤109

Output Format

For each test case the output should follow the following format:

• A single line with "Case #: answer" (without the quotes) where # is the serial number of the current test case (start the numbering by 1) and answer is the maximum number of segments you can touch as described above.

See the sample output for more details.

Sample Input

4
5
2 3
1 3
1 5
3 4
4 5
5
1 2
1 3
2 3
1 4
1 5
4
1 5
1 6
1 7
8 10
3
1 2
3 4
5 6

Sample Output

Case 1: 5
Case 2: 5
Case 3: 4
Case 4: 2

Explanation

• Case 1: We will draw two lines (parallel to Y-axis) crossing X-axis at point 2 and 4. These two lines will touch all the five segments.
• Case 2: We can touch all the points even with one line crossing X-axis at 2.
• Case 3: We will draw first line at any point in range [1,5] so that it can touch first three lines. We will draw second line crossing X-axis at any of the points in range [8,10] and it will touch the last line.

• Case 4: It is not possible to touch more than two lines in this case.

好题一枚。

AC代码：

 #include <cmath>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int MAX_N = ;

 struct SegTree {
     int val[MAX_N << ], lzy[MAX_N << ];
     #define lson(x) (x<<1)
     #define rson(x) ((x<<1) | 1)

     void build() {
         memset(val, , sizeof(val));
         memset(lzy, , sizeof(lzy));
     }

     void pushDown(int rt) {
         if (lzy[rt]) {
             val[lson(rt)] += lzy[rt];
             lzy[lson(rt)] += lzy[rt];
             val[rson(rt)] += lzy[rt];
             lzy[rson(rt)] += lzy[rt];
             lzy[rt] = ;
         }
     }

     void pushUp(int rt) {
         val[rt] = max(val[lson(rt)], val[rson(rt)]);
     }

     void update(int rt, int l, int r, int ql, int qr, int v) {
         if (l >= ql && r <= qr) {
             val[rt] += v;
             lzy[rt] += v;
         } else {
             pushDown(rt);
             int mid = (l + r) >> ;
             if (ql <= mid) update(lson(rt), l, mid, ql, qr, v);
             if (qr  > mid) update(rson(rt), mid+, r, ql, qr, v);
             pushUp(rt);
         }
     }

     int query(int rt, int l, int r, int ql, int qr) {
         if (l >= ql && r <= qr) {
             return val[rt];
         } else {
             pushDown(rt);
             int mid = (l + r) >> ;
             int res = ;
             if (ql <= mid) res = max(res, query(lson(rt), l, mid, ql, qr));
             if (qr  > mid) res = max(res, query(rson(rt), mid+, r, ql, qr));
             return res;
         }
     }

 }st;

 int l[MAX_N], r[MAX_N];
 int ll[MAX_N], rr[MAX_N];
 vector<int> b[MAX_N], e[MAX_N]; // segments begins at $i or ends at $i

 int main(void) {
     int T, cas = ;
     scanf("%d", &T);
     while (T--) {
         int N;
         scanf("%d", &N);
         vector<int> arr;
         for (int i = ; i < N; i++) {
             scanf("%d %d", l+i, r+i);
             arr.push_back(l[i]);
             arr.push_back(r[i]);
         }

         sort(begin(arr), end(arr));
         int m = unique(arr.begin(), arr.end()) - arr.begin();
         for (int i = ; i < m; i++) {
             b[i].clear(); e[i].clear();
         }

         st.build();
         for (int i = ; i < N; i++) {
             ll[i] = lower_bound(begin(arr), begin(arr)+m, l[i]) - begin(arr);
             rr[i] = lower_bound(begin(arr), begin(arr)+m, r[i]) - begin(arr);
             b[ll[i]].push_back(i);
             e[rr[i]].push_back(i);
             st.update(, , m-, ll[i], rr[i], );
         }

         int cnt = , ans = ;
         for (int i = ; i < m; i++) {
             for (const int &it : b[i]) {
                 st.update(, , m-, ll[it], rr[it], -);
                 ++cnt;
             }
             ans = max(ans, cnt + st.query(, , m-, , m-));
             for (const int &it : e[i]) {
                 st.update(, , m-, ll[it], rr[it], -);
                 --cnt;
             }
         }
         printf("Case %d: %d\n", cas++, ans);
     }

     return ;
 }