[关闭]
@zzzc18 2018-01-30T11:22:11.000000Z 字数 13646 阅读 447

斜率优化

bzoj 动态规划-斜率优化


Preface

斜率优化就是用来优化 的,由于之前太弱,以及网上各种假题解,一直没看懂,这篇博客就写一下自己的理解吧

BZOJ1597: [Usaco2008 Mar]土地购买

Description

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

Solution

由于是斜率优化第一次写,写得详细些

记土地长、宽分别为 ,
首先,根据题意,如果一块大的土地可以完全包含一块小的土地,那么小的土地就不必考虑了,直接去掉。可以通过以 为第一关键字, 为第二关键字从小到大排序,扫一遍即可得出。
接下来,可以发现去掉小土地后的序列满足 单调递增, 单调递减。
设前 块土地的最小花费为 ,可以得到一个 方程:

这个方程时间复杂度为 过不掉的。

现在我们考虑当前走到了 的位置,对于 ,我们考虑什么时候从 转移到 比从 转移到 更优。
显然,满足下式时更优:


所以(注意不等式的符号与 的单调性,这很重要):

这时我们令 ,那么当 时,对决策点 而言, 优。

有这个结论就可以搞事了。

考虑以下两个条件
1.对于两个点 满足 那么 优于 ,而 单调递增, 单调递减,所以对于 而言,均有 。换言之,对于以后的决策,都不可能从 转移更优。
2.假设对于三个点 满足
---2.(1) 时, 优,故不选
---2.(2) 时, 优于 优于 ,还是不会选
所以说我们维护的可行转移必须满足

如果非要把 看做斜率的话,那我们维护的可行转移点集应该是一个上凸壳

算法的具体流程:
维护一个双端队列,每次到一个决策点 都检查队首两个元素,如果,就把队首元素弹出,直到只剩一个元素或者不满足
然后,由于 单调递减,可以发现队首元素就是最优转移,利用这个转移计算 ;
再然后将 插入队列,插入时如果K(队尾,队尾第二个)<K(队尾,t)就弹出队尾元素,直到只剩一个元素或者或者K(队尾,队尾第二个)>K(队尾,t)

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. typedef long long LL;
  6. const int MAXN = 50000+9;
  7. int n;
  8. struct PAIR{
  9. LL x,y;
  10. }num[MAXN],val[MAXN];
  11. int tot;
  12. LL dp[MAXN];
  13. bool cmp(const PAIR &A,const PAIR &B){
  14. if(A.x==B.x)
  15. return A.y<B.y;
  16. return A.x<B.x;
  17. }
  18. double K(int a,int b){
  19. return 1.0*(dp[a]-dp[b])/(val[a+1].y-val[b+1].y);
  20. }
  21. void solve(){
  22. int head=1,tail=2;
  23. static int que[MAXN];
  24. for(int i=1;i<=tot;i++){
  25. while(tail-head>1 && K(que[head],que[head+1])>=-val[i].x)
  26. head++;
  27. dp[i]=dp[que[head]]+val[i].x*val[que[head]+1].y;
  28. while(tail-head>1 && K(que[tail-1],que[tail-2])<K(que[tail-1],i))
  29. tail--;
  30. que[tail++]=i;
  31. }
  32. printf("%lld\n",dp[tot]);
  33. }
  34. int main(){
  35. scanf("%d",&n);
  36. for(int i=1;i<=n;i++)
  37. scanf("%lld%lld",&num[i].x,&num[i].y);
  38. sort(num+1,num+n+1,cmp);
  39. for(int i=1;i<=n;i++){
  40. if(num[i].y<=num[i+1].y)continue;
  41. while(tot && val[tot].y<=num[i].y)
  42. tot--;
  43. val[++tot]=num[i];
  44. }
  45. solve();
  46. return 0;
  47. }

BZOJ1010: [HNOI2008]玩具装箱toy

