任务安排

任务安排

描述
有N个任务排成一个序列在一台机器上等待执行，它们的顺序不得改变。机器会把这N个任务分成若干批，每一批包含连续的若干个任务。从时刻0开始，任务被分批加工，执行第 i 个任务所需的时间是 T_i。另外，在每批任务开始前，机器需要S的启动时间，故执行一批任务所需的时间是启动时间S加上每个任务所需时间之和。
一个任务执行后，将在机器中稍作等待，直至该批任务全部执行完毕。也就是说，同一批任务将在同一时刻完成。每个任务的费用是它的完成时刻乘以一个费用系数 C_i。请为机器规划一个分组方案，使得总费用最小。

例如：S=1；T={1,3,4,2,1}；C={3,2,3,3,4}。如果分组方案是{1,2}、{3}、{4,5}，则完成时间分别为{5,5,10,14,14}，费用 {15,10,30,42,56}，总费用就是153。

输入格式

第一行是N(1<=N<=5000)。
第二行是S(0<=S<=50)。
下面N行每行有一对数，分别为Ti和Ci，均为不大于100的正整数，表示第i个任务单独完成所需的时间是Ti及其费用系数Fi。

输出格式
一个数，最小的总费用。

样例输入
5
1
1 3
3 2
4 3
2 3
1 4
样例输出
153
数据范围与约定
1≤N≤5000,1≤S≤50,1≤T_i,C_i≤100

题解：
一看是一道区间的题，马上想到DP、段树或者是单调队列；
先来一波暴力：

#include<bits/stdc++.h>
using namespace std;
int N,S;
struct oo{
	int t,c;
}work[5005];
int dp[5005][5005];
int ans=0x3f3f3f;
int main(){
	cin>>N;
	cin>>S;
	memset(dp,0x3f3f3f,sizeof(dp));
	dp[0][0]=0;
	for(int i=1;i<=N;i++){
		cin>>work[i].t>>work[i].c;
		work[i].t+=work[i-1].t;
		work[i].c+=work[i-1].c;	
		dp[0][i]=0;
	}
	for(int i=1;i<=N;i++){
		for(int j=1;j<=i;j++){
			for(int k=0;k<i;k++){
				dp[i][j]=min(dp[i][j],dp[k][j-1]+(S*j+work[i].t)*(work[i].c-work[k].c));
			}
		}
	}
	for(int i=1;i<=N;i++){
		ans=min(ans,dp[N][i]);
	}
	cout<<ans;
} 

暴力应该还是很好想的，就是一个毫无优化的DP嘛，dp[i][j]就表示前i个分作j批
这是稍稍优化一点的：

#include<bits/stdc++.h>
using namespace std;
long long N,S;
struct oo{
	long long t,c;
}work[5005];
long long dp[5005];
long long ans=0x3f3f3f;
int main(){
	cin>>N;
	cin>>S;
	memset(dp,0x3f3f3f,sizeof(dp));
	dp[0]=0;
	for(int i=1;i<=N;i++){
		cin>>work[i].t>>work[i].c;
		work[i].t+=work[i-1].t;
		work[i].c+=work[i-1].c;	
	}
	for(int i=1;i<=N;i++){
		for(int j=0;j<i;j++){
			dp[i]=min(dp[i],dp[j]+(work[i].c-work[j].c)*work[i].t+S*(work[N].c-work[j].c));
		}
	}
	cout<<dp[N];
} 

在优化一点呢就是提出来：

#include<bits/stdc++.h>
using namespace std;
long long N,S;
struct oo{
	long long t,c;
}work[10005];
long long dp[10005];
long long ans=0x3f3f3f;
int main(){
	cin>>N;
	cin>>S;
	memset(dp,0x3f3f3f,sizeof(dp));
	dp[0]=0;
	for(int i=1;i<=N;i++){
		cin>>work[i].t>>work[i].c;
		work[i].t+=work[i-1].t;
		work[i].c+=work[i-1].c;	
	}
	for(int i=1;i<=N;i++){
		long long I=0x3f3f3f;
		for(int j=0;j<i;j++){
			I=min(I,dp[j]-work[j].c*work[i].t-S*work[j].c);
		}
		dp[i]=I+work[i].c*work[i].t+S*work[N].c;
	}
	cout<<dp[N];
}

再优化一点就是单调队列和斜率优化了：大家可以看我另一篇博客