HDU-3507-打印文章

HDU-3507-打印文章

[Task]:

Zero has an old printer that doesn’t work well sometimes. As it is antique, he still like to use it to print articles. But it is too old to work for a long time and it will certainly wear and tear, so Zero use a cost to evaluate this degree.

One day Zero want to print an article which has N words, and each word i has a cost Ci to be printed. Also, Zero know that print k words in one line will cost



M is a const number.

Now Zero want to know the minimum cost in order to arrange the article perfectly.

[Solution]:

这道题很容易知道是斜率优化的dp

首先推一遍斜率:

先考虑两个状态 dp[i],dp[j] ( i<j )

设 dp[k] 为当前状态

所以

dp[k]=min( (sum[k]-sum[i])2+m+dp[i],(sum[k]-sum[j])2+m+dp[j] );(这就是转移的方程)

设选择 i;

所以:

(sum[k]-sum[i])2+dp[i]<(sum[k]-sum[j])2+dp[j];

展开整理得:

sum[i]2+dp[i]-2*sum[k]*sum[i]<sum[j]2+dp[j]-2*sum[k]*sum[j]

最后:

2*sum[k]*(sum[j]-sum[i])<sum[j]2-sum[i]2+dp[j]-dp[i];

sum[k] < (sum[j]2-sum[i]2+dp[j]-dp[i]) / 2*(sum[j]-sum[i]);

所以:

当 sum[k] < sum[j]^2-sum[i]2+dp[j]-dp[i] / 2*(sum[j]-sum[i]) 选择 i;

否则 选择 j;

每个sum[j]2-sum[i]2+dp[j]-dp[i] / 2*(sum[j]-sum[i]) 都是定值,

而 sum[k]是递增的,所以选 i 还是选 j 的关系是这样的:

iiiiiiiiijjjjjjjjj

可以看出有一个转折点,在这之前选i,在这之后选j;

如果有多个,那么就是:

aaabbbbccfgggghhkkkmmzzz(中间有很多元素根本不会被选择)

而这些关系可以用单调队列维护;

查询最值时一直出队直到

sum[k] < sum[j]^2-sum[i]2+dp[j]-dp[i] / 2*(sum[j]-sum[i])

插入时,当从最后一个元素到当前元素的转折点低于倒数第二个元素到当前元素的转折的时(这意味着最后一个元素会被扼杀在摇篮里(在该选择最后一个元素前,就该选择当前元素了,所以最后一个元素根本不会被选择)),就一直让最后一个元素出队;

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
#define POW(_X) ((_X)*(_X))

const int M=500005;
int n,m;
int sum[M];
int dp[M];
int que[M];

int up(int x,int y) {
return (POW(sum[y])-POW(sum[x])+dp[y]-dp[x]);
}
int down(int x,int y) {
return 2*(sum[y]-sum[x]);
}

void solve(int n,int m) {
memset(sum,0,sizeof(sum));

for (int i=1;i<=n;++i) {
int x;
scanf("%d",&x);
sum[i]=sum[i-1]+x;
}

dp[0]=0;
int L,R;
L=R=0;
que[R++]=0;

for (int i=1;i<=n;++i) {
//少用 double (double 有毒)
while (L+1<R&&sum[i]*down(que[L],que[L+1])>=up(que[L],que[L+1])) L++;
int to=que[L];
dp[i]=POW(sum[i]-sum[to])+m+dp[to];
while (L+1<R&&up(que[R-1],i)*down(que[R-2],que[R-1])<=up(que[R-2],que[R-1])*down(que[R-1],i)) R--;
que[R++]=i;
}
cout<<dp
<<endl;
}

int main() {
while (cin>>n>>m) {
solve(n,m);
}
return 0;
}