【动态规划】Batch Scheduling

原创 2012年03月25日 19:34:35
Description
There is a sequence of N jobs to be processed on one machine. The jobs are numbered from 1 to N,
so that the sequence is 1,2,..., N. The sequence of jobs must be partitioned into one or more
batches, where each batch consists of consecutive jobs in the sequence. The processing starts at
time 0. The batches are handled one by one starting from the first batch as follows. If a batch b
contains jobs with smaller numbers than batch c, then batch b is handled before batch c. The jobs
in a batch are processed successively on the machine. Immediately after all the jobs in a batch
are processed, the machine outputs the results of all the jobs in that batch. The output time of
a job j is the time when the batch containing j finishes.

A setup time S is needed to set up the machine for each batch. For each job i, we know its cost
factor Fi and the time Ti required to process it. If a batch contains the jobs x, x+1,... , x+k,
and starts at time t, then the output time of every job in that batch is t + S + (Tx + Tx+1 + ...
+ Tx+k). Note that the machine outputs the results of all jobs in a batch at the same time. If the
output time of job i is Oi, its cost is Oi * Fi. For example, assume that there are 5 jobs, the
setup time S = 1, (T1, T2, T3, T4, T5) = (1, 3, 4, 2, 1), and (F1, F2, F3, F4, F5) = (3, 2, 3, 3,
4). If the jobs are partitioned into three batches {1, 2}, {3}, {4, 5}, then the output times (O1,
O2, O3, O4, O5) = (5, 5, 10, 14, 14) and the costs of the jobs are (15, 10, 30, 42, 56), respectively.
The total cost for a partitioning is the sum of the costs of all jobs. The total cost for the example
partitioning above is 153.

You are to write a program which, given the batch setup time and a sequence of jobs with their
processing times and cost factors, computes the minimum possible total cost.

Input
Your program reads from standard input. The first line contains the number of jobs N, 1 <= N <=
10000. The second line contains the batch setup time S which is an integer, 0 <= S <= 50. The
following N lines contain information about the jobs 1, 2,..., N in that order as follows. First
on each of these lines is an integer Ti, 1 <= Ti <= 100, the processing time of the job. Following
that, there is an integer Fi, 1 <= Fi <= 100, the cost factor of the job.

Output
Your program writes to standard output. The output contains one line, which contains one integer:
the minimum possible total cost.

Sample Input
5
1
1 3
3 2
4 3
2 3
1 4

Sample Output
153

不难想出一个比较简单的方程:
f[i] = min{f[j] + (out[j] + S + sumT[i] - sumT[j]) * (sumF[i] - sumF[j])}。

但是这个方程中有两个变量(out[j] - sumT[j]和sumF[j]),所以无法使用斜率+单调队列优化。

所以改正推为倒推(将前面所说的前缀和改为后缀和)。

新的转移方程:f[i] = max{f[j] + (S + sumT[i] - sumT[j]) * sumF[i]}。

这下使用斜率优化就变得很简单了。

很容易得到斜率不等式:
     f[f] - f[k]
—————————— >= sumF[i]
  sumT[j] - sumT[k]

那么斜率优化就顺理成章了。
Accode:

#include <cstdio>
#include <cstdlib>
#include <string>
#include <algorithm>

const int maxN = 10010;
typedef long long int64;
int64 F[maxN], sT[maxN], sF[maxN], S;
int q[maxN], n, f = 0, r = 1;

inline int getint()
{
    int res = 0; char tmp;
    while (!isdigit(tmp = getchar()));
    do res = (res << 3) + (res << 1) + tmp - '0';
    while (isdigit(tmp = getchar()));
    return res;
}

#define check(j, k, i) \
(F[j] - F[k] <= sF[i] * (sT[j] - sT[k]))

#define cmp(j, k, i) \
((F[j] - F[k]) * (sT[k] - sT[i]) \
<= (F[k] - F[i]) * (sT[j] - sT[k]))

int main()
{
    freopen("batch_scheduling.in", "r", stdin);
    freopen("batch_scheduling.out", "w", stdout);
    n = getint(); S = getint();
    for (int i = 1; i < n + 1; ++i)
    {
        sT[i] = getint(); sF[i] = getint();
    }
    sT[n + 1] = sF[n + 1] = 0;
    q[0] = n + 1;
    for (int i = n; i; --i)
    {
        sT[i] += sT[i + 1]; sF[i] += sF[i + 1];
        while (f < r - 1 && !check(q[f], q[f + 1], i)) ++f;
        F[i] = F[q[f]] + (S + sT[i] - sT[q[f]]) * sF[i];
        while (f < r - 1 && !cmp(q[r - 2], q[r - 1], i)) --r;
        q[r++] = i;
    }
    printf("%I64d\n", F[1]);
    return 0;
}

uva 1380 - A Scheduling Problem 一个调度问题 好难的动态规划

想不出来啊!!!,紫书上写的很清楚。 1.利用题目给出的图论定理,先不考虑无向边,假如图中有向链的最大长度为K,那么答案为K+1或K+2(注意是K链的长度,答案是链包含点的个数)。 2.考虑答...

动态规划 源码

  • 2017年10月31日 10:51
  • 12KB
  • 下载

poj 1180 Batch Scheduling ( 斜率优化DP )

/* N个任务排成一个序列在一台机器上等待完成(顺序不得改变),这N个任务被分成若干批,每批包含相邻的若干任务。 从时刻0开始,这些任务被分批加工,第i个任务单独完成所需的时间是Ti。在每批任务开始...
  • SYLG_li
  • SYLG_li
  • 2012年09月29日 14:09
  • 433

动态规划,建桥问题代码

  • 2017年11月09日 17:06
  • 340KB
  • 下载

POJ 1180 Batch Scheduling

斜率优化DP 题意:给你N个jobs,要你去用一台或多台机器  顺序  完成,然后每一台机器启动之前需要S的时间去准备; 如果一台机器要完成3个jobs,那么这3个jobs完成的时间就都是  tt  ...
  • Mr_Xujh
  • Mr_Xujh
  • 2015年09月08日 00:16
  • 912

算法之动态规划

  • 2016年01月05日 07:48
  • 5KB
  • 下载

逐时段摄动动态规划poa

  • 2015年11月28日 14:49
  • 32KB
  • 下载

Poj1180 Batch Scheduling --- DP的斜率优化

题意 N个任务排成一个序列在一台机器上等待完成(顺序不得改变),这N个任务被分成若干批,每批包含相邻的若干任务。从时刻0开始,这些任务被分批加工,第i 个任务单独完成所需的时间是Ti。在每批任务开始...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【动态规划】Batch Scheduling
举报原因:
原因补充:

(最多只允许输入30个字)