[离散化+树状数组]CodeForces - 652D Nested Segments

Nested Segments
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.

Input

The first line contains a single integer n (1 ≤ n ≤ 2·105) — the number of segments on a line.

Each of the next n lines contains two integers li and ri ( - 109 ≤ li < ri ≤ 109) — the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.

Output

Print n lines. The j-th of them should contain the only integer aj — the number of segments contained in the j-th segment.

Examples
input
Copy
4
1 8
2 3
4 7
5 6
output
Copy
3
0
1
0
input
Copy
3
3 4
1 5
2 6
output
Copy
0
1
1

 题意:一条线上有n条直线，没有两个线段有相同的端点，要求每个线段各自包含了多少线段

下面有2种做法

思路1:

记录下右端点的坐标，记录下右端点的坐标，将右端点离散化，用树状数组维护右端点数量前缀和,
给左端点升序排序，从最左边的左端点开始找,
因为左端点升序，所以当前左端点要比所有右端点都小（一开始是满足的，接着我们要不断删去右端点来维护这种状态），当前左端点也比它后面的要小，如果它后面的左端点对应的右端点小于当前右端点，则那条线段是包含在当前线段中的），看当前这个右端点之前有多少个右端点就可知道当前这个线段包含了多少线段
因为我们要保证当前左端点要比所有右端点小才能使得只需统计当前右端点之前有多少右端点就能知道当前这个线段包含了多少线段，如果到了下一个左端点，则上一个线段就不包含在下一个线段中了，因此如果到了下一个左端点就要删掉上一个右端点，所以要删掉当前这个已经找过的右端点

思路2:

记录下右端点的坐标，记录下右端点的坐标，将右端点离散化，用树状数组维护右端点数量前缀和,
给左端点降序排序，从最右边的左端点开始找
因为左端点降序排序，所以当前左端点后都没有比它大的未计算过的左端点，如果比它大的左端点被计算过了且那个左端点对应的右端点比现在这个左端点对应的右端点小，则那条线段必定被当前线段包含，所以按左端点降序的顺序添加对应的右端点，可以保证当前没有右端点比当前左端的小

总结:

两种思路的共同点都是要保证当前左端点之前没有比它小的右端点，这样就只需要统计当前左端点对应的右端点之前有多少个右端点就可以知道当前这条线段包含了多少线段，他们的不同点在于思路1是提前把所有的右端的都加进去了，每次查询的时候再删，而思路2是先从最大的左端点开始添加右端点

 

思路1代码:

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 typedef long long ll;
 4 const int amn=2e5+5;
 5 int bit[amn],n,tp,b[amn];
 6 struct node{
 7     int l,r,id;
 8 } a[amn];
 9 int ans[amn],jg[amn],pos;
10 map<ll,int> mp;
11 bool cmp(node a,node b){
12     if(a.r==b.r)return a.r<b.r;
13     return a.l<b.l;
14 }
15 int sum(int i){
16     int s=0;
17     while(i){
18         s+=bit[i];
19         i-=i&-i;
20     }
21     return s;
22 }
23 void add(int i,int x){
24     while(i<=tp){
25         bit[i]+=x;
26         i+=i&-i;
27     }
28 }
29 int main(){
30     ios::sync_with_stdio(0);
31     cin>>n;
32     tp=0;
33     for(int i=1;i<=n;i++){
34         a[i].id=i;          ///记录原始顺序
35         cin>>a[i].l>>a[i].r;
36         b[++tp]=a[i].r;     ///记录下右端点的坐标
37         ans[i]=0;           ///初始化答案数组
38     }
39     sort(b+1,b+1+tp);       ///给右端点的坐标排序
40     int mtp=1;
41     for(int i=1;i<=tp;i++){
42         mp[b[i]]=mtp;       ///将右端点离散化
43         mtp++;
44     }
45     for(int i=1;i<=n;i++){
46         add(mp[a[i].r],1);  ///用树状数组维护右端点数量前缀和
47     }
48     sort(a+1,a+1+n,cmp);    ///给左端点升序排序，从最左边的左端点开始找
49     for(int i=1;i<=n;i++){
50         ans[a[i].id]=sum(mp[a[i].r]-1); ///因为左端点升序，所以当前左端点要比所有未计算过的右端点都小（一开始是满足的，接着我们要不断删去右端点来维护这种状态），当前左端点也比它后面的要小，如果它后面的左端点对应的右端点小于当前右端点，则那条线段是包含在当前线段中的），看当前这个右端点之前有多少个右端点就可知道当前这个线段包含了多少线段
51         add(mp[a[i].r],-1);             ///因为我们要保证当前左端点要比所有右端点小才能使得只需统计当前右端点之前有多少右端点就能知道当前这个线段包含了多少线段，如果到了下一个左端点，则上一个线段就不包含在下一个线段中了，因此如果到了下一个左端点就要删掉上一个右端点，所以要删掉当前这个已经找过的右端点
52     }
53     for(int i=1;i<=n;i++){
54         printf("%d\n",ans[i]);
55     }
56 }
57 /***
58 一条线上有n条直线，没有两个线段有相同的端点，要求每个线段各自包含了多少线段
59 记录下右端点的坐标，记录下右端点的坐标，将右端点离散化，用树状数组维护右端点数量前缀和,
60 给左端点升序排序，从最左边的左端点开始找,
61 因为左端点升序，所以当前左端点要比所有未计算过的右端点都小（一开始是满足的，接着我们要不断删去右端点来维护这种状态），当前左端点也比它后面的要小，如果它后面的左端点对应的右端点小于当前右端点，则那条线段是包含在当前线段中的），看当前这个右端点之前有多少个右端点就可知道当前这个线段包含了多少线段
62 因为我们要保证当前左端点要比所有右端点小才能使得只需统计当前右端点之前有多少右端点就能知道当前这个线段包含了多少线段，如果到了下一个左端点，则上一个线段就不包含在下一个线段中了，因此如果到了下一个左端点就要删掉上一个右端点，所以要删掉当前这个已经找过的右端点
63 ***/

 

