這篇文章主要用來記錄我對《算法導論》 貪心算法一章中的“活動選擇問題”的動態規劃求解和貪心算法求解 的思路和理解。

主要涉及到以下幾個方面的內容：

①什么是活動選擇問題---粗略提下，詳細請參考《算法導論》

②活動選擇問題的DP(Dynamic programming)求解--DP求解問題的思路

③活動選擇問題的貪心算法求解

④為什么這個問題可以用貪心算法求解？

⑤動態規劃與貪心算法的一些區別與聯系

⑥活動選擇問題的DP求解的JAVA語言實現以及時間復雜度分析

⑦活動選擇問題的Greedy算法JAVA實現和時間復雜度分析

⑧一些有用的參考資料

?

①活動選擇問題

給定N個活動，以及它們的開始時間和結束時間，求N個活動中，最大兼容的活動個數。比如：

活動 i:???????????? 1???? 2???? 3????? 4.....

開始時間 si:???? 1????? 3???? 0????? 5....

結束時間 fi:???? 4????? 5???? 6?????? 7.....

活動1的開始時間s(1)=1，結束時間f(1)=4，它與活動2是不兼容的。因為，活動1還沒有結束，活動2就開始了(s(2) < f(1))。

活動2 與 活動4 是兼容的。因為，活動2的進行區間是[3,5) 而活動4的進行區間是[5,7)

目標是：在N個活動中，找出最大兼容的活動個數。

?

②活動選擇問題的DP(Dynamic programming)求解

1）建模

活動 i 用 a(i)來表示，開始時間用 s(i)表示，結束時間用 f(i)表示，所有活動的集合為S

定義一個合適的子問題空間，設 S(i,j) 是與 a(i) 和 a(j)兼容的活動集合。S(i,j)={a(k), a(k) belongs to S: f(i)<=s(k)<f(k)<=s(j)}

2）問題一般化(不是很理解)

這里第一個活動和最后一個活動有點特殊。為了完整表示問題，構造兩個虛擬的活動: a(0) 和 a(n+1)

其中,s(0)=f(0)=0，s(n+1)=f(n+1)=Integer.MAX_VALUE

于是，S=S(0,n+1)，從N個活動中找出最大兼容的活動，就轉化成了求解 S(0,n+1)集合中包含的最多元素個數

3）子問題分析

假設所有的活動都按結束時間遞增排序。子問題空間就是 從S(i,j)中選擇最大兼容活動子集，即max{S(i,j)}

max{S(i,j)}表示與 a(i) a(j) 兼容的最大活動集合。稱為為S(i,j)的解

假設 a(k)是 S(i,j)的解包含的一個活動。S(i,j)就分解為 max{S(i,k)} + max{S(k,j)}+1

從這里可以看到，將原問題分解成了兩個子問題。原問題就是：求解與活動 a(i) a(j) 兼容的最大活動個數，即max{S(i,j)}

而子問題則是：max{S(i,k)}? 和? max{S(k,j)}

設A(i,j)就是S(i,j)的解。那么，A(i,j)=A(i,k) U A(k,j) U {a(k)}

A(0,n+1)就是我們所求的整個問題的最優解。

4）子問題的 選擇個數 分析

設c[i,j]為S(i,j)中最大兼容子集中的活動數，S(i,j)為空集時，c[i,j]=0，這是顯而易見的。因為S(i,j)中都沒有活動嘛，更別談什么兼容活動了呀。

若 i>=j，c[i,j]=0。這個也很好理解，因為它不符合常識。因為，我們假設活動是以結束時間來遞增排序的，在S(i,j)中，是f(i)<s(j)的。那 i 就不會大于 j

畢竟一個活動它不可能 即在 某個活動之前結束，又在該活動之后開始。哈哈。。。。。

前面提到 ：假設 a(k)是 S(i,j)的解包含的一個活動。S(i,j)就分解為 max{S(i,k)} + max{S(k,j)}+1

這意味著，求S(i,j)的最優解，就需要知道 S(i,k) 和 S(k,j) 的最優解。那關鍵是怎么知道 S(i,k) 和 S(k,j) 的最優解呢？

答案是：一個 一個 地嘗試。k 的取值范圍是 (i,j)，遍歷(i,j)內所有的值，計算 S(i,k) 和 S(k,j)的解。就可以找到S(i,j)的最優解了。

?因此，當S(i,j)不為空時，c[i,j] = max{c[i,k] + c[k,j] + 1}? 其中, k belongs to (i,j)? a(k) belongs to S(i,j)

