1. 
   A = {1, 2, 3, 4, 5}
   T = {5, 8, 4, 10, 3}
   D = {10, 12 , 15, 11, 20}
   那麼對於排程f1
   f1: {1, 2, 3, 4, 5} → N
   f1(1) = 0, f1(2) = 5, f1(3) = 13, f1(4) = 17, f1(5) = 27
   客戶1, 2, 3, 4, 5的延遲分別是0, 1, 2, 16, 10；最大延遲是max{0, 1, 2, 16 ,10} = 16。
   但是，不同調度的最大延遲是不一樣的，再如對同一個例項的另一個排程f2
   f2: {1, 2, 3, 4, 5} → N
   f2(1) = 0, f2(2) = 15, f2(3) = 23, f2(4) = 5, f2(5) = 27
   客戶1～5的延遲分別是0, 11, 12, 4 ,10；最大延遲是max{0, 11, 12, 4 ,10} = 12。
   上述排程f1和f2的安排分別如下圖所示：
   
   顯然，排程f2比f1具有更小的延遲。
   我們的問題是：給定 A = {1, 2, …, n}，T = {t1, t2, …, tn}和D = {d1, d2, …, dn}，用貪心演算法求具有最小延遲的排程f。
   (1) 演算法設計思路
   對客戶希望完成的時間進行從小到大排序，相應的預計對客戶服務的時間對應排序
   初始化f和延遲陣列
   (2) 演算法實現的虛擬碼及其計算時間複雜度分析
   求解排程問題的演算法Schedule（int[] d,int[] t）
   輸入：預計對客戶服務時間t[]，客服希望服務時間d[]
   輸出：最大的延遲時間
   s1: int n=d.length
   s2: for (int i=0 to n-1)
   s3: for (int j=i+1 to n-1)
   s4: if (d[i]>d[j]) 交換d[i]和d[j]，t[i]和t[j]
   s5: end for
   s6: end for
   s7: int[] f=new int[n+1];int[] delay=new int[n];f[0]=0
   s8: for (inti =1 to n)
   s9: f[i]=f[i-1]+t[i-1]
   s10: end for
   s11: for (inti =0 to n-1)
   s12: if (f[i+1]>d[i]) delay[i]=f[i+1]-d[i];
   s13: else delay[i]=0;
   s14: end for
   s15: Array.sort(d);
   s16: return d[n-1]
   演算法Schedule的計算時間複雜度分析：
   O（NlogN）
   (3) 實驗程式碼

import java.util.Arrays;

    public class 分配排程 {
         static int schedule(int[] d,int[] t){
            int n=d.length;//獲取陣列的長度
            //將陣列d從小到大排序，相應的t對應排序
            for (int i=0;i<n;i++)
                for (int j=i+1;j<n;j++){
                    if (d[i]>d[j]){
                        swap(d[i],d[j]);//交換兩個數
 

                        swap(t[i],t[j]);
                    }
                }

            int[] f=new int[n+1];//建立一個數組用了儲存服務的依次總時間
            int[] delay=new int[n];//儲存延遲數
            f[0]=0;
            for (int i=1;i<=n;i++)//初始化f
                f[i]=f[i-1]+t[i-1];

            for (int i=0;i<n;i++){//判斷是否延遲
                if (f[i+1]>d[i])//延遲
                    delay[i]=f[i+1]-d[i];
                else //不延遲
                    delay[i]=0;
            }
        Arrays.sort(delay);//對延遲陣列進行從小到大排序
        return delay[n-1];//返回最大的延遲數
        }
         //交換兩個數的方法
        static void swap(int i, int j) {
            // TODO Auto-generated method stub
            int temp=i;
            i=j;
            j=temp;
        }
        public static void main(String[] args) {
            int[] d={10,12,15,11,20};
            int[] t={5,8,4,10,3};
            int max=schedule(d,t);
            System.out.println(max);
        }
    }

(4) 體會
貪心演算法主要是做出對當前最好的選擇，所以對客戶的希望服務時間從小到大排序。