思路2代码:

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 typedef long long ll;
 4 const int amn=2e5+5;
 5 int bit[amn],n,tp,b[amn];
 6 struct node{
 7     int l,r,id;
 8 } a[amn];
 9 int ans[amn],jg[amn],pos;
10 map<ll,int> mp;
11 bool cmp1(node a,node b){
12     if(a.r==b.r)return a.r>b.r;
13     return a.l>b.l;
14 }
15 int sum(int i){
16     int s=0;
17     while(i){
18         s+=bit[i];
19         i-=i&-i;
20     }
21     return s;
22 }
23 void add(int i,int x){
24     while(i<=tp){
25         bit[i]+=x;
26         i+=i&-i;
27     }
28 }
29 int main(){
30     ios::sync_with_stdio(0);
31     cin>>n;
32     tp=0;
33     for(int i=1;i<=n;i++){
34         a[i].id=i;          ///记录原始顺序
35         cin>>a[i].l>>a[i].r;
36         b[++tp]=a[i].r;     ///记录下右端点的坐标
37         ans[i]=0;           ///初始化答案数组
38     }
39     sort(b+1,b+1+tp);       ///给右端点的坐标排序
40     int mtp=1;
41     for(int i=1;i<=tp;i++){
42         mp[b[i]]=mtp;       ///将右端点离散化
43         mtp++;
44     }
45     sort(a+1,a+1+n,cmp1);   ///给左端点降序排序，从最右边的左端点开始找
46     for(int i=1;i<=n;i++){
47         add(mp[a[i].r],1);  ///因为左端点降序排序，所以当前左端点后都没有比它大的未计算过的左端点，如果比它大的左端点被计算过了且那个左端点对应的右端点比现在这个左端点对应的右端点小，则那条线段必定被当前线段包含，所以按左端点降序的顺序添加对应的右端点，可以保证当前没有右端点比当前左端的小
48         ans[a[i].id]=sum(mp[a[i].r]-1);
49     }
50     for(int i=1;i<=n;i++){  ///两种思路的共同点都是要保证当前左端点之前没有比它小的右端点，这样就只需要统计当前左端点对应的右端点之前有多少个右端点就可以知道当前这条线段包含了多少线段，他们的不同点在于思路1是提前把所有的右端的都加进去了，每次查询的时候再删，而思路2是先从最大的左端点开始添加右端点
51         printf("%d\n",ans[i]);
52     }
53 }
54 /***
55 一条线上有n条直线，没有两个线段有相同的端点，要求每个线段各自包含了多少线段
56 记录下右端点的坐标，记录下右端点的坐标，将右端点离散化，用树状数组维护右端点数量前缀和,
57 给左端点降序排序，从最右边的左端点开始找
58 因为左端点降序排序，所以当前左端点后都没有比它大的未计算过的左端点，如果比它大的左端点被计算过了且那个左端点对应的右端点比现在这个左端点对应的右端点小，则那条线段必定被当前线段包含，所以按左端点降序的顺序添加对应的右端点，可以保证当前没有右端点比当前左端的小
59 两种思路的共同点都是要保证当前左端点之前没有比它小的右端点，这样就只需要统计当前左端点对应的右端点之前有多少个右端点就可以知道当前这条线段包含了多少线段，他们的不同点在于思路1是提前把所有的右端的都加进去了，每次查询的时候再删，而思路2是先从最大的左端点开始添加右端点
60 ***/

 

posted @ 2019-08-06 17:57  Railgun000  阅读(195)  评论(0)  编辑  收藏  举报