USACO 2019 February Contest Platinum T3: Mowing Mischief

题目大意

Bessie的表妹Ella和Bella正在参观农场。不幸的是，自从他们到达以来，他们一直在恶作剧。

在他们的最新计划中，他们决定尽可能多地割草。农场的草地是 T×T 的正方形。左下角是 (0,0) ，右上角是 (T,T) 。因此，正方形包含 (T+1)² 个格点（具有整数坐标的点）。

Ella和Bella计划从 (0,0) 开始并以每秒一个单位长度的速度运行到 (T,T) ，同时每只奶牛都握住非常锋利且非常有弹性的线的一端。任何被这根电线扫过的区域的草都会被切断。Ella和Bella可能采取不同的路径，但她们只会向上或者向右移动，从一个格点移动到另一个格点。

Bessie非常担心会切割太多的草，所以她发明了一个聪明的计划来限制Ella和Bella的路径。在整个草原上散布着 N 种花（1≤N≤2e5），每种花都在一个特定的格点上。 Bessie将从这些花中挑选一个子集 S ， S 集合中的花Ella和Bella都需要经过（Ella和Bella的路径都必须经过 S 中的所有花朵）。

Ella和Bella将会切割面积尽可能大的草，请帮助Bessie确定集合 SS 使得在 SS集合尽可能大的情况下被切割的草的面积最小。

题目分析

经过思考，我们发现骑士拉着线扫对Ella和Bella来说最优的情况就是划出一个矩形。

所以，问题变成了在 N 个点中选择某些点，排序后一一构成矩形（相邻的点），求构成的这些矩形的最小面积和。

将所有点按照其横坐标为第一关键字，纵坐标为第二关键字排序，靠前的点无法转移到靠后的点。用树状数组进行动态规划，我们可以得到以每个点为结尾的选取序列的最优长度。（相当于求以每个点结尾的LIS）并根据LIS的大小对点进行分层。

可以得出属于同一层的点横坐标递增，纵坐标递减。

接下来，我们只需要考虑层与层之间的转移。（本层点的LIS一定是由上一层点的LIS转移过来的）

转移方程如下：

dp_i​ =Min_j （j为上一层点 且 x_j​≤x_i​, y_j​≤y_i）​ ​{dp_j ​+ (x_i​−x_j​) ∗ (y_i​−y_j​) } 

把后一项拆开，得：

dp_i​ =Min_j （j为上一层点 且 x_j​≤x_i​, y_j​≤y_i）​ ​{dp_j ​+ x_j​y_j​ − x_i​y_j ​− x_j​y_i​ } +x_iy_i

考虑 j,k 两处转移，令 j的转移 优于 k  ，则

dp_j​ + x_j​y_j​ − x_i​y_j ​− x_j​y_i​  ≤ dp_k​ + x_k​y_k​ − x_i​y_k​ − x_k​y_i​

(y_k​−y_j​) x_i​+(x_k​−x_j​)y_i​ ≤ dp_k​ + x_k​y_k​−dp_j​−x_j​y_j​

注意到 y_k​−y_j​和 x_k​−x_j​必然一正一负，因此这个半平面一定会将下一层的点分为前后两部分，因而若排除掉 xj​≤xi​,yj​≤yi​的限制，该 DP 的转移具有决策单调性。

那么，先用线段树分治处理转移，再用决策单调性优化转移即可。

时间复杂度  O(N log²N)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=3e5+10;
const int MAXT=1e6+10;
const ll Inf=1e18+7;
struct Node{
    int x,y;
}p[MAXN];
inline bool cmpx(Node a,Node b){return a.x==b.x?a.y<b.y:a.x<b.x;}

int T,n,m,s;
int layer[MAXN];
ll dp[MAXN];
int BIT[MAXT];
vector<int> pos[MAXN];
inline int lowbit(int x){return x&(-x);}
inline void Modify(int x,int v){for(int i=x;i<=T;i+=lowbit(i)) BIT[i]=max(BIT[i],v);}
inline int Query(int x){int res=0;for(int i=x;i;i-=lowbit(i))res=max(res,BIT[i]);return res;}

struct Segment_Tree{
    struct Node{
        int ls,rs;
        vector<int> trans;
    }a[MAXN<<1];
    
    int n,size,rt;
    vector<int> point,tmp;
    
    inline void Build(int &rt,int l,int r){
        rt=++size;
        a[rt].ls=a[rt].rs=0;
        a[rt].trans.clear();
        if(l==r) return;
        int mid=(l+r)>>1;
        Build(a[rt].ls,l,mid);
        Build(a[rt].rs,mid+1,r);
    }
    inline void Init(vector<int> tmp){
        point=tmp;
        n=tmp.size();
        rt=size=0;
        Build(rt,0,n-1);
    }
    inline void Modify(int rt,int l,int r,int x){
        if(p[x].x>=p[point[r]].x&&p[x].y>=p[point[l]].y){
            a[rt].trans.push_back(x);
            return;
        }
        if(p[x].x<=p[point[l]].x||p[x].y<=p[point[r]].y) return;
        int mid=(l+r)>>1;
        Modify(a[rt].ls,l,mid,x);
        Modify(a[rt].rs,mid+1,r,x);
    }
    inline void modify(int x){
        Modify(rt,0,n-1,x);
    }
    
    inline void Solve(int l,int r,int ql,int qr){
        ll ans=Inf;int from=0;
        int mid=(l+r)>>1,now=tmp[mid];
        for(int i=ql;i<=qr;++i){
            int pos=point[i];
            ll res=dp[pos]+1ll*(p[now].x-p[pos].x)*(p[now].y-p[pos].y);
            if(res<ans){
                ans=res;
                from=i;
            }
        }
        dp[now]=min(dp[now],ans);
        if(l<mid) Solve(l,mid-1,from,qr);
        if(mid<r) Solve(mid+1,r,ql,from);
    }
    inline void Work(int rt,int l,int r){
        if(a[rt].trans.size()){
            tmp=a[rt].trans;
            Solve(0,tmp.size()-1,l,r);
        }
        if(l==r) return;
        int mid=(l+r)>>1;
        Work(a[rt].ls,l,mid);
        Work(a[rt].rs,mid+1,r);
    }
    inline void work(){
        Work(rt,0,n-1);
    }
}ST;
int main(){
    scanf("%d%d",&n,&T);
    for(int i=1;i<=n;++i)
        scanf("%d%d",&p[i].x,&p[i].y);
    sort(p+1,p+n+1,cmpx);
    
    for(int i=1;i<=n;++i){
        layer[i]=Query(p[i].y)+1;
        Modify(p[i].y,layer[i]);
        pos[layer[i]].push_back(i);
        m=max(m,layer[i]);
        //cout<<layer[i]<<' ';
    }
    //cout<<111<<endl;
    for(int i=0,now;i<(int)pos[1].size();++i){
        now=pos[1][i];
        dp[now]=1ll*p[now].x*p[now].y;
    }
    for(int i=2,now;i<=m;++i){
        ST.Init(pos[i-1]);
        for(int j=0;j<(int)pos[i].size();++j){
            now=pos[i][j];
            dp[now]=Inf;
            ST.modify(now);
        }
        ST.work();
    }
    ll ans=Inf;
    //cout<<111<<endl;
    for(int i=0;i<(int)pos[m].size();++i){
        int now=pos[m][i];
        ans=min(ans,dp[now]+1ll*(T-p[now].x)*(T-p[now].y));
    }
    printf("%lld
",ans);
    return 0;
}