codeforces 1285E Delete a Segment(线段树)

传送门

题意：给你n个线段，线段有交点被看做同一线段，问你删除一条线段后形成的新线段的数量最大为多少？

题解：题解是用扫描线写的，看不懂，提供一个线段树的做法，不过常数有点大。首先由于端点范围需要将端点离散化，同时由于线段可以是一个点，所以需要在相邻俩点拆一个点作为边，那么将所有线段加入后，你如果选择将一条线段删除，那么这条线段造成的影响就是它覆盖的区间中只被它有条线段覆盖的段数合，因为只有当前线段包含了的段，所以如果两边是连接的，那么删除这条线段，这段位置就会空出，答案就会加一。用线段树维护区间中只被覆盖了一次的段数，同时记录一下增加的点（代表边）是否被覆盖（判断当前的为一的段1是不是合法的，位于两端时，如果两端外的那条边的线段没有连接，那么对于的连续一是不会导致增加答案的，可以画个图体会一下）。

代码：

#include<stdio.h>
#include<vector>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<math.h>
#include<queue>
#include<set>
#include<map>
#include<stack>
#define ll long long
#define mid ((l+r)>>1)
#define lk (k<<1)
#define rk (k<<1)+1
using namespace std;
int read(){
    char c;int x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
        x=x*10+c-'0';return x*y;
}
const int maxn=4e5+10;
const int inf=1e9+7;
struct node{
    int li,ri;
};
node di[maxn];
int bi[maxn*2],num[maxn*8],lazy[maxn*8],nk;
bool ls[maxn*8],rs[maxn*8],judge,jl,jr,ju[maxn*2];
bool cmp(node a,node b){
    if(a.li==b.li) return a.ri<b.ri;
    return a.li<b.li;
}
void build(int l,int r,int k){
    num[k]=lazy[k]=0;
    ls[k]=rs[k]=0;
    if(l==r) return ;
    build(l,mid,lk),build(mid+1,r,rk);
}
void modify(int l,int r,int l1,int r1,int k){
    if(l>=l1&&r<=r1){
        lazy[k]++;
        return ;
    }
    if(lazy[k]!=0){
        lazy[lk]+=lazy[k];
        lazy[rk]+=lazy[k];
        lazy[k]=0;
    }
    if(mid>=l1) modify(l,mid,l1,r1,lk);
    if(mid+1<=r1) modify(mid+1,r,l1,r1,rk);
}
void work(int l,int r,int k){
     if(l==r){
        if(lazy[k]<=1){
            num[k]=1;
            ls[k]=rs[k]=ju[l]=true;
        }
        return ;
    }
    if(lazy[k]!=0){
        lazy[lk]+=lazy[k];
        lazy[rk]+=lazy[k];
        lazy[k]=0;
    }
    work(l,mid,lk),work(mid+1,r,rk);
    num[k]=num[lk]+num[rk];
    ls[k]=ls[lk],rs[k]=rs[rk];
    if(rs[lk]&&ls[rk]) num[k]--;
}
int query(int l,int r,int l1,int r1,int k){
    if(l>=l1&&r<=r1){
        int va=0;
        if(judge&&ls[k]) va--;
        judge=rs[k];
        if(l==l1) jl=ls[k];
        if(r==r1) jr=rs[k];
        return num[k]+va;
    }
    if(mid>=r1) return query(l,mid,l1,r1,lk);
    else if(mid+1<=l1) return query(mid+1,r,l1,r1,rk);
    else return query(l,mid,l1,r1,lk)+query(mid+1,r,l1,r1,rk);
}
int main( ){
    int t=read();
    ju[0]=true;
    while(t--){
        int n=read();
        for(int a=1;a<=n;a++) di[a].li=bi[a]=read(),di[a].ri=bi[n+a]=read();
        sort(bi+1,bi+n*2+1);
        nk=unique(bi+1,bi+2*n+1)-bi-1;
        for(int a=1;a<=n;a++){
            di[a].li=lower_bound(bi+1,bi+nk+1,di[a].li)-bi;
            di[a].li+=(di[a].li-1);
            di[a].ri=lower_bound(bi+1,bi+nk+1,di[a].ri)-bi;
            di[a].ri+=(di[a].ri-1);
        }
        nk=2*nk-1;
        for(int a=1;a<=nk;a++) ju[a]=false;ju[nk+1]=true;
        build(1,nk,1);
        sort(di+1,di+n+1,cmp);
        int r=0,las=0;
        for(int a=1;a<=n;a++){
            if(di[a].li>r) las++;
            r=max(r,di[a].ri);
            modify(1,nk,di[a].li,di[a].ri,1);
        }
        work(1,nk,1);
        int ans=0;
        for(int a=1;a<=n;a++){
            judge=jl=jr=false;
            int va=query(1,nk,di[a].li,di[a].ri,1);
            if(jl&&ju[di[a].li-1]) va--;
            if(jr&&ju[di[a].ri+1]) va--;
            ans=max(ans,las+va);
        }
        printf("%d\n",ans);
    }
}