[Luogu2365]任务安排(斜率优化)

Posted 2020-11-07 Frozen_Heart（AFO）

[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];
}