[Luogu2365]任务安排
题目描述
N个任务排成一个序列在一台机器上等待完成（顺序不得改变），这N个任务被分成若干批，每批包含相邻的若干任务。从时刻0开始，这些任务被分批加工，第i个任务单独完成所需的时间是Ti。在每批任务开始前，机器需要启动时间S，而完成这批任务所需的时间是各个任务需要时间的总和（同一批任务将在同一时刻完成）。每个任务的费用是它的完成时刻乘以一个费用系数Fi。请确定一个分组方案，使得总费用最小。
例如：S=1；T={1,3,4,2,1}；F={3,2,3,3,4}。如果分组方案是{1,2}、{3}、{4,5}，则完成时间分别为{5,5,10,14,14}，费用C={15,10,30,42,56}，总费用就是153。
输入输出格式
输入格式：
第一行是N(1<=N<=5000)。
第二行是S(0<=S<=50)。
下面N行每行有一对数，分别为Ti和Fi，均为不大于100的正整数，表示第i个任务单独完成所需的时间是Ti及其费用系数Fi。
输出格式：
一个数，最小的总费用。
输入输出样例
输入样例：
5
1
1 3
3 2
4 3
2 3
1 4
输出样例：
153
这类将一列东西分批处理，并且每分一批会对后面的答案造成影响的dp题目基本都可以用一种方法处理，将其对后续产生的影响直接算入这次的答案里面。
考虑这道题目，由于时间复杂度只能承受(O(N^2))，所以我们只能枚举当前的(i)和之前的某个任务(j)，无法得知之前已经启动了几次。但我们知道，机器因为执行这个任务而花费的启动时间(S)，会累加到在此之后所有任务的完成时刻上。设(dp[i])表示把前(i)个任务分成若干批的最小费用，所以这道题的状态转移方程可以写成
(sumf[i])和(sumt[i])为前缀和数组
在上式中，第(j+1)～(i)个任务在同一批内完成，(sunt[i])是忽略机器启动时，这批任务的完成时刻。因为这批任务的执行，机器的启动时间(S)会对第(j+1)个之后的所有任务产生影响，故我们把这部分影响补充到费用中。
也就是说，我们没有直接求出每批任务的完成时刻，而是在一批任务"开始"后对后续任务产生影响时，就先把费用累计到答案中。这是名为费用提前计算的经典思想。
该解法的时间复杂度为(O(N^2))。
#include<bits/stdc++.h>
using namespace std;
int read()
{
int x=0,w=1;char ch=getchar();
while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return x*w;
}
int sumt[5010],sumf[5010],dp[5010];
int main()
{
memset(dp,0x3f,sizeof(dp));
int n=read(),s=read(),ti,fi;
for(int i=1;i<=n;i++)
{
ti=read();fi=read();
sumt[i]=sumt[i-1]+ti;
sumf[i]=sumf[i-1]+fi;
}
dp[0]=0;
for(int i=1;i<=n;i++)
{
for(int j=0;j<i;j++)
{
if(dp[i]>dp[j]+(sumf[i]-sumf[j])*sumt[i]+s*(sumf[n]-sumf[j]))
{
dp[i]=dp[j]+(sumf[i]-sumf[j])*sumt[i]+s*(sumf[n]-sumf[j]);
}
}
}
cout<<dp[n];
}
但是我们考虑当数据范围变大时
数据范围：(1<=N<=3*10^5,1<=S,Ti,Fi<=512)
这时候我们发现(O(N^2))做不了了，我们想办法把算法时间复杂度优化成(O(N*logN))
先对状态转移方程稍作变形，把常数，仅与(i)有关的项、仅与(j)有关的项以及(i,j)的乘积项分开。
把(min)函数去掉，把关于(j)的值(dp[j])和(sumf[i])看作变量，把其余部分看作常量，得到：
在(sumf[j])为横坐标，(dp[j])为纵坐标的平面直角坐标系中，这是一条以(S+sumt[i])为斜率，(dp[i]-sumt[i]*sumf[i]-S*sumf[N])为截距的直线，也就是说，决策候选集合是坐标系中的一个点集，每个决策(j)都对应着坐标系中的一个点((sumf[j],dp[j]))。每个待求解的状态(dp[i])都对应着一条直线的截距，直线的斜率是一个固定的值(S+sumt[i])，截距未知。当截距最小化的时候，dp[i]也取到最小值。
令直线过每个决策点((sumf[j],dp[j]))，都可以解出一个截距，其中使截距最小的一个就是最优决策。体现在坐标系中，就是一条斜率固定为正整数的斜线自下而上平移，第一次接触到某个决策点时，就得到了最小截距。(没找到图片，自行yy一下)。
对于任意三个决策点((sumf[j1],dp[j1]),(sumf[j2],dp[j2]),(sumf[j3],dp[j3]))，不妨设(j1<j2<j3)，因为(T,F)均为正整数，亦有(sumf[j1]<sumf[j2]<sumf[j3])。根据及时排除无用决策的思想，j2成为最优决策，当且仅当:
不等号两边实际上都是连接两个决策点线段的斜率。通俗的讲，我们应该维护连接相邻两点的线段斜率单调递增的一个下凸壳。(在斜率优化中，我们一般称"连接相邻两点的线段斜率"单调递增的一组顶点构成下凸壳，称"连接相邻两点的线段斜率"单调递减的一组顶点构成上凸壳)只有这个下凸壳上的点才有可能成为最优决策。实际上，对于一条斜率为(k)的直线，若某个顶点左侧线段的斜率比(k)小、右侧线段的斜率比(k)大，则该点(k)为最优决策。
在本题中，(j)的取值范围是(0<=j<i)，随着(i)的增大，每次会有一个新的决策进入候选集合。因为(sumf)的单调性，新决策在坐标系中的横坐标一定大于之前的所有决策，出现在整个凸壳的最右端。另外，因为(sumt)的单调性，每次求解最小截距的直线斜率(S+sumt[i])也单调递增，如果我们只保留凸壳上相邻两点的线段斜率大于(S+sumt[i])的部分，那么凸壳的最左端顶点一定就是最优决策。
综上所述，我们可以建立单调队列(q)，维护这个下凸壳。队列中保存若干个决策变量，它们对应凸壳上的顶点，且满足横坐标(sumf)递增、相邻两点的线段斜率也递增。需要支持的操作有：
1.检查队头的两个决策变量(q[l])和(q[l+1])，若斜率(frac{dp[q[l+1]-dp[q[l]]}{sumf[q[l+1]]-sumf[q[l]]}<=S+sumt[i])，则把(q[l])出队，继续检查新的队头。
2.直接取队头(j=q[l])为最优决策，执行状态转移，更新dp[i]。
3.把新决策(i)从队尾插入，在插入之前，若三个决策点(j1=q[r-1],j2=q[r],j3=i)不满足斜率单调递增(不满足下凸性，即(j2)是无用决策)，则直接从队尾把(q[r])出队，继续检查新的队尾。
整个算法的时间复杂度为(O(N))。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
int read()
{
int x=0,w=1;char ch=getchar();
while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return x*w;
}
int sumt[5010],sumf[5010],dp[5010],team[5010];
int main()
{
memset(dp,0x3f,sizeof(dp));
int n=read(),s=read(),ti,fi;
for(int i=1;i<=n;i++)
{
ti=read();fi=read();
sumt[i]=sumt[i-1]+ti;
sumf[i]=sumf[i-1]+fi;
}
int l=1,r=1;
dp[0]=0;
for(int i=1;i<=n;i++)
{
while(l<r&&dp[team[l+1]]-dp[team[l]]<=(sumf[team[l+1]]-sumf[team[l]])*(s+sumt[i]))
l++;
dp[i]=dp[team[l]]+sumt[i]*(sumf[i]-sumf[team[l]])+s*(sumf[n]-sumf[team[l]]);
while(l<r&&(dp[team[r]]-dp[team[r-1]])*(sumf[i]-sumf[team[r]])>=(dp[i]-dp[team[r]])*(sumf[team[r]]-sumf[team[r-1]])) r--;
team[++r]=i;
}
cout<<dp[n];
}