[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$个任务分成若干批的最小费用，所以这道题的状态转移方程可以写成

\[dp[i]=dp[j]+(sumf[i]-sumf[j])*sumt[i]+s*(sumf[N]-sumf[j])(0<=j<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$的乘积项分开。

\[dp[i]=min(dp[j]-(S+sumt[i])*sumf[i])
\]

\[+sumt[i]*sumf[i]+S*sumf[N]
\]

把$min$函数去掉，把关于$j$的值$dp[j]$和$sumf[i]$看作变量，把其余部分看作常量，得到：

\[dp[i]=(S+sumt[i])*sumf[j]+dp[i]-sumt[i]*sumf[i]-S*sumf[N]
\]

在$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成为最优决策，当且仅当:

\[\frac{dp[j2]-dp[j1]}{sumf[j2]-sumf[j1]}<\frac{dp[j3]-dp[j2]}{sumf[j3]-sumf[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];
}