算法设计与分析---时间任务安排问题

问题描述
具有截止时间和误时惩罚的任务安排问题可描述如下。
(1) 给定 n 个任务的集合 S={1,2,…,n}S={1,2,…,n};
(2) 完成任务i需要titi 时间，1≤i≤n1≤i≤n;
(3) 任务 i 的截止时间 didi ,1≤i≤n1≤i≤n，即要求任务 i 在时间 didi 之前结束;
(4) 任务 i 的误时惩罚 wiwi ,1≤i≤n1≤i≤n,即任务 i 未在时间didi 之前结束将招致 wiwi 的惩罚;
若按时完成则无惩罚。
任务安排问题要求确定 S 的一个时间表(最优时间表)使得总误时惩罚达到最小。

对于给定的 n 个任务，编程计算总误时惩罚最小的最优时间表。

数据输入：
第 1 行是 1 个正整数 n，表示任务数。接下来的 n 行中，每行有 3 个正整数 t,d,w，表示完成相应任务需要时间 t，截止时间为 d，误时惩罚为 w。

注：单位时间时间任务安排问题即n个任务中t=1即可，而非单位时间即n个任务中t不全为1

import java.util.Scanner;

public class 时间任务时间表问题 {
    static class Task{
        int t;  //完成任务需要的时间
        int d;  //截止时间
        int w;      //误罚时间
        int r;  //原始编号
        public Task (int t, int d, int w,int r) {
            this.t = t;
            this.d = d;
            this.w = w;
            this.r = r;
        }
    }
    static void quickSort(Task s[],int l,int r){//快速排序
        if (l<r)
        {   int i=l;
            int j = r;
            Task x = s[l];
            while (i < j)
            {
                while (i<j && s[j].d >= x.d)
                    j--;
                if (i<j)
                    s[i++] = s[j];
                while (i<j && s[i].d < x.d)
                    i++;
                if (i<j)
                    s[j--] = s[i];
            }
            s[i] = x;
            quickSort ( s,l,i-1 );
            quickSort ( s,i+1,r );
        }
    }
    static int min(int a, int b)
    {
        return (a>b) ? b : a;
    }
    //计算最优值
    static void punishment(int n,Task[] tasks,int[][] bak){
        int[][] p = new int[500][500];
        int[][] cc = new int[n][n-1];
        final int MAX = 99;
        //先初始化
        for (int i=1; i<= n; i++)
        {
            for (int j=0; j<tasks[n].d; j++)
            {
                p[i][j] = MAX;
            }
        }
        //对于第一个任务来说，如果时间少于它需要执行的时间 t，则会遭受惩罚
        for (int i=0; i<= tasks[n].d; i++)
        {
            if (i < tasks[1].t) //如果没给够时间
            {
                p[1][i] = tasks[1].w; //罚
                bak[1][i] =  tasks[1].r;
            }
            else
            {
                p[1][i] = 0;
                bak[1][i] = 0;
            }
        }
        for (int i=2; i<=n; i++)
        {
            for (int j=0; j<=tasks[n].d; j++)
            {
                p[i][j] = p[i-1][j] + tasks[i].w;   //p(i-1, d)+wi 表示决定不做第 i 个任务
                bak[i][j] =  tasks[i].r;
                if (min ( j,tasks[i].d ) >= tasks[i].t && p[i][j] > p[i-1][min ( j,tasks[i].d ) - tasks[i].t])
                {   //表示决定要做第 i 个任务
                    p[i][j] = p[i-1][min ( j,tasks[i].d ) - tasks[i].t];
                    bak[i][j] = 0;
                }
            }
        }
        System.out.println ("各惩罚值为：");
        for (int i=n; i>0; i--)
        {
            for (int j=n-1; j>=0; j--)
            {
                System.out.print (p[i][j]+" ");
            }
            System.out.println ();
        }
        System.out.println ("最优值为：");
        System.out.println (p[n][n-1]);
        System.out.println ("记录被罚任务编号为：");
        for (int i=1; i<=n; i++)
        {
            for (int j=0; j<n; j++)
            {
                System.out.print (bak[i][j]+" ");
            }
            System.out.println ();
        }
        System.out.println ("排序后的任务序列号：");
        for (int i=1; i<=n; i++)
        {
            System.out.print (tasks[i].r+" ");
        }
        System.out.println ();
        traceback ( tasks,bak,p,n );
    }
    //输出该组成最优值的路径
    static void traceback(Task[] tasks,int[][] bak,int[][] p,int n ){
        int left = 0;
        int right = 0;
        int[] dd = new int[n+1];
        int[] bb = new int[n+1];
        int[] cc = new int[n+1];
        for (int i=1; i<=n; i++) dd[i] = 1;
        bb[n] = p[n][n-1];
        left = n;
        right = n-1;
        cc[n] = tasks[n].r;
        for (int i=n-1, j=n-2; i>0&&j>=0; i--,j--)
        {
            if (bak[left][right] == 0 )
            {
                bb[i] = p[left][right];
                right = findj ( p,i,bb[i] );
                cc[i] = tasks[i].r;
            }
            else
            {
                dd[i+1] = 0;
                bb[i] = p[left][right]-tasks[left].w;
                right = findj ( p,i,bb[i] );
                cc[i] = tasks[i].r;
            }
            //应为p(1,0)一定受罚所以dd[1]=0
            dd[1] = 0;
            left = i;
        }
        System.out.println ("最优值组成的路径值：");
        for (int i=1; i<=n; i++)
        {
            System.out.print (bb[i]+" ");
        }
        System.out.println ();
        quickSort1 ( tasks,1,n );
        System.out.println ("最优时间表的一个解为：");
        for (int i=1; i<=n; i++)
        {
            if (dd[i] == 0) continue;
            else System.out.print (tasks[i].r+" ");
        }
    }
    static void quickSort1(Task s1[],int l,int r){//快速排序
        if (l<r)
        {   int i=l;
            int j = r;
            Task x = s1[l];
            while (i < j)
            {
                while (i<j && s1[j].t >= x.t)
                    j--;
                if (i<j)
                    s1[i++] = s1[j];
                while (i<j && s1[i].t < x.t)
                    i++;
                if (i<j)
                    s1[j--] = s1[i];
            }
            s1[i] = x;
            quickSort1 ( s1,l,i-1 );
            quickSort1 ( s1,i+1,r );
        }
    }

   //实现给定一个数组中的数，在已知的数组和横坐标i的条件下找到对应的j
    static int findj(int[][] p, int i,int n){
        int j;
        for ( j = 0; j<=i; j++)
        {
            if (p[i][j] == n) break;
        }
        return j;
    }
    public static void main (String[] args) {
        Scanner sc = new Scanner ( System.in );
        System.out.println ("输入任务个数：");
        int n = sc.nextInt ();  //输入n个任务
        Task[] tasks = new Task[n+1];
        int[] d = new int[n+1];
        int[] t = new int[n+1];
        int[] w = new int[n+1];
        int[] r = new int[n+1];
        int[][] bak = new int[n+1][n+1];
        for (int i=1; i<=n; i++)
        {
            t[i] = sc.nextInt ();
            d[i] = sc.nextInt ();
            w[i] = sc.nextInt ();
            r[i] = i;
            tasks[i] = new Task (t[i],d[i],w[i],r[i] );
        }
        //按照截至时间非递减排序
        quickSort ( tasks,1,n );
        punishment ( n,tasks,bak );
    }
}