安全 解题报告

安全

看完题，好，先打一个枚举删边的暴力dp，然后发现不会优化。然后忽然发了大样例，发现挂了，再读一下题，发现删个

的边啊，最开始又不知道...
考虑到一个安全的放置一定得有4个边，像这样

发现内侧边可以和别的外侧边公用之类的，考虑把这个当做状态进行dp

先做一个\(y\)轴的扫描线，把这样的四元组\((l_2,l_1,r_1,r_2)\)(从左至右)状态都找出来。

可以发现，每次加入一条线的时候，至多产生4个这样的4元组，那么四元组的状态不会超过\(4n\)

考虑\(dp_i\)表示\(i\)号四元组做最左边的坦克时的最大答案，那么有转移
\[ dp_i=\max_j\{dp_j|l_1(j)\ge r_2(i)\land l_2(j)\ge r_1(i)\}+1 \]
对后面的限制条件，一维排序，一维在树状数组里面维护一下就可以了

---

Code:

#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#include <set>
#include <queue>
const int N=1e6+5;
using std::max;
template <class T>
void read(T &x)
{
    x=0;char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=x*10+c-'0',c=getchar();
}
struct koito_yuu
{
    int x,l,r;
}yuu[N];
int dx[N],dy[N],n,m,k,dp[N<<1];
struct BEE
{
    int op,x,p;
    BEE(){}
    BEE(int Op,int X,int P){op=Op,x=X,p=P;}
    bool friend operator <(BEE a,BEE b){return a.p==b.p?a.op>b.op:a.p<b.p;}
}bee[N];
std::set <int> s;
std::set <int>::iterator it;
struct node
{
    int l2,l1,r1,r2;
    node(){}
    node(int L2,int L1,int R1,int R2){l2=L2,l1=L1,r1=R1,r2=R2;}
    bool friend operator <(node a,node b){return a.r2>b.r2;}
}yuy[N<<1];
struct mea
{
    int l1,id;
    mea(){}
    mea(int L1,int Id){l1=L1,id=Id;}
    bool friend operator <(mea a,mea b){return a.l1<b.l1;}
};
std::priority_queue <mea> q;
int mx[N<<1];
void ins(int x,int d)
{
    while(x<=k) mx[x]=max(mx[x],d),x+=x&-x;
}
int qry(int x)
{
    int ret=0;
    while(x) ret=max(ret,mx[x]),x-=x&-x;
    return ret;
}
int main()
{
    freopen("safe.in","r",stdin);
    freopen("safe.out","w",stdout);
    read(n);
    dx[++dx[0]]=-1,dx[++dx[0]]=1e9+1;
    dx[++dx[0]]=-2,dx[++dx[0]]=1e9+2;
    for(int i=1;i<=n;i++)
    {
        read(yuu[i].x),read(yuu[i].l),read(yuu[i].r);
        dx[++dx[0]]=yuu[i].x;
        dy[++dy[0]]=yuu[i].l;
        dy[++dy[0]]=yuu[i].r;
    }
    std::sort(dx+1,dx+1+dx[0]);
    dx[0]=std::unique(dx+1,dx+1+dx[0])-dx-1;
    std::sort(dy+1,dy+1+dy[0]);
    dy[0]=std::unique(dy+1,dy+1+dy[0])-dy-1;
    for(int i=1;i<=n;i++)
    {
        yuu[i].x=std::lower_bound(dx+1,dx+1+dx[0],yuu[i].x)-dx;
        yuu[i].l=std::lower_bound(dy+1,dy+1+dy[0],yuu[i].l)-dy;
        yuu[i].r=std::lower_bound(dy+1,dy+1+dy[0],yuu[i].r)-dy;
        bee[++m]=BEE(1,yuu[i].x,yuu[i].l);
        bee[++m]=BEE(0,yuu[i].x,yuu[i].r);
    }
    std::sort(bee+1,bee+1+m);
    s.insert(1),s.insert(dx[0]);
    s.insert(2),s.insert(dx[0]-1);
    for(int i=1;i<=m;i++)
    {
        if(bee[i].op)//add
        {
            int p1,p2,p3,p4,p5,p6;
            p1=p2=p3=p4=p5=p6=0;
            it=s.lower_bound(bee[i].x);
            p4=*it;
            it++;
            p5=*it;
            it++;
            if(it!=s.end()) p6=*it;
            it=s.lower_bound(bee[i].x);
            it--;
            p3=*it;
            it--;
            p2=*it;
            if(it!=s.begin()) --it,p1=*it;
            if(p1) yuy[++k]=node(p1,p2,p3,bee[i].x);
            yuy[++k]=node(p2,p3,bee[i].x,p4);
            yuy[++k]=node(p3,bee[i].x,p4,p5);
            if(p6) yuy[++k]=node(bee[i].x,p4,p5,p6);
            s.insert(bee[i].x);
        }
        else s.erase(bee[i].x);
    }
    std::sort(yuy+1,yuy+1+k);//按r2排列
    int ans=1;
    for(int i=1;i<=k;i++)
    {
        while(!q.empty()&&yuy[i].r2<=q.top().l1)
        {
            int id=q.top().id;
            q.pop();
            int p=dx[0]+1-yuy[id].l2;
            ins(p,dp[id]);
        }
        dp[i]=qry(dx[0]+1-yuy[i].r1)+1;
        ans=max(ans,dp[i]);
        q.push(mea(yuy[i].l1,i));
    }
    printf("%d\n",ans);
    return 0;
}

---

2019.3.24

转载于:https://www.cnblogs.com/butterflydew/p/10588960.html