动态规划的经典例子

最长不减子序列

一个序列有N个数：A[1],A[2],…,A[N]，求出最长非降子序列的长度。 (讲DP基本都会讲到的一个问题LIS：longest increasing subsequence)

正如上面我们讲的，面对这样一个问题，我们首先要定义一个“状态”来代表它的子问题， 并且找到它的解。注意，大部分情况下，某个状态只与它前面出现的状态有关， 而独立于后面的状态。

5，3，4，8，6，7

根据上面找到的状态，我们可以得到：（下文的最长非降子序列都用LIS表示）

• 前1个数的LIS长度d(1)=1(序列：5)
• 前2个数的LIS长度d(2)=1(序列：3；3前面没有比3小的)
• 前3个数的LIS长度d(3)=2(序列：3，4；4前面有个比它小的3，所以d(3)=d(2)+1)
• 前4个数的LIS长度d(4)=3(序列：3，4，8；8前面比它小的有3个数，所以 d(4)=max{d(1),d(2),d(3)}+1=3)

状态转换分成为：

d(i) = max{1, d(j)+1},其中j

#include <iostream>using namespace std;int lis(int A[], int n){    int *d = new int[n];    int len = 1;    for(int i=0; i<n; ++i){        d[i] = 1;        for(int j=0; j<i; ++j)            if(A[j]<=A[i] && d[j]+1>d[i])                d[i] = d[j] + 1;        if(d[i]>len) len = d[i];    }    delete[] d;    return len;}int main(){    int A[] = {        5, 3, 4, 8, 6, 7    };    cout<<lis(A, 6)<<endl;    return 0;}

以上是O(n2)的算法，还有O(nlogn)的实现如下：

//在非递减序列 arr[s..e]（闭区间）上二分查找第一个大于等于key的位置，如果都小于key，就返回e+1int upper_bound(int arr[], int s, int e, int key){    int mid;    if (arr[e] <= key)        return e + 1;    while (s < e)    {        mid = s + (e - s) / 2;        if (arr[mid] <= key)            s = mid + 1;        else            e = mid;    }    return s;}int LIS(int d[], int n){    int i = 0, len = 1, *end = (int *)alloca(sizeof(int) * (n + 1));    end[1] = d[0]; //初始化：长度为1的LIS末尾为d[0]    for (i = 1; i < n; i++)    {        int pos = upper_bound(end, 1, len, d[i]); //找到插入位置        end[pos] = d[i];        if (len < pos) //按需要更新LIS长度            len = pos;    }    return len;}

参考：

http://www.hawstein.com/posts/dp-novice-to-advanced.html
https://www.felix021.com/blog/read.php?1587

收集最多的苹果

平面上有N*M个格子，每个格子中放着一定数量的苹果。你从左上角的格子开始， 每一步只能向下走或是向右走，每次走到一个格子上就把格子里的苹果收集起来， 这样下去，你最多能收集到多少个苹果。

解这个问题与解其它的DP问题几乎没有什么两样。第一步找到问题的“状态”， 第二步找到“状态转移方程”，然后基本上问题就解决了。

首先，我们要找到这个问题中的“状态”是什么？我们必须注意到的一点是， 到达一个格子的方式最多只有两种：从左边来的(除了第一列)和从上边来的(除了第一行)。 因此为了求出到达当前格子后最多能收集到多少个苹果， 我们就要先去考察那些能到达当前这个格子的格子，到达它们最多能收集到多少个苹果。 (是不是有点绕，但这句话的本质其实是DP的关键：欲求问题的解，先要去求子问题的解)

经过上面的分析，很容易可以得出问题的状态和状态转移方程。 状态S[i][j]表示我们走到(i, j)这个格子时，最多能收集到多少个苹果。那么， 状态转移方程如下：

s[i][j]=A[i][j]+max(S[i−1][j],if i > 0;S[i][j−1],if j > 0)

其中i代表行，j代表列，下标均从0开始；A[i][j]代表格子(i, j)处的苹果数量。

S[i][j]有两种计算方式：1.对于每一行，从左向右计算，然后从上到下逐行处理；2. 对于每一列，从上到下计算，然后从左向右逐列处理。 这样做的目的是为了在计算S[i][j]时，S[i-1][j]和S[i][j-1]都已经计算出来了。

伪代码如下：

