hdu题3413—基础算法（模拟题）

单核CPU多任务调度

最新推荐文章于 2018-11-04 14:02:00 发布

原创最新推荐文章于 2018-11-04 14:02:00 发布 · 585 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hdu

hdu—基础算法（模拟）专栏收录该内容

1 篇文章

订阅专栏

本文探讨了单核CPU如何通过巧妙的任务调度实现多任务处理，重点介绍了一种简单但有效的解决方案，使得用户能感受到任务并行执行的效果。

Single CPU, multi-tasking

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 582 Accepted Submission(s): 204

Problem Description

Tuntun is a big fan of Apple Inc. who owns almost all kinds of products the company published. Fascinated by the amazing user experience and fabulous user interface, he spent every nickel of his pocket money on his iMac and iPhone. A few days ago, Apple released their latest iPhone OS 4.0. Tuntun noticed that the most significant new feature of iPhone OS 4.0 is multi-tasking support. He was curious about why the same device with a single core CPU can support multi-tasking under the new operating system. With his clever head, he found out a simple solution. The OS doesn’t have to let the CPU run several tasks exactly at the same time. What the OS should do is just to let the user feel that several tasks are running at the same time. In order to do that, the OS assigns the CPU to the tasks in turn. When the acts of reassigning a CPU from one task to another occur frequently enough, the illusion of parallelism is achieved. Let’s suppose that the OS makes each task run on the CPU for one millisecond every time in turn, and when a task is finished, the OS assigns the CPU to another task immediately. Now if there are 3 tasks which respectively need 1.5, 4.2 and 2.8 millisecond to complete, then the whole process is as follows:

At 0th millisecond, task 1 gets the CPU. After running for 1 millisecond, it still needs 0.5 milliseconds to complete.

At 1st millisecond, task 2 gets the CPU. After running for 1 millisecond, it still needs 3.2 milliseconds to complete.

At 2st millisecond, task 3 gets the CPU. After running for 1 millisecond, it still needs 1.8 milliseconds to complete.

At 3rd millisecond, task 1 comes back to CPU again. After 0.5 millisecond of running, it is finished and will never need the CPU.

At 3.5 millisecond, task 2 gets the CPU again. After running for 1 millisecond, it still needs 2.2 milliseconds to complete.

At 4.5 millisecond, it’s time for task 3 to run. After 1 millisecond, it still needs 0.8 milliseconds to complete.

At 5.5 millisecond, it’s time for task 2 to run. After 1 millisecond, it still needs 1.2 milliseconds to complete.

At 6.5 millisecond, time for task 3. It needs 0.8 millisecond to complete, so task 3 is finished at 7.3 milliseconds.

At 7.3 millisecond, task 2 takes the CPU and keeps running until it is finished.
At 8.5 millisecond, all tasks are finished.

Tuntun decided to make a simple iPhone multi-tasking OS himself, but at first, he needs to know the finishing time of every task. Can you help him?

Input

The first line contains only one integer T indicates the number of test cases.
The following 2×T lines represent T test cases. The first line of each test case is a integer N (0<N <= 100) which represents the number of tasks, and the second line contains N real numbers indicating the time needed for each task. The time is in milliseconds, greater than 0 and less than 10000000.

Output

For each test case, first output “Case N:”, N is the case No. starting form 1. Then print N lines each representing a task’s finishing time, in the order correspondent to the order of tasks in the input. The results should be rounded to 2 digits after decimal point, and you must keep 2 digits after the decimal point.

Sample Input

2
3
1.5 4.2 2.8
5
3.5 4.2 1.6 3.8 4.4

Sample Output

Case 1:
3.50
8.50
7.30
Case 2:
14.10
17.10
7.60
15.90
17.50
想法：我开始用队列去模拟这个问题，超时了，所以又想了另外一种思路去做。具体操作如下
<span style="font-family:Arial;">#include<stdio.h>
#include<math.h>
#define MAX 200
int main(){
	int t;
	scanf("%d",&t);
	int i;
	for(i=0;i<t;i++){
		int n;
		double reserve[MAX];
		double marks=0;
		double cost[MAX];
		scanf("%d",&n);
		int j;
		for(j=0;j<n;j++){
			scanf("%lf",&reserve[j]);
		}
		int k;
		/*计算某个任务总共完成需要的时间，每个任务所在的序列的行相加就是此任务输入的时间
		此后做其他序列上相对此任务的位置的判定，不同的位置所花费的时间是不同的，总共有n个
		任务，则需要分别计算这n个任务*/
		for(j=0;j<n;j++){
			cost[j]=reserve[j];
			for(k=0;k<n;k++){
				if(k!=j){
                    /*当某个位置时间花销少于目标位置的情况*/
					if(floor(reserve[k]+0.999)<floor(reserve[j]+0.999))//floor(double)函数取得是某个数的下限，即不大于某个数
						cost[j]=cost[j]+reserve[k];
                    /*当某个位置的时间花销和目标位置在一轮的时间片上的情况*/
					else if(floor(reserve[k]+0.999)==floor(reserve[j]+0.999)){
						if(k<j)
							cost[j]=cost[j]+reserve[k];
						else
							cost[j]=cost[j]+(floor(reserve[k]+0.999)-1);
					}
					/*当某个位置的时间花销多于目标位置的情况*/
					else if(floor(reserve[k]+0.999)>floor(reserve[j]+0.999)){
						if(k>j)
							cost[j]=cost[j]+(floor(reserve[j]+0.999)-1);
						else
							cost[j]=cost[j]+floor(reserve[j]+0.999);
					}
				}
			}
		}
		printf("Case %d:\n",i+1);
		for(j=0;j<n;j++){
			printf("%.2lf\n",cost[j]);
		}
	}
	return 0;
}</span>