SOJ 1717 Computer (单机任务调度)

一、题目描述

Constraints ：Time Limit: 2 secs, Memory Limit: 32 MB

Description:

　　We often hear that computer is a magic, a great invention, or even a marvel. But actually computer is just a tool people use everyday. It is a machine that can help people to process many jobs effectively. Moreover, without computer, you can not play ICPC. So, guys, let’s study some stuff about computer here.
　　One computer has one CPU (Central Processing Unit). CPU can be idle or processing one job at any time. Jobs come randomly and are stored in the memory until finished. CPU will process jobs according to some strategies. The processing job can be interrupted and saved back so that CPU can be available for other jobs. 
　　Each job has a release time and a processing time. Assume that we know the schedule of all jobs, please generate a program to minimize the sum of completion times of all jobs using a strategy which assigns and interrupts jobs properly.
　　For example, suppose there are two jobs to be completed. Job 1 is released at time 1 and needs 4 time units to process. Job 2’s release time and processing time is 3 and 1. Figures below show three solutions:

　　Figure 1 shows a solution with the total complete time 4 + 6 = 10, and the result of Figure 2 and 3 are both 5 + 6 = 11. In fact, Figure 1 shows the optimal solution 
Please note that all of the jobs will be released, interrupted and assigned in integer time unit.

Input:

　　Input may consist of multiple test cases.
　　Every test case begins with a line that contains one integer n (1<= n <= 50000) denoting the number of jobs. Each of the following n lines contains 2 integers: ri and pi, (1 <= ri <= 10^9, 1 <= pi <= 10000) denoting the release time and processing time of job i.
　　Input is terminated by EOF.

Output:

　　For every test case, print one line with an integer denoting the minimum sum of completion times.

Sample Input

　　2
　　1 4
　　3 1
Sample Output

　　10

二、问题解决

　　1、题意：单机任务调度，模拟CPU工作方式，CPU每个时刻只能处理一个任务，给出每个任务的release时间和process时间，设计调度算法，使所有任务完成时间总和最小。

　　2、思路：贪心思想，每次处理process时间最短的任务。

　　具体步骤：用循环模拟CPU，每个循环表示一个CPU时间。全局维护一个待处理的最小任务优先队列que，即剩余process时间短的任务优先。每次循环中：（1）取出que中top元素，将其剩余process时间减1，即CPU此时刻处理该任务，减到0则记录该任务完成时间；（2）将该时间刻release的任务加入等候队列que中。

　　3、代码：基于上面的思路，可以写出下面的代码。

 // Problem#: 1717
 #include <iostream>
 #include <cstdio>
 #include <queue>
 #include <algorithm>
 using namespace std;
 const int MAX = ;
 struct Job
 {
     int r,p;
     bool operator < (const Job &job) const {
         if(r == job.r) return p < job.p;
         else return r < job.r;
     }
 };
 Job jobs[MAX];

 int main() {
     int n;
     while(scanf("%d",&n) != EOF) {
         for(int i = ; i < n; ++i) {
             scanf("%d%d", &jobs[i].r, &jobs[i].p);
         }
         sort(jobs,jobs+n);

         priority_queue<int,vector<int>,greater<int> > que;
         long long ans = ;
         int cnt = , cur = , tmp;

         que.push(jobs[].p);
         for(long long i = jobs[].r; ;++i) {
             tmp = que.top(); que.pop();
             if (tmp- == ) {
                 ans = ans+i;
                 cnt += ;
                 if(cnt == n) break;
             }
             else que.push(tmp-);
             while(cur < n && jobs[cur].r <= i) {
                 que.push(jobs[cur++].p);
             }
         }
         printf("%lld\n",ans);
     }
     return ;
 }                                 

暴力代码

　　4、进一步分析：虽然思路对了，但上面代码明显会超时。

　　这时考虑加快cpu工作速度，即不是模拟CPU每个时刻处理的任务，而是考虑每个任务能否一次性完成。大概思路是这样，取出que中最小任务时间，判断在下一个任务release时刻（距离上一任务process时刻会有一段时间间隔），该任务能否完成，若能完成，就可以缩短时间间隔，继续判断下一任务；若不能完成，则将该任务process时间减去时间间隔，重新加入que，并将下一任务加入que。

代码如下：

 // Problem#: 1717
 #include <iostream>
 #include <cstdio>
 #include <queue>
 #include <algorithm>
 using namespace std;
 const int MAX = ;
 struct Job
 {
     int r,p;
     bool operator < (const Job &job) const {
         if(r == job.r) return p < job.p;
         else return r < job.r;
     }
 };
 Job jobs[MAX];

 int main() {
     int n;
     while(scanf("%d",&n) != EOF) {
         for(int i = ; i < n; ++i) {
             scanf("%d%d", &jobs[i].r, &jobs[i].p);
         }
         sort(jobs,jobs+n);

         priority_queue<int,vector<int>,greater<int> > que;
         long long ans = ;
         int i = , cnt = , cur, tmp；
         int pre = jobs[].r;  //前一任务处理时刻
         int cur_time = jobs[].r;   //当前时刻

         que.push(jobs[].p);
         while(true) {
             cur = que.top(); que.pop();
             if (i >= n) {
                 cur_time += cur;
                 ans += cur_time;
                 cnt += ;
                 if (cnt == n) break;
                 continue;
             }
             tmp = jobs[i].r - pre;
             if (cur <= tmp) {
                 cur_time += cur;
                 ans += cur_time;
                 cnt += ;
                 pre = cur_time;
                 if (cnt == n) break;
                 if (!que.empty()) continue;   //时间间隔缩短，能否继续处理que中剩余任务
             }else {
                 que.push(cur-tmp);
                 cur_time = jobs[i].r;
             }
             pre = jobs[i].r;
             cur_time = pre;
             while(i < n && jobs[i].r == pre)
                 que.push(jobs[i++].p);
         }

         printf("%lld\n",ans);
     }
     return ;
 }                                     

结果超出我的想象，折磨了2个小时，感觉智商远远不够用啊！