资源调度问题——贪心算法

资源调度：给定等待服务的客户集合A = {1, 2, …, n}，预计对客户i的服务时间是t_i，该客户希望的完成时间是d_i，即T = {t₁, t₂,…, t_n}，D = {d₁, d₂,…, d_n}。如果对客户i的服务在d_i之前结束，那么对客户i的服务没有延迟；如果在d_i之后结束，那么这个服务就被延迟了，延迟的时间等于该服务时间减去d_i。假设都是t_i和d_i正整数，一个调度是函数f：A→N，其中是对客户i的服务开始的时间，要求所有区间互不重叠。一个调度f的最大延迟是所有客户延迟时间的最大值，例如：

A ={1, 2, 3, 4, 5}

T= {5, 8, 4, 10, 3}

D = {10, 12 , 15, 11,20}

那么对于调度f₁

f₁:{1, 2, 3, 4, 5} → N

f₁(1)= 0, f₁(2)= 5, f₁(3)= 13, f₁(4) = 17, f₁(5)= 27

客户1, 2, 3, 4, 5的延迟分别是0, 1, 2, 16, 10；最大延迟是max{0, 1, 2, 16 ,10}= 16。

但是，不同调度的最大延迟是不一样的，再如对同一个实例的另一个调度f₂

f₂:{1, 2, 3, 4, 5} → N

f₂(1)= 0, f₂(2)= 15, f₂(3) = 23, f₂(4) = 5, f₂(5) = 27

扫描二维码关注公众号，回复： 121345 查看本文章

客户1～5的延迟分别是0, 11, 12, 4 ,10；最大延迟是max{0, 11, 12, 4 ,10}= 12。

上述调度f₁和f₂的安排分别如图1所示：

图1 两个不同的调度方案

显然，调度f₂比f₁具有更小的延迟。

我们的问题是：给定 A = {1, 2, …, n}，T= {t₁, t₂, …, t_n}和D = {d₁, d₂, …, d_n}，用贪心算法求解具有最小延迟的调度f（不要求给出理论上的正确性证明）。

import java.util.Scanner;

public class 资源调度 {
	public static void main(String[] args) {
		Scanner in=new Scanner (System.in);
		System.out.println("输入客户数量n");
		int n=in.nextInt();//客户数量
		int t[]=new int[n];//预计完成时间
		int d[]=new int[n];//希望完成时间
		System.out.println("输入每个客户预计完成所需时间：");
		for(int i=0;i<n;i++) {
			t[i]=in.nextInt();
		}
		System.out.println("输入每个客户希望完成时间：");
		for(int i=0;i<n;i++) {
			d[i]=in.nextInt();
		}
		
		int TempSumTime=0;//当前完成总时间
		int maxDelayTime=0;//最大延迟时间
		int TempDelayTime=0;//当前延迟时间
		//冒泡排序
		for(int i=1;i<n;i++) {
			for(int j=0;j<n-i;j++) {
				if(d[j]>d[j+1]) {
					swap(d,j,j+1);
					swap(t,j,j+1);
				}
			}
		}
		
		for(int i=0;i<n;i++) {
			TempSumTime+=t[i];
			if(TempSumTime>d[i]) {//判断是否有延迟时间
				TempDelayTime=TempSumTime-d[i];//求出延迟时间
			}
			if(TempDelayTime>maxDelayTime) {
				maxDelayTime=TempDelayTime;//更新最大延迟时间
			}
		}
		System.out.println("此调度f最大延迟为："+maxDelayTime);
	}

	private static void swap(int[] d, int j, int i) {
		// TODO 自动生成的方法存根
		int temp=d[j];
		d[j]=d[i];
		d[i]=temp;
		
	}
}

资源调度问题——贪心算法

猜你喜欢