[USACO19FEB]Mowing Mischief

题目大意：

给定平面上的一些点，求这些点的一个\(LIS\)，并且还需要满足下列式子最小：

\[\sum_{i=1}^{n-1}(a[i+1].x-a[i].x)*(a[i+1].y-a[i].y)
\]

题解：

比较巧妙的一道题。

首先我们需要找出一个性质，我们先令\(dp[i]\)表示以\(i\)点结尾的\(LIS\),然后这些\(LIS\)相同的点在平面上是横坐标递增，纵坐标递减的，下面我们说的转移点的顺序都是按照这个顺序来的。

然后我们在观察转移，我们令两个转移点\(j\)和\(k\),若\(k\)比\(j\)更优，那么有：

\[dp[k]+(a[i].x-a[k].x)*(a[i].y-a[k].y)\geq dp[j]+(a[i].x-a[j].x)*(a[i].y-a[j].y)
\]

\[a[i].x*(a[j].y-a[k].y)+a[i].y*(a[j].x-a[k].x)\geq dp[j]-dp[k]+a[j].x*a[j].y-a[k].x*a[k].y
\]

\[A*a[i].x+B*a[i].y\geq C
\]

可以看出，这其实是一个半平面,结合上面的性质，对于一排待转移点，更优的转移是一段前缀或者一段后缀，这启发我们这道题中有决策单调性。

但是这个东西还有一个条件就是\(a[i].x\geq a[j].x\ \ a[i].y\geq a[j].y\)，这个东西其实我们发现合法的转移点也是一段连续的区间，这启发我们在外面线段树分治解决这个限制。

对于决策单调性的部分，我们可以令\(k\)是\(j\)的后面一个点，那么上面的\(A\)是负的\(B\)是正的，所以合法的区域在直线上方，按照这个做决策单调性就好了。

代码

#include<bits/stdc++.h>
#define M 1000009
#define N 200009
using namespace std;
typedef long long ll;
vector<int>vec[N],now;
vector<int>::iterator it;
int n,T,dp[N];
ll f[N],ans;
inline ll rd(){
	ll x=0;char c=getchar();bool f=0;
	while(!isdigit(c)){if(c=='-')f=1;c=getchar();}
	while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
	return f?-x:x;
}
struct BIT{
	int tr[M];
	inline void add(int x,int y){
		while(x<=T)tr[x]=max(tr[x],y),x+=x&-x;
	}
	inline int query(int x){
	    int ans=0;
	    while(x)ans=max(ans,tr[x]),x-=x&-x;
	    return ans;
	}
}T1;
struct point{
	int x,y;
	inline bool operator <(const point &b)const{
		if(x!=b.x)return x<b.x;
		else return y<b.y;
	}
}a[N];
struct seg{
	#define ls tr[cnt].l
	#define rs tr[cnt].r
	int rot,tott;
	struct node{
		int l,r;
		vector<int>nw;
    }tr[N<<1];
    void build(int &cnt,int l,int r){
    	cnt=++tott;tr[cnt].l=tr[cnt].r=0;
    	tr[cnt].nw.clear();
    	if(l==r)return;
    	int mid=(l+r)>>1;
    	build(ls,l,mid);build(rs,mid+1,r);
	}
    inline void init(){
    	tott=0;
    	build(rot,0,now.size()-1);
	}
	inline void upd(int cnt,int l,int r,int id){
		if(a[id].x>=a[now[r]].x&&a[id].y>=a[now[l]].y){
			tr[cnt].nw.push_back(id);
			return;
		}
		if(a[id].x<a[now[l]].x||a[id].y<a[now[r]].y)return;
		if(l==r)return;
		int mid=(l+r)>>1;
		upd(ls,l,mid,id);upd(rs,mid+1,r,id);
	}
	inline void _upd(int tag,int l,int r,int L,int R){
		if(l>r)return;
		int no=tr[tag].nw[(l+r)>>1];
		ll biu=1e18,tg=0;
		for(int i=L;i<=R;++i){
			int id=now[i];
			ll x=f[id]+1ll*(a[no].x-a[id].x)*(a[no].y-a[id].y);
			if(x<biu){
				biu=x;
				tg=i;
			}
		}
		f[no]=min(f[no],biu);
		int mid=(l+r)>>1;
		_upd(tag,l,mid-1,tg,R);
		_upd(tag,mid+1,r,L,tg);
	}
	inline void work(int id){
		upd(rot,0,now.size()-1,id);
	}
	void solve(int cnt,int l,int r){
		_upd(cnt,0,tr[cnt].nw.size()-1,l,r);
		if(l==r)return;
		int mid=(l+r)>>1;
		solve(ls,l,mid);solve(rs,mid+1,r);
	}
	inline void solve(){
		solve(rot,0,now.size()-1);
	}
	#undef ls
	#undef rs
}T2;
int main(){
	n=rd();T=rd();
	for(int i=1;i<=n;++i){
		a[i].x=rd();a[i].y=rd();
	}
	sort(a+1,a+n+1);
	int maxx=0;
	for(int i=1;i<=n;++i){
		dp[i]=T1.query(a[i].y)+1;
		T1.add(a[i].y,dp[i]);
		vec[dp[i]].push_back(i);
		maxx=max(maxx,dp[i]);
	}
	memset(f,0x3f,sizeof(f));
	for(it=vec[1].begin();it!=vec[1].end();++it){
		int x=*it;
		f[x]=1ll*a[x].x*a[x].y;
	}
	for(int i=2;i<=maxx;++i){
		now=vec[i-1];
		T2.init();
		for(it=vec[i].begin();it!=vec[i].end();++it){
			int x=*it;
			T2.work(x);
		}
		T2.solve();
	}
	ans=1e18;
	for(it=vec[maxx].begin();it!=vec[maxx].end();++it){
		int x=*it;
		ans=min(ans,f[x]+1ll*(T-a[x].x)*(T-a[x].y));
	}
	cout<<ans;
	return 0;
}