Codeforces 542A. Place Your Ad Here (扫描线进阶 带权值的线段交求最大值) （线段树）

题目：

给n个线段：[ L , R]     

给m个线段：[ A , B ] 权值为C

(1<= n , m <= 200000)   (0<=L<=R<=10^9)  (0<=A<=B<=10^9)  (1<=C<=10^9)

要求：在两组线段中各选一个，使得两个线段的相交部分[ X,Y] 满足 (Y-X)*C 的值最大，求这个最大值以及选择的是哪一对线段。

一类线段带权值，一类不带权值，所以，对于每个带权值的线段，找出跟它相交长度最大的线段，遍历就行了。

直接做是O(mn)会超时，所以需要用到扫描线，这个扫描线还是比较复杂的。

首先，线段相交分为以下四种情况：



将所有线段都加入扫描线，每条线段都出现两次：一次入边， 一次出边。

以下就用L,R代表无权值线段的入边，出边。用A,B代表有权值线段的入边，出边。

扫描线的过程，就是将所有的A,B,L,R排序，然后从小到大扫描一遍。

并且，当坐标一样时，先进行L,R操作（更新数据结构记录的信息），再进行A,B操作（A,B的操作其实就是更新最终答案）。

那么，整个过程实际上，就是在A,B,L,R这四个端点各需要进行什么操作的问题。

以下，设当前坐标为X，按坐标从小到大扫描。L,R,A,B中未列出的操作表示不操作。

情况一： 维护覆盖了X点的LR线段中，可以达到的最大R值是多少 O(n)
L：更新最大的R值

A：若最大R值大于等于B，更新答案。

这种方法实际上，可以计算所有覆盖了A端点的答案。

情况二： O(n log2(n))

R:将R-L这个值加入L的位置。O(log2(n))

B:在区间[A,B]中查找最大值。O(log2(n))

这样做可以找出所有AB覆盖LR的线段，是因为碰到了R端点，才会将R-L加入L位置。

所以，碰到B端点时，在区间[A,B]中，搜到的所有的线段，都是L>=A 并且 R<=B的LR线段。

情况三：

可以跟情况一用同一种方法来做，情况四需要反向扫描。

另一种办法是用平衡树：O(n log2(n))

L：将本线段R值加入平衡树

R：将R值从平衡树中删除

A：找到平衡树中的最大值，计算。

在A点的平衡树的线段LR中，L<=A 并且 R > A

情况四：

L：将L值加入平衡树

R：将L值从平衡树中删除

B：找到平衡树中最小值，计算。

在B点的平衡树的线段LR中，L<=B 并且 R > B

在代码中，将情况一跟三合并成了覆盖了A端点的答案。

所以代码中分了三类：

一：AB包含LR的情况      L>=A    R<=B          --  用线段树维护，单次操作O(log2(n))  总复杂度 O(n log2(n))

二：LR覆盖了A点的情况  L<=A   R>A           --单次操作：平衡树O(log2(n))   或情况一中描述的方法O(1)

三：LR覆盖了B点的情况  L<=B   R>B            --同第二类。

第一类就用线段树O(n*log2(n))

如果二，三类，使用情况一描述的O(n)方法,第二类需要从左往右扫描，第三类需要从右往左扫描，但是都是O(n)复杂度。

如果二，三类，使用平衡树，则只需要从左往右扫描一次，但是总复杂度是O(n*log2(n))

实测：平衡树是982ms  另一种方法是561ms。

平衡树代码：（982ms   49300KB）