Description

  P教授要去看奥运,但是他舍不下他的玩具,于是他决定把所有的玩具运到北京。他使用自己的压缩器进行压缩,其可以将任意物品变成一堆,再放到一种特殊的一维容器中。P教授有编号为1...N的N件玩具,第i件玩具经过压缩后变成一维长度为Ci.为了方便整理,P教授要求在一个一维容器中的玩具编号是连续的。同时如果一个一维容器中有多个玩具,那么两件玩具之间要加入一个单位长度的填充物,形式地说如果将第i件玩具到第j个玩具放到一个容器中,那么容器的长度将为
  制作容器的费用与容器的长度有关,根据教授研究,如果容器长度为x,其制作费用为(X-L)^2.其中L是一个常量。P教授不关心容器的数目,他可以制作出任意长度的容
器,甚至超过L。但他希望费用最小.

Input
  第一行输入两个整数N,L.接下来N行输入Ci.1<=N<=50000,1<=L,Ci<=10^7

Output
  输出最小费用
  

Solution

下面的题就简写了

将每件物品长度+1,L++。(自己推一下式子就发现为什么了了)
求物品长度前缀和记为
朴素动规方程:

像上一题一样推式子
对于 ,当满足

时, 优于
此时

经检验,满足之前所说的两个条件
这次 单调递增,是个下凸壳

同样注意队首的弹出。

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. typedef long long LL;
  6. const int MAXN = 50000+9;
  7. int n,L;
  8. int num[MAXN];
  9. LL sum[MAXN];
  10. LL dp[MAXN];
  11. double K(int a,int b){
  12. return 1.0*(dp[a]-dp[b])/(sum[a]-sum[b])+1.0*(sum[a]+sum[b]);
  13. }
  14. void solve(){
  15. static int head=1,tail=2;
  16. static int que[MAXN];
  17. for(int i=1;i<=n;i++){
  18. while(tail-head>1 && K(que[head],que[head+1])<=2*(sum[i]-L))
  19. head++;
  20. dp[i]=dp[que[head]]+(sum[i]-sum[que[head]]-L)*(sum[i]-sum[que[head]]-L);
  21. while(tail-head>1 && K(que[tail-1],que[tail-2])>K(que[tail-1],i))
  22. tail--;
  23. que[tail++]=i;
  24. }
  25. printf("%lld\n",dp[n]);
  26. }
  27. int main(){
  28. scanf("%d%d",&n,&L);
  29. L++;
  30. for(int i=1;i<=n;i++){
  31. scanf("%d",&num[i]);
  32. num[i]++;
  33. }
  34. for(int i=1;i<=n;i++)
  35. sum[i]=sum[i-1]+num[i];
  36. solve();
  37. return 0;
  38. }

BZOJ1096: [ZJOI2007]仓库建设

Description

  L公司有N个工厂,由高到底分布在一座山上。如图所示,工厂1在山顶,工厂N在山脚。由于这座山处于高原内陆地区(干燥少雨),L公司一般把产品直接堆放在露天,以节省费用。突然有一天,L公司的总裁L先生接到气象部门的电话,被告知三天之后将有一场暴雨,于是L先生决定紧急在某些工厂建立一些仓库以免产品被淋坏。由于地形的不同,在不同工厂建立仓库的费用可能是不同的。第i个工厂目前已有成品Pi件,在第i个工厂位置建立仓库
的费用是Ci。对于没有建立仓库的工厂,其产品应被运往其他的仓库进行储藏,而由于L公司产品的对外销售处设置在山脚的工厂N,故产品只能往山下运(即只能运往编号更大的工厂的仓库),当然运送产品也是需要费用的,假设一件产品运送1个单位距离的费用是1。假设建立的仓库容量都都是足够大的,可以容下所有的产品。你将得到以下数据:1:工厂i距离工厂1的距离Xi(其中X1=0);2:工厂i目前已有成品数量Pi;:3:在工厂i建立仓库的费用
Ci;请你帮助L公司寻找一个仓库建设的方案,使得总的费用(建造费用+运输费用)最小。

Input
  第一行包含一个整数N,表示工厂的个数。接下来N行每行包含两个整数Xi, Pi, Ci, 意义如题中所述。

Output
  仅包含一个整数,为可以找到最优方案的费用。
  
【数据规模】

对于100%的数据, N ≤1000000。 所有的Xi, Pi, Ci均在32位带符号整数以内,保证中间计算结果不超过64位带符号整数。

Solution

记为工厂到山脚的距离
为后缀加权和,即
的前缀和
朴素动规方程(表示 处设有仓库):

