关于动态规划的优化方案(%(color{red}{rqy}))
1.单调队列
单调队列是一种具有单调性的队列，其中的元素全部按照递增或者递减的顺序排列，就比如下面这个递减队列。
假如说我们要在队尾加入一个(5)，那么我们入队的步骤就是这样的：
发现队尾(1)，(q[tail])，(1<5)，则将1退出(tail--)
发现队尾(2)，(q[tail])，(2<5)，则将2退出(tail--)
发现队尾(3)，(q[tail])，(3<5)，则将3退出(tail--)
发现队尾(8)，(q[tail])，(8>5)，停止退出队尾，将(5)入队。
经过上述步骤之后队列变为了{8,5}，依然满足递减的单调性，而实际上这也就是单调队列的基本操作。而维护递增的方式也是一样的。
#define MAXN 100010
int n,a[MAXN];
int q[MAXN],head=1,tail=1;
for(int i=1;i<=n;i++){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);//输入
q[1]=a[1];//将第一个元素入队
for(int i=2;i<=n;i++){
while(head<=tail&&q[tail]<a[i])
//如果队列不为空并且队尾元素小于a[i]
tail--;//弹出队尾元素
q[++tail]=a[i];//入队
}
}
【例题1】
我们现在有一个整数序列(A(a[MAXN]))，长度为(n)，又知两个参数(k)和(m)，要求：从(A)序列中找出(k)个不相交的区间，每段区间长度(len)<=(m)，要求所有k个区间的区间和最大。
考虑最基本的(DP),设(dp[i][j])表示从前(j)个数里面选出来(i)个长度不超过m的不相交区间的区间和最大值，然后我们再枚举一个(k)，指选择([k+1,j])这个子区间。然后我们创造一个前缀和数组(sum[MAXN])，那么([k+1,j])这个区间的区间和就是(sum[j]-sum[k])。子问题分为两块：(j)选入子区间，或者(j)不选入子区间，从(j-m)到(j)范围内枚举一个(k)使得(dp[i-][k]+sum[j]-sum[k])最大，然后与(dp[i][j-1])取一个(max)可得答案。
for(int i=1;i<=n;i++)
sum[i]=sum[i-1]+a[i];//前缀和数组
for(int i=1;i<=k;i++)
for(int j=1;j<=n;j++){
int ans=-INF;
for(int k=j-m;k<=j;k++){
ans=max(ans,dp[i-1][k]+sum[j]-sum[j]);
}
dp[i][j]=max(ans,dp[i][j-1]);
}
这样的(DP)时间复杂度为(O(nmk))，显然太大，于是我们考虑优化。
我们可以看到(DP)的原式子是(color{red}{dp[i][j]=max(dp[i][j-1],max(f[i-1][k]+sum[j]-sum[k]));})
我们发现在里面的(k)的最优化枚举当中，sum[j]是不随k的枚举变化的，所以我们可以将sum[j]提出来变成：(color{red}{dp[i][j]=max(dp[i][j-1],sum[j]+max(f[i-1][k]-sum[k]));})
可以知道在整个式子里面最耗时间的就是最后关于(dp[i-1][k]-sum[k])最大值的枚举，所以只要快速计算出来了(dp[i-1][k]-sum[k])就可以快速计算整个式子。我们来看(dp[i-1][k]-sum[k])的范围是在([0][0],[0][1],....[0][m-1],[1][m],[2][m+1],...,[n-m][n-1])这些区间上的最大值，也就是所有的([j][i+j-1])的区间。
我们发现这些区间的左右端点都是单调递增的，所以我们可以利用单调队列在(O(1))的时间内解决这些区间。然后我们就将时间优化到了(O(nk))。
【例题2】([NOI2005])瑰丽华尔兹(link)
一个(n×m)的矩形网格。你初始站在((x,y))这。有些格子有障碍而有些没有。有(K)个时间段。第(i)个时间段从(s[i])持续到(t[i])（包括两端）这段时间内网格会向某个方向（上下左右之一）倾斜。所以每个时间段内的每个时间单位，你可以选择在原地不动，或者向倾斜的方向走一格（当然你不能走到障碍上或是走出网格）。
求你最多能走多少格。
如上图所示，黑色方块为障碍，(S)为起始点。
按照最常的(DP)思路来看，我们设(dp[k][i][j])为在k时间点，从((x,y))节点走到了((i,j))节点的时候最长走了多长。初始化(dp[0][i][j])全部为(?∞)，而(dp[0][x1][y1]0)=(0)((x1,y1)为初始位置)，考虑子问题就是：从那边来？(k)时刻是从那个方向来还是不动？我们以第(k)时刻向右倾斜为例。
如果是向右倾斜，那么上一层状态就是在((i,j-1))地点，那么结合两个子问题我们可以得出(DP)方程式：(dp[k][i][j]=max(dp[k-1][i][j],dp[k-1][i][j-1]+1);)
for(int k=1;k<=len;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
dp[k][i][j]=max(dp[k-1][i][j],dp[k-1][i][j-1]+1);
那么这样的时间复杂度就是(O(nmsum_{i=1}^{K}(t[i]-s[i]+1)))，是无法通过这个题的全部数据的。然后我们紧接着考虑怎么优化。关于位置的(n^2)枚举我们没有什么办法，但是关于(K)我们可以进行优化，时间点很多有(sum_1^K(t[i]-s[i]+1))个，但是时间段(K)却<=(200)，那么我们可以将一段时间的转移全部合并起来一起算，那么就快得多了。
我们设(dp[k][i][j])为在第(k)个时间段末尾，从((x,y))走到了((i,j))点,(len[k])为第(k)个时间段的持续时间，可以算出是(t[k]-s[k]+1)。
首先还是(n^2)的枚举，和(k)时间段的枚举，之后我们还有一个(l)的枚举，这个(l)枚举的是上一个状态加上在当前这个(k)的时间段内一共走的步数对应倾斜方向的横、竖坐标，如果我们继续以右倾为例，那么(j-len[j]<=l<=j)，就是从完全不动到走了最多的(len[k])步，那么我们有了状态转移方程式：(color{red}{dp[k][i][j]=max_{j-len[k]<=l<=j}(dp[k-1][i][l]+j-l)}),由于其中的+(j)与l的枚举并无关联，所以提出来就变成了(color{red}{dp[k][i][j]=max_{j-len[k]<=l<=j}(dp[k-1][i][l]-l)+j})。其实也就是枚举这个时间段之前这个人的位置在哪，也就知道了当前的(dp[k][i][j])是从哪里转移过来的。
之后，我们回过头来看上一道题的最后的(DP)方程式：(color{red}{dp[i][j]=max(dp[i][j-1],sum[j]+max(f[i-1][k]-sum[k]));})
是不是发现格式非常的相似呢？，我们固定住(i)之后的状态转移方程式基本是和上题一样的，所以一样可以使用单调队列优化到(O(nmK))。
下面针对一组样例，我们进行一遍手动模拟，以帮助更好的理解。
就用洛谷的样例吧。（第一行分别为n,m,x1,y1,k）
4 5 4 1 3
. . xx.
. . . . .
. . . x.
. . . . .
1 3 4
4 5 1
6 7 3
那么画完图之后就是这个样子：
从(1)~(3)时刻的倾斜方向是右，那么纵坐标是你不变的，我们枚举纵坐标。
for(int i=1;i<=k;i++){
int s; int t; int dir;
scanf("%d%d%d",&s,&t,&dir);
//注意要反着DP，也就是倒退
int len=t-s+1;
if(dir==1) //北面（上）
for(int j=1;j<=m;j++)//北面的话横坐标不变，那么我们枚举纵坐标
DP(i,n,j,dir,len);
if(dir==2) //南面（下）
for(int j=1;j<=m;j++)//南面的话横坐标不变，那么我们枚举纵坐标
DP(i,1,j,dir,len);
if(dir==3) //西面（左）
for(int j=1;j<=n;j++)//西面的话纵坐标不变，那么我们枚举横坐标
DP(i,j,m,dir,len);
if(dir==4) //东面（右）
for(int j=1;j<=n;j++)//东面的话纵坐标不变，那么我们枚举横坐标
DP(i,j,1,dir,len);
}
然后当我们的横坐标x枚举到1的时候，我们在DP函数里面定义一个now，然后是(while(x>=1)&&(x<=n)&&(y>=1)&&(y<=m)),因为首先要保证不超过边界。然后如果我们发现右面是可以走的，那么我们就进行一个push操作。也就是关于dp[p-1][x][y]在单调队列里面的入队操作。在最前面我们已经介绍了。
void push(int now,int value){
if(value==-INF) return ;
//如果压根做不到这里，那么直接返回
while(head<=tail&&value-now>=q[tail])
tail--;//弹出队尾
q[++tail]=value-now;
pos[tail]=now;
//pos记录位置，用来判断是不是可以滑
}
而至于为什么要在(while)里面减去一个(now)，是因为(x,y)这个位置不一定是在当前方向的起点上，因为之后某一步的步数减去当前的步数得到的值就是(x,y)到那一步在的点的距离，相当于一个化简~
由于(dp[0][i][j])=-(INF),当前的(p)=(1)所以(p)-(1)的时候(value)就是-(INF)，所以在第0个时间段到不了这个地方，我们直接返回。然后下面其实就没什么事了，所有的push全部直接返回，最后退出DP函数。就这样进行到(x)(即(j))=(3)的时候，我们发现(map[3][4])是一个障碍点，那么也就是说我们之前进行的所有工作全部无效，然后我们将整个队列清空，即(head)=(1,tail)=(0);
然后接着进行到(x)=(4),(y)=(1)((4)行(1)列)的时候，我们到了起始点，而起始点的dp[0][4][1]是0，所以(value)!=-(INF)，我们终于将一个值(value)-(now)=-1入队了，那么我们当前的队列是这个样子的：
加上步数之后我们发现(dp[p][x][y]=q[head]+now)依然是(0)，所以(ans)没有被更新（废话，你从起点走到起点需要更新(ans)嘛），所以我们继续向下进行，因为每次(now)都会++，所以下面的(dp[p][x][y])加上(now)之后就可以更新(ans)的值了。然后进行到(x)=(4),(y)=(5)的时候，我们发现(now-pos[head]=4)，大于可以(len)，也就是说超过了可以滑动的区间。（一共就三秒你怎么滑第四块啊~）那么我们将队首弹出，接下来我们就不能再更新ans的最大值了，(x)=(4)时完美结束。这个时候我们的行走路径大概如下：
（蓝色方块为当前方块，黄色方块为路径）
也就是说从(1)$3s$我们最多可以走3块。（真是麻烦啊）
(i)继续走，我们进行到下一个时间段。(4)~(5s)的时候是向北倾斜的。那么我们进行(DP(i,n,j,dir,len))，我们从(n)行(j)列开始(DP)，第一次将(tail)弹出后又入队我们不管，因为(j=1)、(2)的时候都不能更新(ans)，然后到了(j=3)的时候，我们将(dp[1][4][3]-now=1)入队了。
然后当(now)进行到第三次的时候我们就可以更改ans值为4了。
之后结束了第二个时间段。此时的路径大概是这样的：
最后在第三个时间段内，我们将路径更改为如下：
那么以上就是整个样例的模拟，最终我们得到(ans)数为6.
关于单调队列优化的一点总结
鉴于两者之间的(DP)转移方程的相似性，我们成功的利用单调队列优化了问题，那么回过头来看看，什么样的问题可以利用单调队列进行优化呢？我们最上面讲的单调队列是具有单调性的一种数据结构，他可以保证数据的单调性，自然也就可以留下数据的最大值或者最小值，利用了单调性，就是减少了一位枚举，减去一维，直接获得单调队列里面的最优解。并且DP可以使用单调队列优化，当且仅当(DP)式的格式基本满足(color{red}{dp[i]=a[i]+max_{l[i]<=j<=r[i]}b[j]})的时候。即“(dp[i])=(A(i))+(B(j))中的最小/大值 ((i-k<=j<i,k)为常数())”，当你发现要求(max)而且求可能拓展的状态有线性关系的时候，你就可以考虑单调队列优化了。
2.斜率优化
如果你有一个这样结构的(DP)式：
(f[i]=max_{j=1}^{j<=i}(a[i]?b[j]+c[j]+d[i]))
我们发现取(max)里面的d[i]其实和j的枚举并没有关系，所以将d[i]提出来就变成了这样：
(f[i]=d[i]+min_{j=1}^{j<=i}(a[i]?b[j]+c[j]))
（只是这样的结构而已，比如也可以是(max)，(j)也不一定属于([1,n])此处只是一个单独情况）
其中(a[now],b[now],c[now],d[now])都是关于(now)的函数，并且(b[now])是单调递增的，那么我们接下来利用数学归纳法证明其决策的单调性。
首先我们假设有两个决策(j),(k)满足(j<k)并且(k)的决策优于(j)的决策。那么我们有(d[i]+a[i]*b[j]+c[j]>=d[i]+a[i]*b[k]+c[k]);消去左右两端的d[i]后可得(a[i]*b[j]+c[j]>=a[i]*b[k]+c[k])。
我们知道在(i)后面有状态(i+1)，我们为了简单起见，设(a[now])是单调递减的，那么我们就是要证明
(d[i+1]+a[i+1]*b[j]+c[j]>=d[i+1]+a[i+1]*b[k]+c[k])
由于(a)是单调递减的，所以(a[i-1])也可以写成(a[i]-v)的形式，其中(v>0)，那么式子变成：
(d[i+1]+a[i]*b[j]+v*b[j]+c[j]>=d[i+1]+a[i]*b[k]+v*b[k]+c[k])
然后因为(a[i]*b[j]+c[j]>=a[i]*b[k]+c[k])，并且(b[k]>b[j]),所以我们有(v*b[k]>v*b[j])，所以我们知道
(d[i+1]+a[i+1]*b[j]+c[j]>=d[i+1]+a[i+1]*b[k]+c[k])
是正确的，决策单调性也存在。然后我们将式子展开就可以得到这样一个玩意：
(-a[i]>=frac{c[k]-c[j]}{b[k]-b[j]})。
你会发现这个玩意像极了一个叫做斜率的东西(数学就是瞎(yy)出来的)
(slope(i,j)):(frac{y[k]-y[j]}{x[k]-x[j]})
没错，这个东西就是我们要讲的第二个内容：斜率优化！
记斜率为(slope(i,j)=frac{c[k]-c[j]}{b[k]-b[j]})
那么我们紧接着(yy)这个式子的属性，发现它和单调队列有很多相似之处,因此我们也可以根据这些特性对(DP)进行优化：
- (-a[i]>=slope(q[l],q[l+1]))。
我们知道(q[l])是在(q[l+1])之前就已经输入完毕的了，那么这个式子就表示(q[l])不如(q[l+1])更优，所以弹出队首。
2.(slope(q[r-1],q[r]>slope(q[r],i))。
假设在之后会出现一个(a[t])使得(-a[t]>=slope(q[r-1],q[r])),那么在弹出(q[r-1])之后，(-a[t]也一定>=slope(q[r],i));
我们考虑将每一个((b[j],c[j]))作为一个点对放到一个平面直角坐标系当中，画一条过点((b[j],c[j]))的斜率为(a[i])的直线，那么这个直线的方程式就是(f[i]=a[i]x+(y[j]-a[i]x[j]))，所以我们就成功的将一个决策转化到了平面直角坐标系上面。
假如说我们将所有的决策转化为点映射到图上可以得到这样一个图：
那么我们对于每一个点做一个斜率为(a[i])的直线可以得到这样的一幅图
由于我们要枚举的是一个是决策最优的方案，那么我们就要根据题意，来看看是(min)还是(max)，在这里我们的方程式是取的(min)，也就是要在所有的决策中找到一个位置最靠下的，也就是最右面那道直线。
但是这样每一条边每一条边地建、找实在是太慢，于是我们考虑如何优化。
我们知道最下面的一条边肯定会在一个下凸的凸壳上面（比如下图），那么我们就要想办法维护这个凸壳，将不可能有贡献的点删去。
那么上图中被下面的这条折现包起来的所有的点就都没有作为最优决策的机会，因此我们就要抛弃这些决策，并且有可能被选为最优决策的只有在这个下凸壳上面的点。
而对于整个下凸壳的求法，我们考虑先排一遍序，按照x[i]从小到大的顺序排序，然后由于x[i]递增，那么我们就只需要考虑在右面添加点就可以了。对于一个点v，如果它是由前面两个点组成的直线逆时针旋转过来的，那么很好，我们就将它加入目前的下凸壳，比如下图：
但是如果当前点(v)是由前面两个点(h),(g)所形成的直线经过顺时针旋转得到的，那么我们就要删除之前的最后一个点(g)，继续判断(v)是不是由(h)和(h)前面的点顺时针旋转得到的，直到碰到一个逆时针旋转的操作，那么停止，并将最后删除的点的前一个点连到(v)点上。比如下图：
删除第一个节点之后继续判断
而对于上凸壳的寻找，就是讲寻找下凸壳中所有的顺逆时针反过来就可以了。而顺时针和逆时针的判断就是根据斜率。当然你也可以这么判断：若 ((x[C]?x[A])(y[B]?y[A])?(x[B]?x[A])(y[C]?y[A])>0)，则是顺时针转的；否则是逆时针转的((=0)的情况是三点共线)。
那么维护完了凸壳，加下来我们要做的就是在凸壳上找到一个斜率为(k)的切线了，而这个切线的寻找分为两种情况来考虑。（针对下凸壳）
1.当斜率是递增的时候，我们可以发现被取到的点也是越来越靠右的，所以我们只要从左到右依次删除不优的点就可以了。可以使用双向队列。
2.当斜率不单调的时候，我们就采用二分的方法。我们一直取中间的(mid)点，如果(mid+1)存在并且与(mid)点构成的直线的斜率小于k，那么l=mid+1吗，接着二分；如果(mid-1)存在并且与(mid)构成的直线的斜率大于k，那么r=mid-1，接着二分。如果上面两个条件都不满足，那么(mid)就是切点，也就是我们要找的点啦！！
【例题3】[HNOI2008]玩具装箱（Link）
题目描述
(P)教授要去看奥运，但是他舍不下他的玩具，于是他决定把所有的玩具运到北京。他使用自己的压缩器进行压缩，其可以将任意物品变成一堆，再放到一种特殊的一维容器中。(P)教授有编号为(1...N)的(N)件玩具，第(i)件玩具经过压缩后变成一维长度为(C[i]).为了方便整理，(P)教授要求在一个一维容器中的玩具编号是连续的。同时如果一个一维容器中有多个玩具，那么两件玩具之间要加入一个单位长度的填充物，形式地说如果将第i件玩具到第j个玩具放到一个容器中，那么容器的长度将为(x=j-i+sum_{k=j}^{k<=j}C[k]) 制作容器的费用与容器的长度有关，根据教授研究，如果容器长度为(x),其制作费用为((X-L)^2).其中(L)是一个常量。(P)教授不关心容器的数目，他可以制作出任意长度的容器，甚至超过(L)。但他希望费用最小.
输入输出格式
输入格式：
第一行输入两个整数(N)，(L).接下来(N)行输入(C[i]).(1<=N<=50000),(1<=L,Ci<=10^7)
输出格式：
输出最小费用
简单来说，我们有一个长度为(L)的序列(C[i]),要求将序列分成若干段，每一段如果从(i)到(j)，整段的和为(S)，那么就会产生((j-i+S-L)^2)的代价，要求得到最小的代价和。
那么(S)就是(sum_{k=i}^{k<=j}C[k])，那么我们就可以把式子简化成这样：(sum_{k=i}^{k<=j}(C[k]+1)-(L+1))，所以你可以发现如果将输入的所有(C[i])加上(i)并且将(L)全部加上(1)的话，费用就变成了((S-L)^2)。
设(sum[i])为(i)点的前缀和，我们得到(DP)式子为(f[i]=min_{j=0}^{j<=i}(f[j]+(sum[i]-sum[j]-L+i-j-1)^2))
嗯，按照上面的节奏，我们将(j)范围内的式子变一下：(f[i]=min_{j=0}^{j<=i}(f[j]+((sum[i]+i)-(sum[j]+j)-L)^2))
然后我们令(s[i]=sum[i]+i)，式子就变成了这样：(f[i]=min_{j=0}^{j<=i}(f[j]+(s[i]-s[j]-L)^2))
然后把里面的平方展开(f[i]=min_{j=0}^{j<=i}(f[j]+s[i]^2+(s[j]+L)^2-2*s[i]*(s[j]+L)))
然后稍微一个移项(f[i]+2*s[i]*min_{j=0}^{j<=i}(s[j]+L)=f[j]+s[i]^2+(s[j]+L)^2)
然后我们看这个式子的格式就很熟悉了
b+kx=y
对！就是前面搞的直线的解析式！所以我们知道这么一个转化
(x=s[j]+L)
(y=f[j]+s[i]^2+(s[j]+L)^2)
并且我们还知道(dp[i])就是上面的(y=kx+b)的截距。那么我们将所有的((x=s[j]+L，f[j]+s[i]^2+(s[j]+L)^2))点全部加到平面直角坐标系上，然后维护下凸壳就可以啦！并且你可以发现斜率(k=2*s[i])是一个单调递增的哦~
并且这里还有一个很重要的地方：看上面的那个(y)的方程是(y=f[j]+s[i]^2+(s[j]+L)^2)而实际上这里并不是一个关于(i,j)的双变量，我们在对于同一个(f[i])计算的时候，求斜率坐标相见就已经抵消掉了这个(i)的部分。
至于凸壳的寻找方法和最优点的寻找方法上面已经有比较详细的介绍了，就不再多说，上代码讲解就好了吧。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define MAXN 100010
#define INF 0x7fffffff
#define ll long long
using namespace std;
ll n,L,s[MAXN],f[MAXN];
ll q[MAXN],head,tail;
inline void read(ll &x){
char c=getchar(); x=0;
while(c<'0'||c>'9') c=getchar();
while(c<='9'&&c>='0') x=x*10+c-48,c=getchar();
}
inline void print(ll x){
ll num=0; char c[15];
while(x) c[++num]=(x%10)+48,x/=10;
while(num) putchar(c[num--]);
putchar('
');
}
inline double x(ll j){
return s[j];
}
inline double y(ll i){
return f[i]+(s[i]+L-1)*(s[i]+L-1);
}
inline double slope(ll i,ll j){
return (y(j)-y(i))/(x(j)-x(i));
}
int main(){
read(n); read(L);
L++; head=1; tail=1;
for(int i=1;i<=n;i++){
ll x; read(x);
s[i]=s[i-1]+x;
s[i]+=i;
}
for(int i=1;i<=n;i++){
while(head<tail&&slope(q[head],q[head+1])<2*s[i])
head++; ll j=q[head];
f[i]=f[j]+(s[i]-s[j]-L)*(s[i]-s[j]-L);
while(head<tail&&slope(q[tail-1],q[tail])>slope(q[tail],i))
tail--;
q[++tail]=i;
}
print(f[n]);
return 0;
}
【例题4】 土地征用 （Link）
约翰准备扩大他的农场，眼前他正在考虑购买N块长方形的土地。如果约翰单买一块土 地，价格就是土地的面积。但他可以选择并购一组土地，并购的价格为这些土地中最大的长 乘以最大的宽。比如约翰并购一块3 × 5和一块5 × 3的土地，他只需要支付5 × 5 = 25元， 比单买合算。 约翰希望买下所有的土地。他发现，将这些土地分成不同的小组来并购可以节省经费。 给定每份土地的尺寸，请你帮助他计算购买所有土地所需的最小费用。
输入输出格式
输入格式：
(Line) (1:) (A) (single) (integer:) (N)
(Lines) (2..N+1:) (Line) (i+1) (describes) (plot) (i) (with) (two) (space-separated) (integers:) (width) _ (i) (and) (length) _ (i)
输出格式：
(Line) (1:) (The) (minimum) (amount) (necessary) (to) (buy) (all) (the) (plots.)
我们定义结构体(Edge)中含有(X,Y)分别表示一块土地的长和宽。
考虑一块土地(A)，如果有一块土地(B)的(X)和(Y)都大于(A)，那么(A)的存在是没有意义的，因为(A)是可以不耗费任何代价被(B)所合并的，所以它不会对答案产生任何影响。于是我们考虑去掉这样所有的土地(A)。
首先我们将所有土地按照长度从小到大排序，长度相同的按照宽度从小到大排序。定义一个(Stack)，然后连续将所有的土地入栈，在(A)入栈之前将之前栈中所有宽度小于等于(A)的土地全部弹出，然后入栈(A)。那么最后在栈中的元素就是我们所希望的元素。这里的元素是按照长度从小到大，宽度从大到小的顺序有序排列的。
那么显然我们每次合并的都是一个连续的区间。考虑使用(DP)，易得状态转移方程：(dp[i]=min_{j=1}^{j<=Top}(dp[i],dp[j]+Stack[j+1]*L[i])),其中Stack里面存的是元素的宽度，L是栈中元素的长度。（因为有些土地被抛弃了所以我们不能继续使用(Edge)结构体），然而这样的时间复杂度会超时，考虑斜率优化。
我们看到后面的(dp[j]+Stack[j+1]*L[i])，设(k=Stack[j+1]，b=dp[j])，然后(x=L[i])，那么我们就得到了直线方程:(y=kx+b)。套上斜率优化的板子即可。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100010
#define LL long long
#define INF 0x7fffffff
using namespace std ;
LL N, Stack[MAXN], Top;
LL dp[MAXN], q[MAXN];
LL A[MAXN], B[MAXN];
LL L[MAXN];
inline void Read(LL & x){
char C = getchar() ; x = 0 ;
while(C < '0' || C > '9') C = getchar() ;
while(C <= '9' && C >= '0')
x = x * 10 + C - 48, C = getchar() ;
}
inline void Print(LL x){
LL num = 0 ; char C[15] ;
while(x) C[++ num] = (x % 10) + 48, x /= 10 ;
while(num) putchar(C[num --]) ;
putchar('
') ;
}
struct Node{
LL X, Y ;
}Edge[MAXN << 1];
inline bool Cmp(Node A, Node B){
if(A.X == B.X) return A.Y < B.Y;
else return A.X < B.X;
}
inline void Put_In_Stack(){
for(int i = 1; i <= N; i ++){
while(Top && Stack[Top] <= Edge[i].Y)
Top -- ;
Stack[++ Top] = Edge[i].Y ;
L[Top] = Edge[i].X ;
}
}
inline double Calc(LL i, LL j){
return dp[j] + Stack[j + 1] * L[i] ;
}
inline bool Slope(LL a, LL b, LL c){
return (B[c] - B[a]) * (A[b] - A[a]) - (B[b] - B[a]) * (A[c] - A[a]) >= 0;
}
int main(){
Read(N) ;
for(int i = 1; i <= N; i ++){
Read(Edge[i].X) ;
Read(Edge[i].Y) ;
}
sort(Edge + 1, Edge + N + 1, Cmp) ;
Put_In_Stack() ;
A[0] = Stack[1] ;
LL Head = 1, Tail = 1 ;
for(int i = 1;i <= Top; i ++){
while(Head < Tail && Calc(i, q[Head]) >= Calc(i, q[Head + 1]))
Head ++ ;
dp[i] = Calc(i, q[Head]) ;
A[i] = Stack[i + 1] ;
B[i] = dp[i] ;
while(Head < Tail && Slope(q[Tail - 1], q[Tail], i))
Tail -- ;
q[++ Tail] = i ;
}
Print(dp[Top]) ; return 0 ;
}