#include <iostream>  using namespace std;  #define MAX_N 100  #define MAX_M 100  int arr[ MAX_N ][ MAX_M ] = { 0 };  int dp[ MAX_N + 2 ][ MAX_M + 2 ] = { 0 };   int main(){      int n, m;      cin>> n >> m;  //输入n*m的方格      int i, j ;      for( i = 0; i < n; i++){          for( j = 0; j < m; j++)              cin>> arr[ i ][ j ];      } //输入方格中各个格子中的苹果数量      for( i = 0; i < n; i++){          for( j = 0; j < m; j++){              dp[ i + 1 ][ j + 1 ] = dp[ i ][ j + 1] > dp[ i + 1 ][ j ] ?                           dp[ i ][ j + 1] + arr[ i ][ j ] : dp[ i + 1][ j ] + arr[ i ][ j ];           }      }       cout<<dp[i][j]<<endl;      return 0;  }  

http://www.tuicool.com/articles/IVVvue

01背包问题

问题描述

有编号分别为a,b,c,d,e的五件物品，它们的重量分别是2,2,6,5,4，它们的价值分别是6,3,5,4,6，现在给你个承重为10的背包，如何让背包里装入的物品具有最大的价值总和？

问题分析

01背包的状态转换方程 f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ), f[i-1,j] }

代码实现

 #include<stdio.h>   #include<iostream>   using namespace std;   int table[10][100]={0};   int tableTwo[10][100];   int flag[10]={-1};    int Knapsack(int v[],int w[],int c,int n){//value weight capacity num       for(int i=1;i<n+1;i++){//因为涉及到i-1的计算，所以下标从1开始           for(int j=1;j<c+1;j++){              if(j<w[i]){                  table[i][j]=table[i-1][j];                  //flag[i]=0;              }else{                  table[i][j]=max(table[i-1][j],table[i-1][j-w[i]]+v[i]);                  //flag[i]=table[i-1][j]>(table[i-1][j-w[i]]+v[i])?0:1;              }          }      }      return table[n][c];   }   int KnapsackTwo(int v[],int w[],int c,int n){//此方法从n->1计算 。自底向上，自左向右       int jMax=min(w[n]-1,c);       for(int j=0;j<jMax;j++)tableTwo[n][j]=0;//j<当前背包容量或者当前物品重量时，tableTwo[n][j]=0;       for(int j=w[n];j<=c;j++)tableTwo[n][j]=v[n];//当前背包容量可以装得下时， tableTwo[n][j]=v[n];      for(int i=n-1;i>1;i--){          jMax=min(w[i],c);          for(int j=0;j<=jMax;j++)tableTwo[i][j]=tableTwo[i+1][j];          for(int j=w[i];j<=c;j++)tableTwo[i][j]=max(tableTwo[i+1][j],tableTwo[i+1][j-w[i]]+v[i]);//当前背包容量装得下，但是要判断其价值是否最大，确定到底装不装       }      tableTwo[1][c]=tableTwo[2][c];//先假设1物品不装       if(c>=w[1])tableTwo[1][c]=max(tableTwo[1][c],tableTwo[2][c-w[1]]+v[1]);//根据价值，判断到底装不装       return tableTwo[1][c];//返回最优值     }   void Traceback(int w[],int c,int n){//根据最优值，求最优解       for(int i=1;i<n;i++){          if(tableTwo[i][c]==tableTwo[i+1][c])flag[i]=0;          else {              flag[i]=1;              c-=w[i];              }      }      flag[n]=tableTwo[n][c]?1:0;   }   int main(){      int weight[6]={0,2,2,6,5,4};//最低位补了0，从weight[1]开始赋值       int value[6]={0,6,3,5,4,6};      int c=10;      cout<<"第一种方法->总价值最大为："<<Knapsack(value,weight,c,5)<<endl;      cout<<"第二种方法->总价值最大为："<<KnapsackTwo(value,weight,c,5)<<endl;      Traceback(weight,c,5);      cout<<"最优值的解：";       for(int i=1;i<5+1;i++)cout<<flag[i]<<" ";      cout<<endl;      for(int i=1;i<6;i++){          for(int j=0;j<11;j++){              printf("%2d ",tableTwo[i][j]);          }          cout<<endl;      }      return 0;   }   /* 第一种方法->总价值最大为：15 第二种方法->总价值最大为：15 最优值的解：1 1 0 0 1  0  0  0  0  0  0  0  0  0  0 15  0  0  3  3  6  6  9  9  9 10 11  0  0  0  0  6  6  6  6  6 10 11  0  0  0  0  6  6  6  6  6 10 10  0  0  0  0  6  6  6  6  6  6  6  */ 

http://blog.csdn.net/catkint/article/details/51009680
http://blog.csdn.net/mu399/article/details/7722810