### IOI '02 - Yong-In, Korea

## Batch Scheduling

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 *F*_{i} and the time *T*_{i} 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* + (*T*_{x}
+ *T*_{x+1} + … + *T*_{x+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 *O*_{i}, its cost is
*O*_{i} × *F*_{i}. For example, assume that
there are 5 jobs, the setup time *S* = 1, (*T*_{1}, *T*_{2},
*T*_{3}, *T*_{4}, *T*_{5}) = (1, 3, 4, 2, 1), and
(*F*_{1}, *F*_{2}, *F*_{3}, *F*_{4},
*F*_{5}) = (3, 2, 3, 3, 4). If the jobs are partitioned into three batches {1, 2}, {3}, {4, 5},
then the output times (*O*_{1}, *O*_{2}, *O*_{3},
*O*_{4}, *O*_{5}) = (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*, an integer between 0 and 50 inclusive. 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

*T*

_{i}(1 ≤

*T*

_{i}≤ 100), the processing time of the job. Following that, there is an integer

*F*

_{i}(1 ≤

*F*

_{i}≤ 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. This is guaranteed to be less than 2^{31}.

### Sample Input 1

2 50 100 100 100 100

### Sample Output 1

45000

### Sample Input 2

5 1 1 3 3 2 4 3 2 3 1 4

### Sample Ouptut 2

153

Sample Case 2 is the example presented in the text.

All Submissions

Best Solutions

**Point Value:** 17 (partial)

**Time Limit:** 1.00s

**Memory Limit:** 64M

**Added:** Jun 02, 2010

**Languages Allowed:**

C++03, PAS, C, HASK, ASM, RUBY, PYTH2, JAVA, PHP, SCM, CAML, PERL, C#, C++11, PYTH3

## Comments (Search)

framon May 16, 2015 - 6:09:15 pm UTC wall clockI submitted the same code multiple times and every time I got some "wall clock" TLE, until I got lucky and got 100/100... The strange thing is that the affected test cases changed every time!

kobortoron Jul 26, 2015 - 4:35:20 am UTC Re: wall clockEdit: It's ridiculous that my O(N^2) solution passes but my O(N) hits the wall clock thing.