对于 优于 当且仅当

满足两个条件,是个上凸壳

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. typedef long long LL;
  6. const int MAXN = 1000000+9;
  7. int n;
  8. LL dis[MAXN];
  9. LL P[MAXN];
  10. LL C[MAXN];
  11. LL dp[MAXN],succ[MAXN],sum[MAXN];
  12. double K(int a,int b){
  13. return 1.0*(dp[a]+succ[a+1]-dp[b]-succ[b+1])/(sum[b]-sum[a]);
  14. }
  15. void solve(){
  16. static int head=1,tail=2;
  17. static int que[MAXN];
  18. for(int i=1;i<=n;i++){
  19. while(tail-head>1 && K(que[head],que[head+1])>=dis[i])
  20. head++;
  21. dp[i]=C[i]+dp[que[head]]+succ[que[head]+1]-succ[i+1]-dis[i]*(sum[i]-sum[que[head]]);
  22. while(tail-head>1 && K(que[tail-1],que[tail-2])<K(que[tail-1],i))
  23. tail--;
  24. que[tail++]=i;
  25. }
  26. printf("%lld\n",dp[n]);
  27. }
  28. int main(){
  29. scanf("%d",&n);
  30. for(int i=1;i<=n;i++)
  31. scanf("%lld%lld%lld",&dis[i],&P[i],&C[i]);
  32. LL d=dis[n];
  33. //到山脚距离
  34. for(int i=1;i<=n;i++)
  35. dis[i]=d-dis[i];
  36. for(int i=n;i;i--)
  37. succ[i]=succ[i+1]+dis[i]*P[i];
  38. for(int i=1;i<=n;i++)
  39. sum[i]=sum[i-1]+P[i];
  40. solve();
  41. return 0;
  42. }

BZOJ1911: [Apio2010]特别行动队

Description

1911_1.jpg-80.4kB
1911_2.jpg-20.3kB
1911_3.jpg-9.3kB
1911_4.jpg-18.2kB

Solution

的前缀和
朴素动规方程(表示 处为一个行动队的结束位置):

对于 ,若 优,则:

满足两个条件,是一个上凸壳

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 1000000+9;
  6. typedef long long LL;
  7. int n;
  8. LL a,b,c;
  9. LL sum[MAXN];
  10. LL dp[MAXN];
  11. LL square(LL x){
  12. return x*x;
  13. }
  14. double K(int x,int y){
  15. return 1.0*(dp[x]-dp[y])/(sum[x]-sum[y])-1.0*b+1.0*a*(sum[x]+sum[y]);
  16. }
  17. void solve(){
  18. static int head=1,tail=2;
  19. static int que[MAXN];
  20. //que[head]=0;
  21. for(int i=1;i<=n;i++){
  22. while(tail-head>1 && K(que[head],que[head+1])>=2*a*sum[i])
  23. head++;
  24. LL val=sum[i]-sum[que[head]];
  25. dp[i]=dp[que[head]]+a*square(val)+b*val+c;
  26. while(tail-head>1 && K(que[tail-1],que[tail-2])<K(que[tail-1],i))
  27. tail--;
  28. que[tail++]=i;
  29. }
  30. printf("%lld\n",dp[n]);
  31. }
  32. int main(){
  33. scanf("%d",&n);
  34. scanf("%lld%lld%lld",&a,&b,&c);
  35. for(int i=1;i<=n;i++){
  36. LL x;
  37. scanf("%lld",&x);
  38. sum[i]=sum[i-1]+x;
  39. }
  40. solve();
  41. return 0;
  42. }

BZOJ4518: [Sdoi2016]征途

Description

  Pine开始了从S地到T地的征途。
  从S地到T地的路可以划分成n段,相邻两段路的分界点设有休息站。
  Pine计划用m天到达T地。除第m天外,每一天晚上Pine都必须在休息站过夜。所以,一段路必须在同一天中走完。
  Pine希望每一天走的路长度尽可能相近,所以他希望每一天走的路的长度的方差尽可能小。
  帮助Pine求出最小方差是多少。
  设方差是v,可以证明,v×m^2是一个整数。为了避免精度误差,输出结果时输出v×m^2。

Input
  第一行两个数 n、m。
  第二行 n 个数,表示 n 段路的长度