/*
982 ms 49300 KB
*/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define maxn 200007
#define LL long long
using namespace std;
//SBT(Size Balanced Tree)
struct Node{
int V,ID;
Node():V(0),ID(0){}
Node(int V,int ID):V(V),ID(ID){}
bool operator <(const Node &B)const{return V < B.V || V==B.V && ID < B.ID;}
bool operator ==(const Node &B)const{return V==B.V&&ID==B.ID;}
}K[maxn<<1];
int L[maxn<<1],R[maxn<<1],S[maxn<<1],IP,TA,TB;
void zig(int &x){int t=R[x];R[x]=L[t];L[t]=x;S[t]=S[x];S[x]=S[L[x]]+S[R[x]]+1;x=t;}
void zag(int &x){int t=L[x];L[x]=R[t];R[t]=x;S[t]=S[x];S[x]=S[L[x]]+S[R[x]]+1;x=t;}
void lev(int &x,bool flag){
if(flag){
if(S[L[L[x]]]>S[R[x]]) zag(x);
else if(S[R[L[x]]]>S[R[x]]) {zig(L[x]);zag(x);}
else return;
}
else{
if(S[R[R[x]]]>S[L[x]]) zig(x);
else if(S[L[R[x]]]>S[L[x]]){zag(R[x]);zig(x);}
else return;
}
lev(L[x],true);lev(R[x],false);
lev(x,true);lev(x,false);
}
void Insert(int &rt,Node X){
if(!rt) {rt=++IP;L[rt]=R[rt]=0;S[rt]=1;K[rt]=X;return;}
X < K[rt]?Insert(L[rt],X):Insert(R[rt],X);
++S[rt];lev(rt,X < K[rt]);
}
Node Delete(int &rt,Node X){
Node Del;--S[rt];
if(X == K[rt] || X < K[rt] && !L[rt] || K[rt] < X && !R[rt]){
Del=K[rt];
if(!L[rt]||!R[rt]) rt=L[rt]+R[rt];
else K[rt]=Delete(L[rt],X);
}
else Del=X < K[rt]?Delete(L[rt],X):Delete(R[rt],X);
lev(rt,K[rt]<X);
return Del;
}
int Min(int &rt){return L[rt]?Min(L[rt]):rt;}
int Max(int &rt){return R[rt]?Max(R[rt]):rt;}
//非递归线段树 -- 单点修改，维护区间最大值
//Segment Tree
Node ST[maxn<<4];
int N;
void Build(int n){//初始化
N=1;while(N < n+2) N <<= 1;
int I=N <<1;
Node X=Node(0,0);
for(int i=0;i<I;++i) ST[i]=X;
}
void Update(int L,Node X){//点更新
for(int s=N+L;s;s>>=1){
if(ST[s]<X) ST[s]=X;
else break;
}
}
Node Query(int L,int R){//查询区间最大值
Node ANS;
for(int s=N+L-1,t=N+R+1;s^t^1;s>>=1,t>>=1){
if(~s&1&&ANS < ST[s^1]) ANS=ST[s^1];
if( t&1&&ANS < ST[t^1]) ANS=ST[t^1];
}
return ANS;
}
//离散化
int Rank[maxn<<2],Rn;
void SortRank(){
int I=1;
sort(Rank+1,Rank+Rn+1);
for(int i=2;i<=Rn;++i) if(Rank[i]!=Rank[i-1]) Rank[++I]=Rank[i];
Rn=I;
}
int GetRank(int x){
int L=1,R=Rn;//[L,R] first >=x
while(L^R){
int M=(L+R)>>1;
if(Rank[M]<x) L=M+1;
else R=M;
}
return L;
}
//Line Information
struct Window{
int A,B,C;//[A,B)--C
Window(){}
Window(int A,int B,int C):A(A),B(B),C(C){}
}W[maxn];int Wn;
struct Ad{
int L,R;//[L,R)
Ad(){}
Ad(int L,int R):L(L),R(R){}
}A[maxn];int An;
//SweepLine
struct SweepLine{
int X,ID;
bool TYPE,IN;//type1=Ad type0=Window
SweepLine(){}
SweepLine(int X,int ID,int TYPE,int IN):X(X),ID(ID),TYPE(TYPE),IN(IN){}
bool operator <(const SweepLine &B)const{return X < B.X || X==B.X && TYPE < B.TYPE;}
}Line[maxn<<2];int Ln;
int n,m;
int main(void)
{
while(~scanf("%d%d",&n,&m)){
Ln=Rn=An=Wn=0;
for(int i=1;i<=n;++i){
int l,r;scanf("%d%d",&l,&r);
Rank[++Rn]=l;
Rank[++Rn]=r;
A[++An]=Ad(l,r);
}
for(int i=1;i<=m;++i){
int a,b,c;scanf("%d%d%d",&a,&b,&c);
Rank[++Rn]=a;
Rank[++Rn]=b;
W[++Wn]=Window(a,b,c);
}
//离散化
SortRank();
//扫描线
for(int i=1;i<=n;++i){
Line[Ln++]=SweepLine(GetRank(A[i].L),i,1,1);
Line[Ln++]=SweepLine(GetRank(A[i].R),i,1,0);
}
for(int i=1;i<=m;++i){
Line[Ln++]=SweepLine(GetRank(W[i].A),i,0,1);
Line[Ln++]=SweepLine(GetRank(W[i].B),i,0,0);
}
sort(Line,Line+Ln);
L[0]=R[0]=S[0]=IP=TA=TB=0;//SBT初始化
Build(Rn);//线段树初始化
LL ANS=0;int I=0,AID,WID;
for(int i=1;i<=Rn;++i){
while(I < Ln && Line[I].X == i){
if(Line[I].TYPE){//更新
if(Line[I].IN){//L操作
Insert(TB,Node(A[Line[I].ID].L,Line[I].ID));
Insert(TA,Node(A[Line[I].ID].R,Line[I].ID));
}
else{//R操作
Delete(TB,Node(A[Line[I].ID].L,Line[I].ID));
Delete(TA,Node(A[Line[I].ID].R,Line[I].ID));
Update(GetRank(A[Line[I].ID].L),Node(A[Line[I].ID].R-A[Line[I].ID].L,Line[I].ID));
}
}
else{//计算
if(Line[I].IN){//A操作
int rt=Max(TA);
if(rt){
LL D=((LL) W[Line[I].ID].C)*(min(W[Line[I].ID].B,K[rt].V)-W[Line[I].ID].A);
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=K[rt].ID;
}
}

}
else{//B操作
int rt=Min(TB);
if(rt){
LL D=((LL) W[Line[I].ID].C)*(W[Line[I].ID].B-max(W[Line[I].ID].A,K[rt].V));
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=K[rt].ID;
}
}

Node X=Query(GetRank(W[Line[I].ID].A),GetRank(W[Line[I].ID].B));
if(X.V){
LL D=((LL) W[Line[I].ID].C)*X.V;
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=X.ID;
}
}
}
}
++I;
}
}
printf("%I64d\n",ANS);
if(ANS) printf("%d %d\n",AID,WID);
}
return 0;
}


