算法设计与分析: 4-22 任务时间表问题

4-22 任务时间表问题

---

问题描述

一个单位时间任务是恰好需要一个单位时间完成的任务。给定一个单位时间任务的有限 集 S。关于 S 的一个时间表用于描述 S 中单位时间任务的执行次序。时间表中第 1 个任务从 时间 0 开始执行直至时间 1 结束，第 2 个任务从时间 1 开始执行至时间 2 结束，…，第 n 个任务从时间 n-1 开始执行直至时间 n 结束。
具有截止时间和误时惩罚的单位时间任务时间表问题可描述如下。
(1) n 个单位时间任务的集合 $S=\{1,2,...,n\}$;
(2) 任务 i 的截止时间 $d_i ,1≤i≤n,1≤ d_i ≤n$，即要求任务 i 在时间 $d_i$ 之前结束;
(3) 任务 i 的误时惩罚 $w_i$ ,$1≤i≤n$,即任务 i 未在时间 $d_i$ 之前结束将招致 $w_i$ 的惩罚;
若按时完成则无惩罚。
任务时间表问题要求确定 S 的一个时间表(最优时间表)使得总误时惩罚达到最小。

给定 n 个单位时间任务，各任务的截止时间 $d_i$ ,各任务的误时惩罚 $w_i$,$1≤i≤n$，编程计算最优时间表。

数据输入：
第一行是正整数 n，表示任务数。接下来的 2 行中，每 行有 n 个正整数，分别表示各任务的截止时间和误时惩罚。

---

Java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class RenWuShiJianBiao {

    private static class TASK implements Comparable{
        int deadline;
        int punishment;

        public int compareTo(Object t){
            TASK task = (TASK) t;
            int result = Integer.compare(task.punishment, punishment);//降序

            return result;
        }
    }

    private static int n;
    private static int[] job,d;//job[i]: 最优解中的第i个任务
    private static boolean[] jobDone;
    private static List<TASK> task;

    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        while (true){
            n = input.nextInt();

            job = new int[n+1];
            jobDone = new boolean[n+1];
            d = new int[n+1];
            task = new ArrayList<>(n+1);

            for(int i=0; i<n; i++){
                TASK tmp = new TASK();
                tmp.deadline = input.nextInt();
                task.add(tmp);
            }
            for(int i=0; i<n; i++)
                task.get(i).punishment = input.nextInt();

            Collections.sort(task);

            for(int i=0; i<n; i++)
                d[i+1] = task.get(i).deadline;//按误时惩罚降序排列

            int index = greedy();

            int sum = 0;
            for(int i=1; i<=index; i++){
                jobDone[job[i]-1] = true;
//                System.out.println(job[i]-1);
            }
            for(int i=0; i<n; i++){
                if(!jobDone[i])
                    sum += task.get(i).punishment;
            }

            System.out.println(sum);
        }
    }

    //按误时惩罚降序排列
    private static int greedy(){
        d[0] = 0;
        job[0] = 0;
        int k = 1;
        job[1] = 1;
        for(int i=2; i<=n; i++){
            int r = k;
            while((d[job[r]] > d[i]) && (d[job[r]] != r))
                r = r-1;
            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 = k+1;
            }
        }

        return k;
    }
}

Input & Output

7
4 2 4 3 1 4 6
70 60 50 40 30 20 10
50

Reference

王晓东《计算机算法设计与分析》（第3版）P136