Poj1180 Batch Scheduling --- DP的斜率优化

题意

N个任务排成一个序列在一台机器上等待完成（顺序不得改变），这N个任务被分成若干批，每批包含相邻的若干任务。从时刻0开始，这些任务被分批加工，第i 个任务单独完成所需的时间是Ti。在每批任务开始前，机器需要启动时间S，而完成这批任务所需的时间是各个任务需要时间的总和（同一批任务将在同一时刻完 成）。每个任务的费用是它的完成时刻乘以一个费用系数Fi。请确定一个分组方案，使得总费用最小。

算法讨论

毫无疑问DP.转移方程：dp[i]=Min{dp[j]+(sumF[i]-sumF[j])*sumT[i]+s*(sumF[N]-sumF[j])},其中dp[i]表示的是完成1~i的工作的花费+因为开机启动时间所浪费的后面的花费。

但是这个转移方程的复杂度是O（N^2）的，如果RP好的话可以试试~但是显然，我们有更强大的方法：斜率优化。

至于什么是斜率优化……可以百度一下“斜率优化”……

只说说这道题的证明：

设G[i,j]表示dp[i]的决策为j时的dp[i]值。

设j1<j2,且G[i,j1]<G[i,j2](即以j1为决策时优于j2)

G[i,j1]=dp[j1]-sumF[j1]*sumT[i]-s*sumF[j1]+s*sumF[N]+sumF[i]*sumT[i]

G[i,j2]=dp[j2]-sumF[j2]*sumT[i]-s*sumF[j2]+s*sumF[N]+sumF[i]*sumT[i]

G[i,j1]-G[i,j2]=(dp[j1]-s*sumF[j1])-(dp[j2]-s*sumF[j2])-sumT[i]*(sumF[j1]-sumF[j2])<0

整理得

【(dp[j1]-s*sumF[j1])-(dp[j2]-s*sumF[j2])】

---------------------------------------------------------------------     > sumT[i]

　　　　(sumF[j1]-sumF[j2])

又因为sumT[i]单调不降

所以最优决策单调

那么维护一个队列就可以了。

参考代码：

# include <iostream>
# include <cstdio>
# include <cmath>
using namespace std;
const int maxN=10005;
long long dp[maxN],f[maxN],t[maxN],N,s;
long long calc(int,int);
int slope(int,int,int);

int main()
{
	int seq[maxN],fi,ti,l=1,r=1;
	seq[1]=0;
	scanf("%lld",&N);scanf("%lld",&s);
	for (int i=1;i<=N;i++){
		scanf("%d%d",&ti,&fi);t[i]=t[i-1]+ti;f[i]=f[i-1]+fi;
	}
	for (int i=1;i<=N;i++){
		while ((l<r)&&(calc(i,seq[l])>calc(i,seq[l+1]))) l++;
		dp[i]=calc(i,seq[l]);
		while ((l<r)&&(slope(seq[r],seq[r-1],i))) r--;
		seq[++r]=i;
	}
	printf("%lld\n",dp[N]);
	return 0;
}

long long calc(int i,int j)
{
	return dp[j]+(f[i]-f[j])*t[i]+s*(f[N]-f[j]);
}

int slope(int i,int j,int k)
{
	long long imj=((dp[k]-s*f[k])-(dp[i]-s*f[i]))*(f[k]-f[j]);
	long long jmi=((dp[k]-s*f[k])-(dp[j]-s*f[j]))*(f[k]-f[i]);
	return imj<jmi;
}