算法设计课程设计－－任务时间表问题

问题描述

        一个单位时间任务是恰好需要一个单位时间完成的任务。给定一个单位时间任务的有限集S.关于S的一个时间表用于描述S中单位时间任务的执行次序。

        如：给定单位时间任务集S各任务截止时间和误时惩罚，截止时间d[i]{4,2,4,3,1,4,6}，误时惩罚w[i]{70,60,50,40,30,20,10},求解最优时间表，计算最小总误时惩罚。
 

思路分析过程

        问题要使所有任务的总误时惩罚最小，容易想到采用贪心策略：误时惩罚大的任务先执行。这样，即使有任务不能按时执行，惩罚值也是剩下较小的。

        但是，直接将误时惩罚大的任务从前往后排是否是最好的贪心策略呢？答案是否定的。因为每个任务都有一个时间底线，在时间底线之前执行都不会受到惩罚。假设有这样一种情况：有两项任务，序号是1、2，误时惩罚分别为70、60，时间底线分别为2、1。如果按照上面的贪心策略，执行次序为1、2，任务2因为超过时间底线而被惩罚。而事实上，最优的贪心策略是执行次序为2、1，两个任务都不会收到惩罚。 

        综合考虑误时惩罚和时间底线两个因素，我们的算法需要使每个任务在不误时的前提下，尽可能向后安排，留给其他任务最大的执行空间。按照这种思想得到改进的贪心策略：误时惩罚大的任务优先排到它的时间底线，如果该时间已经有任务，则向前安排；如果前面都已经有任务（惩罚在所难免），则从最后向前安排。 

详细设计说明书

变量：in Scanner类型的变量便于控制台接收数据

方法：

main(String[]):void主方法，入口方法。
show(int[],int[],int[],int[]):void参数列表分别为截至时间，误时惩罚，时间表，原始数据下表。展示菜单列表。
greedyJob(int[],int[],int[]):void参数列表分别为截至时间，误时惩罚，时间表。计算最优时间表。
superSort(int[],int[],int[]):void参数列表分别为截至时间，误时惩罚，时间表。排序。

源代码

import java.util.Scanner;
/**
* @time 2016-06-11
* @Description 计算任务时间表问题
*/
public class TimeTable {
//声明静态的扫描器类便于调用
static Scanner in = new Scanner(System.in);
/**
* 主方法
* @param args
*/
public static void main(String args[]) {
/**
* 测试用例
* int[] v1 = { 0, 4, 2, 4, 3, 1, 4, 6 };
* int[] w1 = { 0, 70, 60,50, 40, 30, 20, 10 };
*/
System.out.println("请输入任务集的大小：");
int size = in.nextInt();
int[] v1 = new int[size + 1];
int[] w1 = new int[size + 1];
int[] indexs=new int[v1.length];
int time = 0;
int passtime = 0;
for (int i = 0; i < indexs.length; i++) {
indexs[i]=i;
}
System.out.println("请分别输入各任务截至时间：");
for (int i = 1; i <= size; i++) {
System.out.print("第" + i + "个任务的截至时间：");
time = in.nextInt();
v1[i] = time;
}
System.out.println("请分别输入各任务误时惩罚：");
for (int i = 1; i <= size; i++) {
System.out.print("第" + i + "个任务的误时惩罚：");
passtime = in.nextInt();
w1[i] = passtime;
}
int[] u1 = new int[v1.length];
new TimeTable().show(v1, w1, u1,indexs);
}
/**
* 显示方法show
* @param v1 截止时间
* @param w1 误时惩罚
* @param u1 最优时间表
*/
public void show(int[] v1, int[] w1, int[] u1,int[] indexs) {
SuperSort(v1, w1,indexs);
int total=greedyjob(v1, w1, u1);
System.out.println("<<时间表问题>>");
while (true) {
System.out.println("\n1.总误时惩罚为");
System.out.println("2.最优时间表为");
System.out.println("0.退出\n");
System.out.println("---------------------------------");
System.out.print("请选择>");
int choose = in.nextInt();
switch (choose) {
case 1:
System.out.println("总误时惩罚为：" +total);
System.out.println("-----------------------------");
break;
case 2:
System.out.print("最优时间表为：");
for (int i = 1; i <= v1.length - 1; i++) {
System.out.print(indexs[u1[i]] + "  ");
}
System.out.println();
System.out.println("-----------------------------");				break;
case 0:
System.err.println("退出成功！");
System.out.println("-----------------------------");				System.exit(0);
}
}
}
/**
* 主要计算方法
* @param d 截止时间
* @param w 误时惩罚
* @param job 最优时间表
* @return 总误时惩罚
*/
public int greedyjob(int[] d, int[] w, int[] job) {
int n = d.length - 1;
d[0] = 0;
job[0] = 0;
int k = 1;
job[1] = 1;
int sum = 0;

for (int i = 2; i <= n; i++) {
int r = k;
while ((d[job[r]] > d[i]) && (d[job[r]] != r)) {
r--;
}
if ((d[job[r]] <= d[i]) && (d[i] > r)) {
for (int m = k; m > r; m--) {
job[m + 1] = job[m];
}
job[r + 1] = i;
k++;
}
}
for (int i = 1; i <= k; i++) {
w[job[i]] = 0;
}
for (int i = 1; i <= n; i++) {
if (w[i] > 0) {
job[++k] = i;
sum += w[i];
}
}
return sum;
}
/**
* 排序：对相同截止时间的误时惩罚进行降序排列；
* @param d 截止时间
* @param w 误时惩罚
*/
public void superSort(int[] d, int[] w, int[] indexs) {
for (int i = 1; i < d.length - 1; i++) {
for (int j = i + 1; j < d.length; j++) {
if (w[i] < w[j]) {
int temp = w[i];
w[i] = w[j];
w[j] = temp;

temp = indexs[i];
indexs[i] = indexs[j];
indexs[j] = temp;

temp = d[i];
d[i] = d[j];
d[j] = temp;
}
}
}
}
}
}

遇到问题

        算是很快完成算法的要求，测试也是发现了一些问题，于是尝试修改代码，改进代码，过程中我们用过新的算法，180度的代码大转换，最终还是无法解决问题，于是只有一行一行检查代码，查bug，当看到一个交换数字的算法代码块时，我真的是既惭愧又很无奈呀，仅仅是两个数组小标写反了，导致我们无用工作了两天，在做课程设计初期，算法部分变量不清楚具体含义，经过调试测试，最终明白，排序方法构建时，大意出错，导致长时间代码无法通过测试。

总结

        通过实际操作实验加深了对时间表问题的理解，同时也学到了相关的很多知识，贪心算法和任务调度问题的理解也深入了解了不少，整个过程中，我深刻的体会到了编写程序是必须加倍小心，尽量或不出现尝试性问题，否则会发生很多意想不到的事，代码编写细心很重要，总之算法重在在理解，代码实现只是一种表现形式，确是很好的表现。团队的合作很重要，每人一个小模块，大大加快开发效率。