動態規劃

• 引言
  • 問題引入?
    對于一個2×2的表格，從左上角走到右下角，過程只可以向右或向下移動，共有6種方式（如圖），那么，對于一個10×10的表格呢？?
    
  • 遞歸解法
    • n設坐標以左上角為（0，0），向右記為R，為x軸的增方向；向下記為D，為y軸的增方向。當前坐標為C，表格的寬=高=S。
    • 從（0，0）開始，我們有兩種選擇，R和D。
    • 如果第一步選擇R時，C=（1，0），此時又有兩種選擇，R和D，也就是說，與第一步是一樣的。
    • 同理，如果第一步選擇的是D，也與第一步一致。
    • 顯然，這是一個遞歸的過程。邊界條件就是當C的坐標到達（S-1，S-1)。
    • 因此：?
      static const int gridSize = 10;int Recursivity_GetRoutes(int x, int y) {int count = 0;if (x < gridSize)count += Recursivity_GetRoutes(x + 1, y);if (y < gridSize)count += Recursivity_GetRoutes(x, y + 1);if (x == gridSize && y == gridSize)return 1;return count; }
  • 更高效的解法?
    上述的程序是針對10×10的表格，它運行的不算慢，所以我們再將表格的大小翻倍，測試下它的運行時間。通過在一臺普通的計算機上測試，表格為20×20時，程序運行超過了30分鐘（具體時間有興趣的可以測試），為什么會這么慢呢？?
    我們知道，遞歸的過程會消耗一定的時間，但是也不足以將程序拖到運行30分鐘之久。因此我們取表格中的一個點來分析，拿P點來說，到達這個點有下圖中的路徑：?
    
    我們看到，到達P點之后，這個點到終點的路徑數是固定的（如圖粉線所示），然而，遞歸調用中為用紅線到達P和藍線到達P分別計算了一次。?
    因此我們需要一個備忘錄，或者說一個哈希表，來保存以前計算過的值，而且，嘗試用迭代代替遞歸又能進一步增加效率和運行時的安全性。?
    注意觀察會發現一個重要的性質：?
    
    因此，我們決定采用一個自底向上的，帶有備忘錄的迭代的解法：?
    long long Dp_GetRoutes(){long long arr[21][21] = {0};for(int i = 0; i < 21; ++i)arr[i][20] = 1, arr[20][i] = 1;for(int i = 19; i >= 0; --i)for(int j = 19; j >= 0; --j){arr[i][j] = arr[i + 1][j] + arr[i][j + 1];}return arr[0][0];} 當然，對于這個問題，有一個手算的方法，為了走到終點，必然會向右走20步，向下走20步。它們的全排列共有40!種。?
    又因為，20個相同的R及D進行全排列是沒意義的，所以需要除以(20!×20!）。?
    結果為40! / (20!×20!）。
• 動態規劃
  • 定義?
    動態規劃(dynamic programming)是運籌學的一個分支，是求解決策過程最優化的數學方法。20世紀50年代初美國數學家R.E.Bellman等人在研究多階段決策過程的優化問題時，提出了著名的最優化原理，把多階段過程轉化為一系列單階段問題，利用各階段之間的關系，逐個求解，創立了解決這類過程優化問題的新方法——動態規劃。
  • 特征
    • 最優子結構
      • 如果問題的一個(最優)解中，包含了子問題的(最優)解，則該問題具有最優子結構。
      • 結合引言中的例子，從底層開始迭代，比如取一個點，坐標為（x,y），那么，從這個點到終點的所有路徑的總和就等于（x+1,y）到終點的所有路徑和加上(x,y+1)到終點的所有路徑和。
      • 證明最優子結構可以使用“剪切粘貼”的方法。在后面討論誤用動態規劃時的最短路時應用此方法。
    • 重疊子問題
      • 用來解決原問題的算法會反復地解同樣的子問題，而不是總產生新的問題。
      • 就引言中的例子而言，隨著迭代的進行，總會遇到相同的子問題，因為我們做了備忘，因此這些問題只被計算一次。
  • 提防誤用
    • 動態規劃中的子問題一定是相互獨立的，一個子問題中的解不會影響其它子問題的解。比如將點(x,y)到終點的路徑分割為從(x+1,y)到終點的所有路徑加上從(x,y+1)到終點的所有路徑。
    • 考慮下圖中的最短路和最長路徑：?
      
      如果需要計算q到t的最短路徑，可以將問題從r或者s處劃分開，具體在哪里劃分取決于r到t的路徑和s到t的路徑誰短。這樣問題的兩個部分是獨立的。?
      如果需要計算q到t的最長路徑，考慮從r處分開子問題，那么q到r的最長路徑為q->s->t->r，r到t的最長路徑顯然是r->q->s->t，合并二者，得到q->s->t->r->q->s->t，顯然是錯誤的。
    • 兩種路徑產生很大差別，原因是，最長路徑的子問題不獨立，選定了一個子問題的解之后，它所使用的點不應被另一個子問題再使用。
    • 實際上，最長路徑問題是NP完全的，也就是說，無法在多項式時間（一個問題的計算時間m(n)不大于問題大小n的多項式倍數）得到解決。
• 典型動態規劃問題舉例
  • 最大取值?
    問題：?
    從下面的三角的頂端，每次只能移動到下一行的且與之臨近的點上，其最大值是（紅色表示路徑）：3 + 7 + 4 + 9 = 23。?
    那么，對于以下的三角呢？?
    
    分析：同樣，我們從三角的倒數第二層開始分析，假如，此時我們在最左邊的63上，按題意，此時只有兩種選擇，04和62，顯然，為了得到最大值，我們會選擇62，第二行的其余點也如此選擇。?
    接著，我們上升一層，在91上，為了得到最大值，我們會選擇63和66。?
    顯然這是個動態規劃的問題，在倒數第N層到底層內這個問題(最優子結構)是最優的。?
    當三角只有一層時，最大取值=底層點的值。?
    static inline int Max(int x, int y){return (x > y) ? x : y; }static int arr[][15] = {/*layer1*/ { 75 },/*layer2*/ { 95, 64 },/*layer3*/ { 17, 47, 82 },/*layer4*/ { 18, 35, 87, 10 },/*layer5*/ { 20, 4, 82, 47, 65 },/*layer6*/ { 19, 1, 23, 75, 3, 34 },/*layer7*/ { 88, 2, 77, 73, 7, 63, 67 },/*layer8*/ { 99, 65, 4, 28, 6, 16, 70, 92 },/*layer9*/ { 41, 41, 26, 56, 83, 40, 80, 70, 33 },/*layer10*/ { 41, 48, 72, 33, 47, 32, 37, 16, 94, 29 },/*layer11*/ { 53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14 },/*layer12*/ { 70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57 },/*layer13*/ { 91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48 },/*layer14*/ { 63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31 },/*layer15*/ { 4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23 }};int Dp_GetMaxValueThroughTriangle(){const int limit = 15 - 1;for(int layer = limit; layer != 0; --layer){const int& layerNumberCount = layer;for(int numberIndex = 0; numberIndex < layerNumberCount; ++numberIndex)arr[layer - 1][numberIndex] += Max(arr[layer][numberIndex], arr[layer][numberIndex + 1]);}return arr[0][0];}
  • 錢幣組合方式?
    假設我們有無限多的1元，2元，5元，10元，20元，50元，100元，200元的錢幣，那么為了組合成一個200元的錢幣，共有多少種組合方式？?
    比如說：?
    200 = 1×100+1×50+2×20+1×5+1×2+3×1。?
    因為有了1元的錢幣，這就使我們組成的任何不足200的數字可以整合為200。?
    為了說明問題，我們來觀察這樣的一個類似的小問題，用1元，2元，5元來組成5元。?
    如果只允許用1元，那么顯然只有一種方案：1×5。?
    如果允許用1元和2元，那么，5元的組合方式有，1×5，2+1×3，2×2+1。增加了兩種方案。?
    如果允許用1，2，5元，那么有：?
    1×5，2+1×3，2×2+1，5×1。?
    我們假設組成0元的方式有一種，那么，可選的最大幣值為x，那么：?
    當x=1時：?
    當x=2時：?
    當x=5時：?
    
    從這個問題總結出：當目標幣值為Y，現在可用的最大幣值為1，2，5……X(X ≤Y)，Z是小于X的最大幣值，組成Y的方式為f(Y)那么?
    f(Y) = f(Y-X) + f(X-Z)?
    比如說，對于Y=3，X=2，可知Z=1，所以，?
    f(3) = f(3-2) + f(2 - 1) = f(1) + f(1) = 1 + 1 = 2。特別地，f(0) = 1。?
    static int faceValue[] = {1, 2, 5, 10, 20, 50, 100, 200}; static const size_t factValueCount = 8;int Dp_GetCountOfWaysCan200BeMadeUp(){// Dynamic Programming.const int destination = 200;int waysCount[destination + 1] = { 0 };waysCount[0] = 1;for(int indexCoin2Give = 0; indexCoin2Give < factValueCount; ++indexCoin2Give)for(int indexValueNeed2Pay = faceValue[indexCoin2Give]; indexValueNeed2Pay <= destination; ++indexValueNeed2Pay)waysCount[indexValueNeed2Pay] += waysCount[indexValueNeed2Pay - faceValue[indexCoin2Give]];return waysCount[200];} 由于數據量不大，也可以用遞歸解決或者枚舉法解決。?
    int Recursivity_GetCountOfWaysCan200BeMadeUp(int money, int maxCoin){int coins[8] = {200, 100, 50, 20, 10, 5, 2, 1};int result = 0;if(maxCoin == 7) // Only coins[1] = 1 is available.return 1;for(int i = maxCoin; i < 8; i++){if (money - coins[i] == 0)//Done.result += 1;if (money - coins[i] > 0) result += Recursivity_GetCountOfWaysCan200BeMadeUp(money - coins[i], i);// else, money < coins[i], continue. }return result;}///int BruteFource_GetCountOfWays(){int ways = 0;const int dest = 200;for(int a = dest; a >= 0; a -= 200) //a個200。for(int b = a; b >= 0; b -= 100) //b個100。for(int c = b; c >= 0; c -= 50) //c個50。for(int d = c; d >= 0; d -= 20) //d個20。for(int e = d; e >= 0; e -= 10) //e個10。for(int f = e; f >= 0; f -= 5) //f個5。for(int g = f; g >= 0; g -= 2) //g個2。++ways;return ways;}
• 活動安排?
  假設有11個活動，需要占用同一個資源(比如說一個會議室)，他們的活動時間按照結束時間遞增的順序，如下表所示：?
  如果兩個活動不會同時占用一樣資源，那么稱他們是相容的。那么，共有最多可以有多少個活動相容？?
  n假設S(i,j)表示一個集合，活動記為a， S(i,j)之中的元素代表活動，并且所有的活動都在a_i結束之后開始，在a_j開始之前結束。假設活動的編號從1開始，到n-1結束，定義哨兵事件，a_0為最開始的事件，a_n為最結束的事件。記c[i,j]為|S(i,j)|。?
  簡言之，如果一個活動a_k是S(i,j)中的一個合法的活動，那么c[i,j]為k取(i,j)中的各個值，并通過c[i,k]+1+c[k,j]得到的最大結果。?
  #include <vector> #include <map> #include <iostream>const int FirstActivityInitializer = 0; const int LastActivityInitializer = 2147483647; //INT_MAX;struct Activity{Activity(int b = -1, int e = -1) : tBeg(b), tEnd(e) {}operator int(){ return tEnd; }int tBeg;int tEnd;};typedef std::vector<Activity> ActivityTable; typedef std::map<int, int> HashTable; typedef std::map<int, size_t> ResultCollector;const Activity firstActivity(FirstActivityInitializer, FirstActivityInitializer); const Activity lastActivity(LastActivityInitializer, LastActivityInitializer);static inline int MakeKey(int l, int h){return ((h << 16) | l);}static inline void output(ResultCollector& result, int from, int to){int divider = result[MakeKey(from, to)];if(divider == 0){ //New pair (MakeKey(from, to), 0) has been inserted into ResultCollector, remove it.result.erase(MakeKey(from, to));return;}std::cout << divider << " ";output(result, from, divider);output(result, divider, to);}static inline void OutputResult(const ResultCollector& result, int from, int to){std::cout << "Optional: ";output(const_cast<ResultCollector&>(result), from, to);std::cout << std::endl;}static int ActivitySelector(const ActivityTable& act){ActivityTable activities(1, firstActivity);activities.insert(activities.end(), act.begin(), act.end());activities.push_back(lastActivity);HashTable hashTable;ResultCollector collector;size_t actCount = activities.size() - 1;for(size_t subLen = 1; subLen < actCount; ++subLen)for(size_t first = 0; first < actCount - subLen; ++first){size_t last = first + subLen + 1;for(size_t cur = first + 1; cur < last; ++cur)if(activities[cur].tBeg >= activities[first].tEnd && activities[cur].tEnd <= activities[last].tBeg&& hashTable[MakeKey(first, cur)] + 1 + hashTable[MakeKey(cur, last)] > hashTable[MakeKey(first, last)]){collector[MakeKey(first, last)] = cur;hashTable[MakeKey(first, last)] = hashTable[MakeKey(first, cur)] + 1 + hashTable[MakeKey(cur, last)];}}OutputResult(collector, 0, actCount);return hashTable[MakeKey(0, activities.size() - 1)];}int Dp_ActivitySelector(){ActivityTable al;al.push_back(Activity(1, 4));al.push_back(Activity(3, 5));al.push_back(Activity(0, 6));al.push_back(Activity(5, 7));al.push_back(Activity(3, 8));al.push_back(Activity(5, 9));al.push_back(Activity(6, 10));al.push_back(Activity(8, 11));al.push_back(Activity(8, 12));al.push_back(Activity(2, 13));al.push_back(Activity(12, 14));return ActivitySelector(al);}
• 題外話
  • 前面我們假設活動按照結束時間遞增的順序排列，其實我們也可以不要這個限制，而在活動選擇之前主動進行排序。觀察活動結束時間的選擇區間，顯然是0～24的，那么，用計數排序是很合適的。下面的計數排序是兼容STL的：?
    #include <algorithm> #include <cassert>template <class RanIt> static void count_sort(RanIt first, RanIt last, int upper){typedef std::iterator_traits<RanIt>::value_type value_t;typedef std::iterator_traits<RanIt>::difference_type distance_t;distance_t dis = std::distance(first, last);std::vector<value_t> tmp(first, last);RanIt dest = tmp.begin();int *host = new int[upper];//fill temporary range with default value.std::fill(host, host + upper, 0);//host[i]: count of values which are equal to i. eg: host[2] == 1, //means there are two '2'.for(int i = 0; i < dis; ++i)++host[*(first + i)];//host[i]: count of values which are not greater than i. eg: host[2] = 3,//means there are 3 numbers less or equal to 2.for(int i = 1; i < upper; ++i)host[i] += host[i - 1];//place the number backwardly to keep this algorithm stable.for(int i = (--dis); i >= 0; --i){value_t temp = *(first + i);dest[host[temp] - 1] = temp, --host[temp];}//copy result back into the input range. std::copy(tmp.begin(), tmp.end(), first);//clean up. delete host;}template <class RanIt> inline void CountSort(RanIt first, RanIt last, int upper){ //this algorithm use both the index and the value of an array to represent data.if(*(std::min_element(first, last)) >= 0 && *(std::max_element(first, last)) <= upper)count_sort(first, last, ++upper);elseassert(false);}
  • 當然，用動態規劃解決活動選擇問題是可以的，但是它還有另一個重要的性質，如果已經選定了活動x，那么，下一個被選擇的活動一定是與x相容且結束時間最早的活動y。證明：?
    假設下一個選擇的活動為z且z≠y，那么，將z換為y，因為y是最早結束的活動，并且y與x相容，所以y的結束時間必然≤z的結束時間，這就保證了它不與已選擇的其他活動沖突。所以y在這個活動集中是合理的。?
    有了上述的性質，我們假設第一個活動是a_0,它的結束時間為0，選擇下一個時，選擇開始時間大于0且結束時間最早的，因為活動的結束時間已經按照遞增排序，因此選擇的是a_1，按照這個規則，同理，下一個選擇的是a_4，然后是a_8，最后是a_11。?
    上述方法稱為貪心算法，每次選取當前看來最優的解，從而獲得全局的最優解。?
    貪心算法是一個與動態規劃類似但是較動態規劃更為簡潔但卻更容易誤用的算法。

轉載于:https://www.cnblogs.com/tham/p/6827473.html

總結

以上是生活随笔為你收集整理的动态规划 入门学习的全部內容，希望文章能夠幫你解決所遇到的問題。

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