[BZOJ1597]土地购买

Description

农夫John准备扩大他的农场,他正在考虑N (1 <= N <= 50,000) 块长方形的土地. 每块土地的长宽满足(1 <= 宽 <= 1,000,000; 1 <= 长 <= 1,000,000). 每块土地的价格是它的面积,但FJ可以同时购买多快土地. 这些土地的价格是它们最大的长乘以它们最大的宽, 但是土地的长宽不能交换. 如果FJ买一块3×5的地和一块5×3的地,则他需要付5×5=25. FJ希望买下所有的土地,但是他发现分组来买这些土地可以节省经费. 他需要你帮助他找到最小的经费.

Input

* 第1行: 一个数: N

* 第2..N+1行: 第i+1行包含两个数,分别为第i块土地的长和宽

Output

* 第一行: 最小的可行费用.

Sample Input

4
100 1
15 15
20 5
1 100

Sample Output

500

HINT

FJ分3组买这些土地: 第一组:100×1, 第二组1×100, 第三组20×5 和 15×15 plot. 每组的价格分别为100,100,300, 总共500.

题解

斜率优化好像是很久之前的坑?

推式子真是太刺激了.

对于这道题,购买的土地并不是连续的,所以原始数据并不具有决策单调性.

所以我们需要通过某些操作,构造出一个决策单调性.

有一种方法好像是用堆…?我本人是sort了一遍,按照第一关键字长度递增,第二关键字宽度递增.

然后扫一遍,把小块放在大块中一起购买(相当于合并)

这样最后得到的数据就有决策单调性了,因为这时连着买肯定比跳着买要优越

然后我们再手推一下式子

f[i]=f[j]+land[j+1].y*land[i].x

对于某两个决策点j1,j2,如果j1优于j2

f[j1]+land[j1+1].y*land[i].x<f[j2]+land[j2+1].y*land[i].x

f[j1]-f[j2]<land[i].x*(land[j2+1].y-land[j1+1].y)

(f[j1]-f[j2])/(land[j2+1].y-land[j1+1].y)<land[i].x

设k(j1,j2)=(f[j1]-f[j2])/(land[j2+1].y-land[j1+1].y)

那么我们用一个单调队列q[]来维护,

设头为h,尾为t,则q[h+1]比q[h]优时,有k(q[h+1],q[h])<x[i],此时h++

对于插入元素i,如果i比q[t]优,则k(i,q[t])<k(q[t],q[t-1]),此时t–

然后照着打就行了,代码见下

 #include<cstdio>
 #include<queue>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 typedef long long LL;
 const int N=;
 int n,e,q[N],head,tail;
 LL f[N];
 struct node{LL x,y;}land[N],s[N];
 inline bool mt(const node &a,const node &b){return a.x==b.x?a.y<b.y:a.x<b.x;}
 inline double k(int j1,int j2){return (double)(f[j1]-f[j2])/(s[j2+].y-s[j1+].y);}
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
         scanf("%lld%lld",&land[i].x,&land[i].y);
     sort(land+,land+n+,mt);
     for(int i=;i<=n;i++)
     {
         while(e&&land[i].y>=s[e].y)e--;
         s[++e]=land[i];
     }
     for(int i=;i<=e;i++)
     {
         while(head<tail&&k(q[head+],q[head])<s[i].x)head++;
         f[i]=f[q[head]]+s[q[head]+].y*s[i].x;
         while(head<tail&&k(i,q[tail])<k(q[tail],q[tail-]))tail--;
         q[++tail]=i;
     }
     printf("%lld",f[e]);
 }

BZOJ1597