【xsy3423】党² 线段树+李超线段树or动态半平面交

本来并不打算出原创题的，此题集CF542A和sk的灵感而成，算个半原创吧。

 

题目大意：

给定有$n$个元素的集合$P$，其中第$i$个元素中包含$L_i,R_i,V_i$三个值。

给定另一个有$n$个元素的集合$Q$，其中第$i$个元素包含$A_i,B_i,C_i$三个值。

选择集合$P$中第$x$个元素和集合$Q$中第$y$个元素的收益为$(r-l+1)*V_x*C_y$，其中$[l,r]$为$[L_i,R_i]$和$[A_i,B_i]$的交集。你需要在集合$P$，$Q$中分别选出一个元素，使得收益最大

 

数据范围：

子任务一：满足$n≤5000$

子任务二：满足$V_i=1$。

子任务三：满足$L_i=A_i=1$。

子任务四：满足$n≤10^5$

对于全部数据，所有数$≤10^5$，且$L_i≤R_i,A_i≤B_i$。

 

子任务一：暴力

 

子任务二：该子任务为CF542A：

这里有一个题解，看情况三和情况四就行了

 

子任务三：

不难发现该情况下，对于任意的$i,j$必有$L_i≤A_j,B_j≤R_i$，或者$A_j≤L_i,R_i≤B_j$。

我们把$P$和$Q$中所有元素都丢入一个数组中按右端点排序，同时我们种一棵线段树。

若当前元素原先在$P$中，我们用$(R_i-L_i+1)\times V_i$更新第$L_i$个位置的值（取max）

否则，我们查询区间$[A_i,B_i]$中的最大值，将该值乘上$C_i$后更新答案。

不难发现此方法可以处理所有$Q_i$包含$P_j$的情况。

对于$P_i$包含$Q_j$的情况，我们交换下两个集合再处理一次就好了。

 

 

子任务四：

首先要处理一下$P_i$包含$Q_i$或者$Q_i$包含$P_i$的情况，直接用子任务三的方式处理一下就行了。

 

我们将$P$中第$i$个元素看成一个定义域在$[L_i,R_i]$间的函数，我们把这个函数写作$F_i(x)$。

不难发现$F_i(x)=V_ix-(L_i-1)\times V_i$。

为了方便接下来的表述，我们将$F_i(x)$更改为如下形式：

$F_i(x)=\begin{cases} V_ix-(L_i-1)\times V_i \ \ \ x\in[L_i,R_i] \\ 0\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ x\notin[L_i,R_i]\end{cases}$

这是个分段函数

 

我们在$Q$中找出第y个元素$Q_y$，若存在$i$满足$A_y≤L_i$，则$Q_y$与$P_i$产生的收益为$C_y\times F_i(B_y)$。

最终答案显然为$max(C_y\times F_i(B_y))$。

 

按照子任务三的套路，我们把$P$和$Q$中所有元素都丢入一个数组中按左端点排序，维护一个保存函数的集合$S$

定义$S(x)=max_{F∈S}F(x)$

我们从大到小从数组中取出元素

若当前元素原先在$P$中，我们求出该元素对应的函数，并把它丢入$S$中。

否则，我们用$C_i\times S(B_i)$更新答案。

该做法复杂度显然是$O(nT_s)$，其中$T_s$表示求$S(x)$的复杂度。

 

我们不难想到$T_s=O(n)$的做法，但是不够优美。

我们考虑种一棵线段树，线段树的每个节点分别维护一个支持插入函数的半平面交。

如果我们要加入一个定义域在$[l,r]$的一次函数$f(x)$，就在线段树对应的区间上插入这个函数即可。

对于$S(x)$操作，我们只需要找出所有包含$x$的区间，在这些区间上的半平面交上求值即可。

单次插入的复杂度均摊为$O(log^2\ n)$ 单次查询的复杂度为$O(log^2\ n)$。

 

然而该方法只能处理出$Q_i$在$P_j$左边的情况。$Q_i$在$P_j$右边的情况我们交换一下两个集合再跑一遍就行了。

 

所以这是一道扫描线+线段树维护动态半平面的题目

总复杂度就是$O(n\ log^2\  n)$，空间复杂度$O(n\ log\ n)$。

完结撒花

 

#include<bits/stdc++.h>
#define M 100010
#define L long long
#define mid ((aa[x].l+aa[x].r)>>1)
#define S set<line>::iterator
using namespace std;

int n,N=0,up=0; L ans=0;
struct lr{
    int l,r,val;
    void rd(){scanf("%d%d%d",&l,&r,&val); up=max(up,r);}
}a[M],b[M];
void swapAB(){for(int i=1;i<=n;i++) swap(a[i],b[i]);}
struct ask{
    int id,isa; ask(){id=isa=0;}
    ask(int ID,int ISa){id=ID; isa=ISa;}
    friend bool operator <(ask A,ask B){
        int vala=A.isa?a[A.id].l:b[A.id].l;
        int valb=B.isa?a[B.id].l:b[B.id].l;
        if(vala!=valb) return vala<valb;
        return A.isa>B.isa;
    }
}p[M*2];

