码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2018-05-20 21:54:19      阅读:183      评论:0      收藏:0      [点我收藏+]

标签:size   return   set   转移   序列   没有   pac   加工   span   

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

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

标签:size   return   set   转移   序列   没有   pac   加工   span   

原文地址:https://www.cnblogs.com/lsgjcya/p/9064670.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!