另一份代码：（561ms   41500KB）
/*
561 ms 41500 KB
*/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define out(i) <<#i<<"="<<(i)<<" "
#define OUT1(a1) cout out(a1) <<endl
#define OUT2(a1,a2) cout out(a1) out(a2) <<endl
#define OUT3(a1,a2,a3) cout out(a1) out(a2) out(a3)<<endl
#define maxn 200007
#define LL long long
using namespace std;
//非递归线段树 -- 单点修改，维护区间最大值
//Segment Tree
struct Node{
int V,ID;
Node():V(0),ID(0){}
Node(int V,int ID):V(V),ID(ID){}
bool operator <(const Node &B)const{return V < B.V || V==B.V && ID < B.ID;}
bool operator ==(const Node &B)const{return V==B.V&&ID==B.ID;}
}ST[maxn<<4];
int N;
void Build(int n){
N=1;while(N < n+2) N <<= 1;
int I=N <<1;
Node X=Node(0,0);
for(int i=0;i<I;++i) ST[i]=X;
}
void Update(int L,Node X){//点更新
for(int s=N+L;s;s>>=1){
if(ST[s]<X) ST[s]=X;
else break;
}
}
Node Query(int L,int R){//查询区间最大值
Node ANS;
for(int s=N+L-1,t=N+R+1;s^t^1;s>>=1,t>>=1){
if(~s&1&&ANS < ST[s^1]) ANS=ST[s^1];
if( t&1&&ANS < ST[t^1]) ANS=ST[t^1];
}
return ANS;
}
//离散化
int Rank[maxn<<2],Rn;
void SortRank(){
int I=1;
sort(Rank+1,Rank+Rn+1);
for(int i=2;i<=Rn;++i) if(Rank[i]!=Rank[i-1]) Rank[++I]=Rank[i];
Rn=I;
}
int GetRank(int x){
int L=1,R=Rn;//[L,R] first >=x
while(L^R){
int M=(L+R)>>1;
if(Rank[M]<x) L=M+1;
else R=M;
}
return L;
}
//Information
struct Window{
int A,B,C;//[A,B)--C
Window(){}
Window(int A,int B,int C):A(A),B(B),C(C){}
}W[maxn];int Wn;
struct Ad{
int L,R;//[L,R)
Ad(){}
Ad(int L,int R):L(L),R(R){}
}A[maxn];int An;
//SweepLine
struct SweepLine{
int X,ID;
bool TYPE,IN;//type1=Ad type0=Window
SweepLine(){}
SweepLine(int X,int ID,int TYPE,int IN):X(X),ID(ID),TYPE(TYPE),IN(IN){}
bool operator <(const SweepLine &B)const{return X < B.X || X==B.X && TYPE < B.TYPE;}
}Line[maxn<<2];int Ln;
int n,m;
int main(void)
{
while(~scanf("%d%d",&n,&m)){
Ln=Rn=An=Wn=0;
for(int i=1;i<=n;++i){
int l,r;scanf("%d%d",&l,&r);
Rank[++Rn]=l;
Rank[++Rn]=r;
A[++An]=Ad(l,r);
}
for(int i=1;i<=m;++i){
int a,b,c;scanf("%d%d%d",&a,&b,&c);
Rank[++Rn]=a;
Rank[++Rn]=b;
W[++Wn]=Window(a,b,c);
}
//离散化
SortRank();
//扫描线
for(int i=1;i<=n;++i){
Line[Ln++]=SweepLine(GetRank(A[i].L),i,1,1);
Line[Ln++]=SweepLine(GetRank(A[i].R),i,1,0);
}
for(int i=1;i<=m;++i){
Line[Ln++]=SweepLine(GetRank(W[i].A),i,0,1);
Line[Ln++]=SweepLine(GetRank(W[i].B),i,0,0);
}
sort(Line,Line+Ln);

Build(Rn);//线段树初始化
LL ANS=0;int I=0,AID,WID;
int RM=0,RID=0;
for(int i=1;i<=Rn;++i){//第一次扫描线，从左到右，计算第一，二类情况
if(Rank[i]>RM) RM=Rank[i],RID=0;
while(I < Ln && Line[I].X == i){
if(Line[I].TYPE){//更新
if(Line[I].IN){//L操作
if(A[Line[I].ID].R>RM) RM=A[Line[I].ID].R,RID=Line[I].ID;
}
else{//R操作
Update(GetRank(A[Line[I].ID].L),Node(A[Line[I].ID].R-A[Line[I].ID].L,Line[I].ID));
}
}
else{//计算
if(Line[I].IN){//A操作
if(RID){
LL D=((LL) W[Line[I].ID].C)*(min(RM,W[Line[I].ID].B)-W[Line[I].ID].A);
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=RID;
}
}
}
else{//B操作
Node X=Query(GetRank(W[Line[I].ID].A),GetRank(W[Line[I].ID].B));
if(X.V){
LL D=((LL) W[Line[I].ID].C)*X.V;
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=X.ID;
}
}
}
}
++I;
}
}
I=Ln-1;int LM=Rank[Rn],LID=0;
for(int i=Rn;i>=1;--i){//第二次扫描线，从右往左，计算第三类情况
if(Rank[i]<LM) LM=Rank[i],LID=0;
while(I>=0 && Line[I].X == i){
if(Line[I].TYPE){//更新
if(!Line[I].IN) {//R操作
if(A[Line[I].ID].L <LM) LM=A[Line[I].ID].L,LID=Line[I].ID;
}
}
else{//计算
if(!Line[I].IN){//B操作
if(LID){
LL D=((LL) W[Line[I].ID].C)*(W[Line[I].ID].B-max(W[Line[I].ID].A,LM));
if(D > ANS){
ANS=D;
WID=Line[I].ID;
AID=LID;
}
}
}
}
--I;
}
}
printf("%I64d\n",ANS);
if(ANS) printf("%d %d\n",AID,WID);
}
return 0;
}


将所有线段都加入扫描线，每条线段都出现两次：一次入边， 一次出边。

以下就用L,R代表无权值线段的入边，出边。用A,B代表有权值线段的入边，出边。

扫描线的过程，就是将所有的A,B,L,R排序，然后从小到大扫描一遍。

那么，整个过程实际上，就是在A,B,L,R这四个端点各需要进行什么操作的问题。