动态规划问题

　　参考http://chuansong.me/n/112761

　　先从一个基本的例子上手

　　我们有面值为1元、3元和5元的硬币若干枚，如何用最少的硬币凑够11元？

　　令n=f(v),表示n个硬币可凑齐v元,现在需要求n的最小值

　　当v为0时，f(0)=0

　　当v为1时，可以取1元硬币了，我取1个1元硬币，f(1)=1+f(1-1)　

　　当v为2时，可以取1元硬币，我取1个1元硬币，f(2)=1+f(2-1)=2

　　当v为3时，可以取1元硬币和3元硬币，我可以取1个1元或者1个3元，f(3)=min(1+f(3-1),1+f(3-3))=1

　　当v为4时，可以取1元硬币和3元硬币，我可以取一个1元或者1个3元，f(4)=min(1+f(4-1),1+f(4-3))=2

　　当v为5时，可以取1元硬币、3元硬币和5元硬币，f(5)=min(1+f(5-5),1+f(5-3),1+f(5-1)))=1

　　够了，通项f(v)=min(f(v-x[j])+1)  x[j]表示各种面值

int getMin(int v,vector<int>& x){             //x[0]=1,x[1]=3,x[2]=5
    int temp[100]={0};                        //其实只用保证temp[0]=0就可以了
    int flag;                                 
    for(int i=1;i<=v;++i){
        flag=1000;                             
        for(int j=0;j<x.size();++j){           //min(f(i-x[j])+1),自底向上的方式，不用单独去做备忘录 
            if(x[j]<=i&&flag>temp[i-x[j]]+1){    
                flag=temp[i-x[j]]+1;
            }
        }
        temp[i]=flag;
    }
    return temp[v];
}

　　小结一下，动态规划就是在寻找状态方程f(v)=min(f(v-x[j])+1)

　　再上一个例子

　　找出序列的最长非递减子序列的长度，eg，序列为5,3,4,8,6,7

　　令n=f(v)，表示前v个数的最长非递减子序列为n

　　当v=1时，f(1)=1

　　当v=2时，第2个数比第1个小，f(2)=1

　　当v=3时，第3个数比第2个大，f(3)=f(2)+1

　　当v=4时，第4个数比第1、2、3个数大，f(4)=max(f(1)+1,f(2)+1,f(3)+1)

　　够了，状态方程f(v)=max(1,f(j)+1)    j<v&&a[v]>=a[j]

 

int getMax(vector<int>& a){
    if(a.empty())return 0;
    int b[1000]={1};
    int flag=1;
    for(int i=0;i<a.size();++i){
        for(int j=i-1;j>=0;--j){
            if(a[i]>=a[j]&&b[i]<b[j]+1){
                b[i]=b[j]+1;
            }
            if(b[i]<b[j])
                b[i]=b[j];
        }
    }
    return b[a.size()-1];
}