算法设计与分析---时间任务安排问题
问题描述
具有截止时间和误时惩罚的任务安排问题可描述如下。
(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
int j = r;
Task x = s[l];
while (i < j)
{
while (i
j–;
if (i
while (i
if (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
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
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
int j = r;
Task x = s1[l];
while (i < j)
{
while (i
j–;
if (i
while (i
if (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 );
}
}