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

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

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

②活動選擇問題的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 greedyActivitySelection(int[] s, int[] f, int i, int n, ArrayList 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 greedyActivitySelection2(int[] s, int[] f, int n, ArrayList 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 added public 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 purpose public 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 + " "); }

}

總結

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

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