算法导论-实验三--一个任务调度问题

实验三一个任务调度问题

1.问题描述:

在单处理器上具有期限和惩罚的单位时间任务调度问题.

2.算法原理:

考虑一个给定的调度. 我们说一个任务在调度迟了, 如果它在规定的时间之后完成; 否则, 这个任务在该调度中是早的. 一个任意的调度总可以安排成早任务优先的形式, 其中早的任务总是在迟的任务之前. 为了搞清这一点, 请注意如果某个早任务a(i)跟在某个迟任务a(j)之后, 就可以交换a(i)和a(j)的位置, 并不影响a(i)是早的a(j)是迟的状态.

类似的,任意一个调度可以安排成一个规范形式, 其中早的任务先于迟的任务, 且按期限单调递增顺序对早任务进行调度. 为了做到这一点, 将调度安排成早任务优先形式. 然而, 只要在该调度中有两个分别完成于时间k和k+1的早任务a(i)和a(j) 使得d(j)

如此, 寻找最优调度问题就成为找一个由最优调度中早的任务构成的集合A的问题. 一旦A被确定后, 就可按期限的单调递增顺序列出A中的所有元素,从而给出实际的调度, 然后按任意顺序列出迟的任务(S-A), 就可以产生出最优调度的一个规范次序.

称一个任务的集合A是独立的, 如果存在关于A中任务的一个调度, 使得没有一个任务是迟的. 显然, 某一调度中早任务的集合就构成一个独立的任务集.

3.实验数据:

输入:

没有输入, 有一个结构体task,系统会随机生成task的期限和惩罚

输出:

分别输出随机生成task的集合后的早任务集合,迟任务惩罚以及将每个替换为

后的早任务集合,迟任务惩罚.

4.实验截图:

5.结果分析:

可以看出将每个替换为后的早任务集合基本上包括了没有替换是的早任务集合, 并且替换后的迟任务惩罚大于没有替换时的迟任务惩罚.

6.源代码:

普通排序

/*贪心算法实现单处理器任务调度。

*基本思想是：首先按照惩罚把各个任务降序排序。

*然后遍历任务，逐一确定是否可以放入独立子集A

*/

#include

#include <>

#include <>

using namespace std;

#define n 8

struct task

{

int id;d = i;

ta[i].d = 1 + rand() % 20;

ta[i].w = rand() % 50;

}

}

void print(task ta)

{

cout << "id=" << << "\td=" << << "\tw=" << << endl; }

void copy(task& t, task s)

{

= ;

= ;

= ;

}

void sortW(task ta[]) < ta[j + 1].w)>ta[j + 1].d)

{

copy(s, ta[j]);

copy(ta[j], ta[j + 1]);

copy(ta[j + 1], s);

}

}

}

}

int greedy(task a[], task ta[]);

k = 1;

for (i = 0; i <= n; i++)

{

if (i >= a[0].d)

Nt[i] = 1;

else

Nt[i] = 0;

}

for (i = 1; i

{

for (j = ta[i].d; j <= n; j++)

{

if (Nt[j] + 1>j); j <= n; j++);

}

for (i = 0; i < n; i++)

{

sum2 += ta[i].w;

}

return sum2 - sum1;

}

int main()

{

task tasker[n];;

for (i = 0; i < n; i++)

maxweg = tasker[i].w;

}

k = greedy(A, tasker);

sortD(A, k); = maxweg - tasker[i].w;

}

k = greedy(A, tasker);

sortD(A, k);

cout << "改变后最优调度方案的早任务为：" << endl;

for (i = 0; i < k; i++)

{

print(A[i]);

}

cout << "改变后迟任务惩罚为：" << getW(A, tasker, k) << endl;

return 0;

}