Output
  一个数,最小方差乘以 m^2 后的值

HINT
  1≤n≤3000,保证从 S 到 T 的总路程不超过 30000

Solution

方差公式:

题目中让结果乘上 显然有玄机

问题变为了求 的最小值,其中 是原序列的一段和

表示当前已经选了 个连续的段,其中最后一个段的结尾是
朴素动规方程:

时间复杂度
和之前的套路一样,对于 ,若 优于 ,则

满足两个条件,是个下凸包
斜率优化后时间复杂度为

这一题需要注意初始化,dp[i][1]=sum[i]^2,直接转移应该有问题,会从dp[i][0]进行瞎转移,似乎有问题。

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 3000+9;
  6. typedef long long LL;
  7. int n,m;
  8. LL sum[MAXN];
  9. LL dp[MAXN][MAXN];
  10. LL square(LL x){
  11. return x*x;
  12. }
  13. double K(int a,int b,int step){
  14. return 1.0*(dp[a][step]-dp[b][step])/(sum[a]-sum[b])+1.0*(sum[a]+sum[b]);
  15. }
  16. void solve(){
  17. static int head=1,tail=2;
  18. static int que[MAXN];
  19. for(int i=1;i<=n;i++)
  20. dp[i][1]=square(sum[i]);
  21. for(int j=2;j<=m;j++){
  22. head=1,tail=2;
  23. for(int i=1;i<=n;i++){
  24. while(tail-head>1 && K(que[head],que[head+1],j-1)<=2*sum[i])
  25. head++;
  26. dp[i][j]=dp[que[head]][j-1]+square((sum[i]-sum[que[head]]));
  27. while(tail-head>1 && K(que[tail-1],que[tail-2],j-1)>K(que[tail-1],i,j-1))
  28. tail--;
  29. que[tail++]=i;
  30. }
  31. }
  32. printf("%lld\n",dp[n][m]*m-square(sum[n]));
  33. }
  34. int main(){
  35. scanf("%d%d",&n,&m);
  36. for(int i=1;i<=n;i++){
  37. LL x;
  38. scanf("%lld",&x);
  39. sum[i]=sum[i-1]+x;
  40. }
  41. solve();
  42. return 0;
  43. }

UPD:之前代码貌似有问题,比如存在一些选了3个数却分了5段的情况,下面这个应该说的过去

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 3000+9;
  6. typedef long long LL;
  7. int n,m;
  8. LL sum[MAXN];
  9. LL dp[MAXN][MAXN];
  10. LL square(LL x){
  11. return x*x;
  12. }
  13. double K(int a,int b,int step){
  14. return 1.0*(dp[a][step]-dp[b][step])/(sum[a]-sum[b])+1.0*(sum[a]+sum[b]);
  15. }
  16. void solve(){
  17. static int head=1,tail=2;
  18. static int que[MAXN];
  19. for(int i=1;i<=n;i++)
  20. dp[i][1]=square(sum[i]);
  21. for(int j=2;j<=m;j++){
  22. head=1,tail=2;
  23. for(int i=j-1;i<=n;i++){
  24. while(tail-head>1 && K(que[head],que[head+1],j-1)<=2*sum[i])
  25. head++;
  26. if(i==j-1){
  27. dp[i][j]=1000000000000LL;
  28. }
  29. else
  30. dp[i][j]=dp[que[head]][j-1]+square((sum[i]-sum[que[head]]));
  31. while(tail-head>1 && K(que[tail-1],que[tail-2],j-1)>K(que[tail-1],i,j-1))
  32. tail--;
  33. que[tail++]=i;
  34. }
  35. }
  36. printf("%lld\n",dp[n][m]*m-square(sum[n]));
  37. }
  38. int main(){
  39. scanf("%d%d",&n,&m);
  40. for(int i=1;i<=n;i++){
  41. LL x;
  42. scanf("%lld",&x);
  43. sum[i]=sum[i-1]+x;
  44. }
  45. solve();
  46. return 0;
  47. }

BZOJ3675: [Apio2014]序列分割

Description