namespace SolveContains{
    struct seg{int l,r;L maxn;}aa[1<<18];
    void build(int x,int l,int r){
        aa[x].l=l; aa[x].r=r; aa[x].maxn=0; if(l==r) return;
        build(x<<1,l,mid); build(x<<1|1,mid+1,r);
    }
    void updata(int x,int k,L val){
        aa[x].maxn=max(aa[x].maxn,val); 
        if(aa[x].l==aa[x].r) return;
        if(k<=mid) updata(x<<1,k,val); 
        else updata(x<<1|1,k,val);
    }
    L query(int x,int l,int r){
        if(l<=aa[x].l&&aa[x].r<=r) return aa[x].maxn;
        L res=0;
        if(l<=mid) res=max(res,query(x<<1,l,r));
        if(mid<r) res=max(res,query(x<<1|1,l,r));
        return res;
    }
    bool cmp(ask A,ask B){
        int vala=A.isa?a[A.id].r:b[A.id].r;
        int valb=B.isa?a[B.id].r:b[B.id].r;
        if(vala!=valb) return vala<valb;
        return A.isa<B.isa;
    }
    void sub(){
        build(1,1,up);
        N=0; for(int i=1;i<=n;i++) p[++N]=ask(i,1),p[++N]=ask(i,0);
        sort(p+1,p+N+1,cmp);
        for(int i=1;i<=N;i++){
            int id=p[i].id;
            if(p[i].isa){
                L now=query(1,a[id].l,a[id].r);
                ans=max(ans,now*a[id].val);
            }else{
                L val=1LL*b[id].val*(b[id].r-b[id].l+1);
                updata(1,b[id].l,val);
            }
        }
    }
    void solve(){sub();swapAB();sub();swapAB();}
}

void ReadData(){
    cin>>n;
    for(int i=1;i<=n;i++) a[i].rd();
    for(int i=1;i<=n;i++) b[i].rd();
}

struct line{
    L k,b; line(){k=b=0;}
    line(L _k,L _b){b=_b; k=_k;}
    L f(L x){return k*x+b;}
    friend bool operator <(line a,line b){
        if(a.k==b.k) return a.b<b.b;
        return a.k<b.k;
    }
    friend double operator *(line a,line b){
        return 1.*(b.b-a.b)/(a.k-b.k);
    }
};
bool under(line a,line b,line c){
    double x=a*b;
    if(a.f(x)>=c.f(x)) return 1;
    return 0;
}
struct plane{//半平面
    set<line> s;
    map<double,line> mp;
    void clear(){
        s.clear(); mp.clear();
        s.insert(line(0,0));
        mp[-100]=line(0,0);
    }
    L f(int x){
        map<double,line>::iterator it=mp.upper_bound(x); it--;
        line now=it->second;
        return now.f(x);
    }
    void remove(S it){
        S nxt=it,pre=it; nxt++; pre--;
        if(nxt!=s.end()){
            double l=(*it)*(*nxt);
            mp.erase(mp.find(l));
            double x=(*nxt)*(*pre);
            mp[x]=*nxt;
        }
        double r=(*it)*(*pre);
        mp.erase(mp.find(r));
        s.erase(it);
    }
    void insert(line l){
        S nxt=s.upper_bound(l),pre=nxt; pre--;
        if(nxt!=s.end()){
            double x=(*nxt)*(*pre);
            mp.erase(mp.find(x));
            double r=l*(*nxt);
            mp[r]=(*nxt);
        }
        double x=l*(*pre);
        s.insert(l); mp[x]=l;
    }
    void add(line l){
        S it=s.upper_bound(l),nx=it,ls=it,hh; ls--;
        if(it!=s.end()&&under(*it,*ls,l)) return;
        for(nx++;it!=s.end()&&nx!=s.end();it=nx,nx++){
            double x=(*it)*(*nx);
            line now=*it;
            if(now.k==l.k) return;
            if(l.f(x)>=now.f(x)) remove(it);
            else break;
        }
        it=s.upper_bound(l); it--; ls=it;
        for(ls--;it!=s.begin();){
            double x=(*it)*(*ls);
            line now=(*it);
            if(now.k==l.k||l.f(x)>=now.f(x)){
                hh=it; hh--; ls--;
                remove(it);
                it=hh;
            }
            else break;
        }
        insert(l);
    }
};

namespace seg{
    struct hhh{
        int l,r; plane p;
        void insert(line now){return p.add(now);}
        L f(L x){return p.f(x);}
    }aa[1<<18];
    
    void build(int x,int l,int r){
        aa[x].l=l; aa[x].r=r; aa[x].p.clear();
        if(l==r) return;
        build(x<<1,l,mid); build(x<<1|1,mid+1,r);
    }
    void updata(int x,int l,int r,line now){
        if(l<=aa[x].l&&aa[x].r<=r) return aa[x].insert(now);
        if(l<=mid) updata(x<<1,l,r,now);
        if(mid<r) updata(x<<1|1,l,r,now);
    }
    L query(int x,int k){
        L res=aa[x].f(k);
        if(aa[x].l==aa[x].r) return res;
        if(k<=mid) res=max(res,query(x<<1,k));
        else res=max(res,query(x<<1|1,k));
        return res;
    }
}

namespace SolveOthers{
    void sub(){
        seg::build(1,1,up);
        N=0; for(int i=1;i<=n;i++) p[++N]=ask(i,1),p[++N]=ask(i,0);
        sort(p+1,p+N+1);
        for(int i=N;i;i--){
            int id=p[i].id;
            if(p[i].isa){
                L now=seg::query(1,a[id].r);
                ans=max(ans,now*a[id].val);
            }else{
                line hh=line(b[id].val,-1LL*b[id].val*(b[id].l-1));
                seg::updata(1,b[id].l,b[id].r,hh);
            }
        }
    }
    void solve(){sub();swapAB();sub();}
}

main(){
    ReadData();
    SolveContains::solve();
    SolveOthers::solve();
    cout<<ans<<endl;
}