下面，就是DP中的狀態轉移方程(遞歸表達式)，根據它，就可以寫代碼實現了。

從上面分析可以看出：原問題分解成了兩個子問題，要解決原問題，一共有 j-i+1中選擇，然后一 一遍歷求出所有的選擇。這就是動態規劃的特點，先分析最優子問題，然后再做選擇。

?

③活動選擇問題的貪心算法求解

所謂貪心算法，就是每次在做選擇時，總是先選擇具有相同特征的那個解，即“貪心”解。在這里，“貪心”的那個解則是： 結束時間最早的那個活動

具體步驟是怎樣的呢？

第一步：先對活動按照結束時間進行排序。因為我們總是優先選擇結束時間最早的活動的嘛。排序之后，方便選擇嘛。。。

第二步：按照貪心原則 選中一個活動，然后排除 所有與該活動 有沖突的活動。

第三步：繼續選擇下一個活動。其實，第二步與第三步合起來就是：每次都選結束時間最早的活動，但是后面選擇的活動不能與前面選擇的活動有沖突。

從這里可以看出，貪心算法是在原問題上先做貪心選擇，然后得到一個子問題，再求解子問題。（求解子問題的過程，就是一個不斷貪心選擇的過程）

?

④為什么這個問題可以用貪心算法求解？

看了貪心算法之后，就會有疑問？憑什么這樣選就能得到最優解啊？或者說，這樣做到底對不對？

別急嘛，我們可以用數學來證明這樣做是正確的。而且從這個證明過程中，可以窺出動態規劃與貪心算法的區別。

對于活動選擇問題而言：當可用貪心算法解時，貪心的效率要比動態規劃高。為什么要高呢？后面再詳細講。

這個證明具體可參考《算法導論》上的證明。它的大致證明過程就是：

當選擇了貪心解時(結束時間最小的活動)，也是將原問題劃分成了兩個子問題，但是其中一個子問題是空的，而我們只需要考慮另一個非空的子問題就可以了。

具體而言就是：假設 a(m) 是 S(i,j)中具有最早結束時間的那個活動，那按照我們的貪心選擇，我們肯定會選擇a(m)的嘛。選了a(m)之后，就將問題分解成了兩個子問題:S(i,m) 和 S(m,j)。前面提到，活動是按結束時間排序了的，而現在a(m)又是最早結束的活動，因為，S(i,m)就是個空集，而我們只需要考慮S(m,j)

但是，這里有個重大的疑問還未解決---憑什么說 a(m) 就是 S(i,j)的最優解中的活動呢？或者說憑什么 活動m 就是最大兼容活動集合中的活動？

這里就用到經常用來證明貪心算法正確性的一個技巧---剪枝。關于這個技巧，可參考一篇博文：漫談算法（一）如何證明貪心算法是最優

對于活動選擇問題，咱就來簡要證明下吧。。。其實還是《算法導論》中講的證明，只不過我又復述一遍罷了。

慢著，我們要證明的是啥？再說一遍：憑什么說 a(m) 就是 S(i,j)的最優解中的活動呢？，我們證明的就是：a(m)是S(i,j)的最優解中的元素，即a(m)是S(i,j)最大兼容活動子集中的活動。

設A(i,j)是S(i,j)的最大兼容活動子集---也就是說，在所有與 活動a(i) 和 活動a(j) 相兼容的活動中，A(i,j)含有的活動個數最多。

將A(i,j)中的活動按結束時間遞增排序。設a(k)是A(i,j)中的第一個活動。若a(k)=a(m)，那沒話說了。a(m)就是a(k)嘛，那a(m)肯定在A(i,j)中噻

若a(k) != a(m)，這說明A(i,j)中的第一個元素(活動)不是a(m)。那我們可以運用剪枝思想，剪掉A(i,j)中的第一個活動a(k)，再把活動a(m)貼到A(i,j)里面去。

這樣，A(i,j)中的活動個數還是沒有變化---少了個a(k)，加了個a(m)啊

那么，可能你就會問了，憑什么能把 a(m)貼到 A(i,j)里面去啊？？？？？我們可以這樣想想：a(k)是A(i,j)中的第一個活動，那為什么a(k)可以在A(i,j)中呢？

廢話！上面帶下劃線且加粗的的都說了假設 a(k)是A(i,j)中的第一個活動了啊！！