小H最近迷上了一个分隔序列的游戏。在这个游戏里,小H需要将一个长度为n的非负整数序列分割成k+1个非空的子序列。为了得到k+1个子序列,小H需要重复k次以下的步骤:
1.小H首先选择一个长度超过1的序列(一开始小H只有一个长度为n的序列——也就是一开始得到的整个序列);
2.选择一个位置,并通过这个位置将这个序列分割成连续的两个非空的新序列。
每次进行上述步骤之后,小H将会得到一定的分数。这个分数为两个新序列中元素和的乘积。小H希望选择一种最佳的分割方式,使得k轮之后,小H的总得分最大。

Input

输入第一行包含两个整数n,k(k+1≤n)。
第二行包含n个非负整数a1,a2,...,an(0≤ai≤10^4),表示一开始小H得到的序列。
Output
输出第一行包含一个整数,为小H可以得到的最大分数。

Sample Input

7 3 
4 1 3 4 0 2 3 

Sample Output

108 

HINT

【样例说明】

在样例中,小H可以通过如下3轮操作得到108分:

1.-开始小H有一个序列(4,1,3,4,0,2,3)。小H选择在第1个数之后的位置将序列分成两部分,并得到4×(1+3+4+0+2+3)=52分。

2.这一轮开始时小H有两个序列:(4),(1,3,4,0,2,3)。小H选择在第3个数字之后的位置将第二个序列分成两部分,并得到(1+3)×(4+0+2+3)=36分。

3.这一轮开始时小H有三个序列:(4),(1,3),(4,0,2,3)。小H选择在第5个数字之后的位置将第三个序列分成两部分,并得到(4+0)×(2+3)= 20分。

经过上述三轮操作,小H将会得到四个子序列:(4),(1,3),(4,0),(2,3)并总共得到52+36+20=108分。

【数据规模与评分】

数据满足2≤n≤100000,1≤k≤min(n -1,200)。

Solution

就方程而言,这和上一题类似,好像还简单一些。

为前 个数已经分为 部份。
朴素动规方程:

时间复杂度达到了

考虑 ,若 优,则:

满足两个条件,是个下凸壳

优化后时间复杂度可以达到

这题有两个坑点:

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 100000+9;
  6. typedef long long LL;
  7. const LL INF = 1000000000000LL;
  8. LL sum[MAXN];
  9. LL dp[MAXN][7];
  10. int n,k;
  11. double K(int a,int b,int step){
  12. if(sum[a]==sum[b])
  13. return INF;
  14. return 1.0*(dp[a][step]-dp[b][step])/(sum[b]-sum[a])+1.0*(sum[a]+sum[b]);
  15. }
  16. void solve(){
  17. static int head=1,tail=2;
  18. static int que[MAXN];
  19. int opt=0;
  20. for(int j=1;j<=k;j++){
  21. opt^=1;
  22. head=1,tail=2;
  23. for(int i=1;i<=n;i++)
  24. dp[i][opt]=0;
  25. for(int i=1;i<=n;i++){
  26. while(tail-head>1 && K(que[head],que[head+1],opt^1)<=sum[i])
  27. head++;
  28. dp[i][opt]=dp[que[head]][opt^1]+sum[que[head]]*(sum[i]-sum[que[head]]);
  29. while(tail-head>1 && K(que[tail-1],que[tail-2],opt^1)>K(que[tail-1],i,opt^1))
  30. tail--;
  31. que[tail++]=i;
  32. }
  33. }
  34. printf("%lld\n",dp[n][opt]);
  35. }
  36. int main(){
  37. scanf("%d%d",&n,&k);
  38. for(int i=1;i<=n;i++){
  39. LL x;
  40. scanf("%lld",&x);
  41. sum[i]=sum[i-1]+x;
  42. }
  43. solve();
  44. return 0;
  45. }

BZOJ3156: 防御准备

Description

1(1).jpg-68.5kB

Input
第一行为一个整数N表示战线的总长度。

第二行N个整数,第i个整数表示在位置i放置守卫塔的花费Ai。

Output
共一个整数,表示最小的战线花费值。

HINT

1<=N<=10^6,1<=Ai<=10^9

Solution

