bzoj1010: [HNOI2008]玩具装箱toy

 bzoj 1010: [HNOI2008]玩具装箱toy

Description

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

Input

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

Output

　　输出最小费用

Sample Input

5 4
3
4
2
1
4

Sample Output

1

Analysis

方法一：

　　令f[i]表示把前i个玩具装好，并且第i个玩具是其所在箱子的结尾，使用的最小费用。

　　令w[i][j]表示把第i+1个玩具(为什么+1往下看)到第j个玩具装进一个箱子的费用，则w[i][j]=(j-i+∑c[i+1...j]-L)^2

　　那么f[i]=min{f[x]+w[x][i]}；(因为第x件不和第i件一起装进箱子，所以w[i][j]要设为i+1到j物品)

　　看到方程自然想到要证明决策是否满足单调性。

　　w[i][j]=(j-i-1+∑c[i+1 to j]-L)^2

　　w[i+1][j+1]=(j-i-1+∑c[i+2 to j+1]-L)^2

　　w[i+1][j]=(j-i+∑c[i+2...j]-L)^2

　　w[i][j+1]=(j-i+∑c[i+1][j+1]-L)^2

　　令t=j-i+∑c[i+1 to j]-L，x=c[i+1]，y=c[j+1]

　　那么w[i][j]=t^2，w[i+1][j+1]=(t-x+y)^2，w[i+1][j]=(t-x)^2，w[i][j+1]=(t+y)^2

　　作差：( w[i][j]+w[i+1][j+1] ) - ( w[i+1][j]+w[i][j+1] ) = ...各种化简... = -2xy

　　∵x>0,y>0

　　∴( w[i][j]+w[i+1][j+1] ) - ( w[i+1][j]+w[i][j+1] ) = -2xy < 0

　　即 w[i][j]+w[i+1][j+1] <  w[i+1][j]+w[i][j+1]

　　因此这个方程具有决策单调性

　　所以我们就可以维护一个栈，存一些区间，然后用二分什么的各种乱搞就行了

　　All in all，复杂度O(NlogN)

代码

//[HNOI2008]玩具装箱toy 决策单调性DP 
#include <cstdio>
#define ll long long
#define maxn 60000
using namespace std;
struct interval{ll l, r, k;}s[maxn];
ll c[maxn], ss[maxn], L, N, f[maxn], top;
void init()
{
	ll i, j;
	scanf("%lld%lld",&N,&L);
	for(i=1;i<=N;i++)scanf("%lld",&c[i]),ss[i]=ss[i-1]+c[i];
}
ll w(ll i, ll j)
{
	ll t=j-i-1+ss[j]-ss[i]-L;
	return t*t;
}
ll update(ll x, ll y)
{return x<y?f[x]+w(x,y):f[y]+1;}
ll find(interval it, ll x)
{
	ll l=it.l, r=it.r, mid=(l+r)>>1;
	while(l<r)
	{
		if(update(x,mid)<update(it.k,mid))r=mid;
		else l=mid+1;
		mid=(l+r)>>1;
	}
	return update(x,l)<update(it.k,l)?l:it.r+1;
}
ll work()
{
	ll i, j, x, k, l, r, mid;
	interval t;
	f[1]=(c[1]-L)*(c[1]-L);
	s[++top]=(interval){1,N,0};
	for(i=1,j=1;i<=N;i++)
	{
		if(s[j].r<i)j++;
		f[i]=update(s[j].k,i);
		while(1)
		{
			t=s[top];
			if(update(i,t.r)<update(t.k,t.r))
			{
				if(update(i,t.l)<update(t.k,t.l)){top--;continue;}
				else
				{
					x=find(t,i);
					s[top].r=x-1;
					break;
				}
			}
			else break;
		}
		if(s[top].r<N)s[top+1]=(interval){s[top++].r+1,N,i};
	}
}
int main()
{
	init();
	work();
	printf("%lld\n",f[N]);
	return 0;
}

方法二：

斜率优化

f[i]

=f[j]+w[i,j]

=f[j]+(i-j-1+s[i]-s[j]-L)　　其中s表示前缀和

=f[j]+[(i+s[i])-(j+s[j])+(-L-1)]^2

令a[k]=k+s[k]，t=-L-1

则f[i]

=f[j]+(a[i]-a[j]+t)^2

=f[j]+a[i]^2+a[j]^2+t^2+2t[i]-2ta[j]-2a[i]a[j]

=(f[j]+a[j]^2-2ta[j])-2a[i]a[j]+(2ta[i]+t^2+a[i]^2)

令b[j]=f[j]+a[j]^2-2ta[j]

则f[i]=b[j]-2a[i]*a[j]+2ta[i]+t^2+a[i]^2

当我们枚举i的时候，和i相关的一切看作是常数

原方程化为b[j]=2a[i]*a[j]+f[i]+(2ta[i]+t^2+a[i]^2)

我们的目的是最小化f[i]

根据线性规划的知识，上式中f[i]可以看做是斜率为a[i]的直线的截距，我们需要选择一个点（也就是(a[j],b[j])）使直线经过这个点且截距最大，易知这个点一定在下凸壳上。

这个题目中由于a[i]=s[i]+i所以是单调的，因此可以使用单调队列来维护下凸壳。

代码

//玩具装箱 斜率优化 
#include <cstdio>
#define maxn 50010
#define ll long long
using namespace std;
ll f[maxn], a[maxn], b[maxn], N, L, t;
struct point{ll x,y;double k;}q[maxn];
ll read(ll x=0){scanf("%lld",&x);return x;}
void input()
{
	ll i, s=0, c;
	N=read(),L=read(),t=-L-1;
	for(i=1;i<=N;i++)
	{
		c=read();
		s+=c;
		a[i]=s+i;
	}
}
void solve()
{
	ll i, j, l=1, r=1;
	q[r++]=(point){0,0};
	for(i=1;i<=N;i++)
	{
		while(l<r-1 and 2*a[i]>q[l+1].k)l++;
        f[i]=q[l].y-2*a[i]*q[l].x+t*t+2*t*a[i]+a[i]*a[i];
        b[i]=f[i]+a[i]*a[i]-2*t*a[i];
        while(r>l+1 and 1.0*(b[i]-q[r-1].y)/(a[i]-q[r-1].x)<q[r-1].k)r--;
        q[r]=(point){a[i],b[i],1.0*(b[i]-q[r-1].y)/(a[i]-q[r-1].x)};r++;
    }
}
int main()
{
	input();
	solve();
	printf("%lld\n",f[N]);
	return 0;
}