其實，這不是本質 ，本質就是：a(k)是與 a(i) 和 a(j)兼容的活動啊，而且沒有和A(i,j)中的其他活動沖突啊！因為，S(i,j)的解 就是求與 a(i) 和 a(j)兼容的一組活動啊，而A(i,j)就是這樣的一組活動且它是最大的(活動個數最多)，能夠放在A(i,j)中的活動，它一定是與a(i) 和 a(j) 兼容的。

那么，再回到a(m)，a(m)同樣也具有 ”本質“ 中提到的兩個性質：?a(m)是與a(i) 和 a(j) 兼容的活動? ?a(m)沒有與A(i,j)中其他活動沖突。

下面來說明下為什么 a(m)沒有與A(i,j)中其他活動沖突？因為a(k)是沒有與A(i,j)中的其他活動沖突的，而a(m)又是S(i,j)中結束時間最早的活動

故：，完成時間：f(m)<f(k) ，a(m)都比a(k)更早完成，而a(k)都沒有與A(i,j)中的其他活動沖突，那a(m)就更不可能與A(i,j)中的其他活動沖突了。

整個思路就是：在證明中先考察一個全局最優解，然后證明可以對該解加以修改(比如運用“剪枝”技巧)，使其采用貪心選擇(將貪心的那個選擇貼上去)，這個選擇將原問題變成一個相似的、但更小的問題。

終于完成了證明。好累。

?

⑤動態規劃與貪心算法的一些區別與聯系

這里只針對活動選擇問題作一下比較。其他的我也不懂。

a)動態規劃是先分析子問題，再做選擇。而貪心算法則是先做貪心選擇，做完選擇后，生成了子問題，然后再去求解子問題。

b)從 a) 中可以看出，動態規劃是自底向上解決問題，而貪心算法則是自頂向下解決問題。

c)動態規劃每一步可能會產生多個子問題，而貪心算法每一步只會產生一個子問題。（比如這里的貪心算法產生了“二個”子問題，但是其中一個是空的。）

?

⑥活動選擇問題的DP求解的JAVA語言實現以及時間復雜度分析