写出朴素方程考虑优化即可。
我感觉已经不用写了,代码里其实很清楚。方程和斜率都能看出来,套路都一样

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 1000000+9;
  6. typedef long long LL;
  7. int n;
  8. int num[MAXN];
  9. LL dp[MAXN];
  10. double K(int a,int b){
  11. return 2.0*(dp[a]-dp[b])/(a-b)+a+b+1;
  12. }
  13. void solve(){
  14. static int head=1,tail=2;
  15. static int que[MAXN];
  16. for(int i=1;i<=n;i++){
  17. while(tail-head>1 && K(que[head],que[head+1])<=2*i)
  18. head++;
  19. dp[i]=dp[que[head]]+1LL*(i-que[head]-1)*(i-que[head])/2+num[i];
  20. while(tail-head>1 && K(que[tail-1],que[tail-2])>K(que[tail-1],i))
  21. tail--;
  22. que[tail++]=i;
  23. }
  24. printf("%lld\n",dp[n]);
  25. }
  26. int main(){
  27. scanf("%d",&n);
  28. for(int i=1;i<=n;i++)
  29. scanf("%d",&i[num]);
  30. solve();
  31. return 0;
  32. }

BZOJ3437: 小P的牧场

Description

小P在MC里有n个牧场,自西向东呈一字形排列(自西向东用1…n编号),于是他就烦恼了:为了控制这n个牧场,他需要在某些牧场上面建立控制站,每个牧场上只能建立一个控制站,每个控制站控制的牧场是它所在的牧场一直到它西边第一个控制站的所有牧场(它西边第一个控制站所在的牧场不被控制)(如果它西边不存在控制站,那么它控制西边所有的牧场),每个牧场被控制都需要一定的花费(毕竟在控制站到牧场间修建道路是需要资源的嘛~),而且该花费等于它到控制它的控制站之间的牧场数目(不包括自身,但包括控制站所在牧场)乘上该牧场的放养量,在第i个牧场建立控制站的花费是ai,每个牧场i的放养量是bi,理所当然,小P需要总花费最小,但是小P的智商有点不够用了,所以这个最小总花费就由你来算出啦。

Input
第一行一个整数 n 表示牧场数目

第二行包括n个整数,第i个整数表示ai

第三行包括n个整数,第i个整数表示bi

Output
只有一行,包括一个整数,表示最小花费

Sample Input

4
2 4 2 4
3 1 4 2

Sample Output

9

样例解释
选取牧场1,3,4建立控制站,最小费用为2+(2+1*1)+4=9。

Hint
1<=n<=1000000, 0 < a i ,bi < = 10000

Solution

和 BZOJ1096: [ZJOI2007]仓库建设 类似

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int MAXN = 1000000+9;
  6. typedef long long LL;
  7. int n;
  8. LL a[MAXN],b[MAXN];
  9. LL sum[MAXN],succ[MAXN];
  10. LL dp[MAXN];
  11. double K(int a,int b){
  12. return 1.0*(dp[a]-dp[b]+succ[a+1]-succ[b+1])/(sum[a]-sum[b])+n;
  13. }
  14. void solve(){
  15. static int head=1,tail=2;
  16. static int que[MAXN];
  17. for(int i=1;i<=n;i++){
  18. while(tail-head>1 && K(que[head],que[head+1])<=i)
  19. head++;
  20. dp[i]=a[i]+dp[que[head]]+succ[que[head]+1]-succ[i+1]-1LL*(n-i)*(sum[i]-sum[que[head]]);
  21. while(tail-head>1 && K(que[tail-1],que[tail-2])>K(que[tail-1],i))
  22. tail--;
  23. que[tail++]=i;
  24. }
  25. printf("%lld\n",dp[n]);
  26. }
  27. int main(){
  28. scanf("%d",&n);
  29. for(int i=1;i<=n;i++)
  30. scanf("%lld",&a[i]);
  31. for(int i=1;i<=n;i++)
  32. scanf("%lld",&b[i]);
  33. for(int i=1;i<=n;i++)
  34. sum[i]=sum[i-1]+b[i];
  35. for(int i=n;i;i--)
  36. succ[i]=succ[i+1]+(n-i)*b[i];
  37. solve();
  38. return 0;
  39. }

Last but not least

如果真的看到最后,会发现上面的题全部是一个套路。全部由单调队列维护即可。
以后再写别的,如 CDQ分治 二分等更多的斜率优化。


添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注