1 /** 2 * //算法導論中活動選擇問題動態規劃求解 3 * @param s 活動的開始時間 4 * @param f 活動的結束時間 5 * @param n 活動數目 6 * @return 最大兼容的活動個數 7 */ 8 public static int maxCompatiableActivity(int[] s, int[] f, int n){ 9 int[][] c = new int[n + 2][n + 2]; 10 11 for(int j = 0; j <= n+1; j++) 12 for(int i = n+1; i >= j; i--) 13 c[i][j] = 0;//if i>=j S(i,j)是空集合 14 15 int maxTemp = 0; 16 for(int j = 1; j <= n+1; j++) 17 { 18 for(int i = 0; i < j; i++)//i < j 19 { 20 for(int k = i+1; k < j; k++)// i< k <j 21 { 22 if(s[k] >= f[i] && f[k] <= s[j])//S(i,j)不空 23 { 24 if(c[i][k] + c[k][j] + 1 > maxTemp) 25 maxTemp = c[i][k] + c[k][j] + 1; 26 } 27 }//inner for 28 c[i][j] = maxTemp; 29 maxTemp = 0; 30 }//media for 31 }//outer for 32 return c[0][n+1]; 33 }

DP時間復雜度與問題的個數以及每個問題的選擇數 有關。

比如這里的 S(i,j)一共大約有N^2個， 因為 1=<j<=N， 1=<i<j? ，這里求和大約是 (N^2)/2（對于S(i,j) i>j沒有實際意義嘛）,每個S(i,j)一共有 j-i+1種 選擇

故時間復雜度為O(N^3)

?

⑦活動選擇問題的Greedy算法JAVA實現和時間復雜度分析

貪心算法即可以用遞歸實現，也可以用非遞歸實現。

1 //貪心算法的遞歸解 2 public static ArrayList<Integer> greedyActivitySelection(int[] s, int[] f, int i, int n, ArrayList<Integer> activities){ 3 //初始調用時 i = 0, 所以a(1)是必選的(注意:活動編號已經按結束時間排序) 4 int m = i + 1; 5 6 //s[m] < f[i] 意味著活動 a(m) 與 a(i)沖突了 7 while(m <= n && s[m] < f[i]) 8 m++;//選擇下一個活動 9 10 if(m <= n){ 11 activities.add(m); 12 greedyActivitySelection(s, f, m, n, activities); 13 } 14 return activities; 15 } 16 17 //貪心算法的非遞歸解, assume f[] has been sorted and actId 0/n+1 is virtually added 18 public static ArrayList<Integer> greedyActivitySelection2(int[] s, int[] f, int n, ArrayList<Integer> acitivities){ 19 //所有真正的活動(不包括 活動0和 活動n+1)中,結束時間最早的那個活動一定是最大兼容活動集合中的 活動. 20 int m = 1; 21 acitivities.add(m); 22 23 for(int actId = 2; actId <= n; actId++){ 24 if(s[actId] >= f[m])//actId的開始時間在 m 號活動之后.--actId 與 m 沒有沖突 25 { 26 m = actId; 27 acitivities.add(m); 28 } 29 } 30 return acitivities; 31 }

貪心算法的時間復雜度為O(N)，why?你可以看代碼啊。只有一個循環啊。每個活動只會遍歷一次啊。

這里從理論上來分析下：因為對于貪心算法而言，每次只有一種選擇即貪心選擇，而DP中每個問題S(i,j)中 j-i+1種選擇。

貪心算法做出一次貪心選擇后，即選中某個活動后，活動個數減少1，即問題規模減少1。

?

⑧參考資料

https://www.zhihu.com/question/23995189

《背包九講》

http://www.cnblogs.com/hapjin/p/5572483.html

?

附完整代碼：

import java.util.ArrayList; public class ActivitySelection {/*** //算法導論中活動選擇問題動態規劃求解* @param s 活動的開始時間* @param f 活動的結束時間* @param n 活動數目* @return 最大兼容的活動個數*/public static int maxCompatiableActivity(int[] s, int[] f, int n){int[][] c = new int[n + 2][n + 2];for(int j = 0; j <= n+1; j++)for(int i = n+1; i >= j; i--)c[i][j] = 0;//if i>=j S(i,j)是空集合int maxTemp = 0;for(int j = 1; j <= n+1; j++){for(int i = 0; i < j; i++)//i < j {for(int k = i+1; k < j; k++)// i< k <j {if(s[k] >= f[i] && f[k] <= s[j])//S(i,j)不空 {if(c[i][k] + c[k][j] + 1 > maxTemp)maxTemp = c[i][k] + c[k][j] + 1;}}//inner forc[i][j] = maxTemp;maxTemp = 0;}//media for}//outer forreturn c[0][n+1];}//貪心算法的遞歸解public static ArrayList<Integer> greedyActivitySelection(int[] s, int[] f, int i, int n, ArrayList<Integer> activities){//初始調用時 i = 0, 所以a(1)是必選的(注意:活動編號已經按結束時間排序)int m = i + 1;//s[m] < f[i] 意味著活動 a(m) 與 a(i)沖突了while(m <= n && s[m] < f[i])m++;//選擇下一個活動if(m <= n){activities.add(m);greedyActivitySelection(s, f, m, n, activities);}return activities;}//貪心算法的非遞歸解, assume f[] has been sorted and actId 0/n+1 is virtually addedpublic static ArrayList<Integer> greedyActivitySelection2(int[] s, int[] f, int n, ArrayList<Integer> acitivities){//所有真正的活動(不包括 活動0和 活動n+1)中,結束時間最早的那個活動一定是最大兼容活動集合中的 活動.int m = 1;acitivities.add(m);for(int actId = 2; actId <= n; actId++){if(s[actId] >= f[m])//actId的開始時間在 m 號活動之后.--actId 與 m 沒有沖突 {m = actId;acitivities.add(m);}}return acitivities;}//for test purposepublic static void main(String[] args) {//添加了 a(0) 和 a(n+1)活動. 其中s(0)=f(0)=0, s(n+1)=f(n+1)=Integer.MAX_VALUEint[] s = {0,1,3,0,5,3,5,6,8,8,2,12,Integer.MAX_VALUE};//start timeint[] f = {0,4,5,6,7,8,9,10,11,12,13,14,Integer.MAX_VALUE};//finish timeint n = 11;//活動的個數int result = maxCompatiableActivity(s, f, n);System.out.println("最大兼容活動個數: " + result);ArrayList<Integer> acts = new ArrayList<Integer>();greedyActivitySelection(s, f, 0, n, acts);for (Integer activityId : acts)System.out.print(activityId + " ");System.out.println();ArrayList<Integer> acts2 = new ArrayList<Integer>();greedyActivitySelection2(s, f, n, acts2);for (Integer activityId : acts2)System.out.print(activityId + " ");} }

?

總結

以上是生活随笔為你收集整理的从 活动选择问题 看动态规划和贪心算法的区别与联系的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。