算法导论：动态规划

一般情况下，对于一个问题，由于使用暴力求解或者直接求解的方法计算量会非常大， 所以按照动态规划的思想，将问题分解为可以利用规模更小的子问题来求解的问题，这样就大大减小了计算量，但是随之而来的是程序与算法的复杂度的上升。

对于一个动态规划问题，可以使用递归的方法，也可以不用递归的方法，不用递归的情况，一般需要注意算法设计中子问题的求解顺序，就像钢条切割问题的自顶向下还是自底向上。

top-down实现

#include <iostream>
#include <algorithm>
#include <limits.h>
using namespace std;

int cutRod(int* p, int n)
{
    if(n==0)
        return 0;
    int q = INT_MIN;
    for(int i=1;i<=n;i++)
    {
        q=max(q,p[i-1]+cutRod(p,n-i));
    }
    return q;
}

int main()
{
    int p[10]={1,5,8,9,10,17,17,20,24,30};
    for(int i=0;i<=10;i++)
        cout<<cutRod(p,i)<<endl;
    return 0;
}

自顶向下，加了备忘机制。

int memoized_cutRod_aux(int* p,int n,int* r)
{
    int q;
    if(r[n]>=0)
        return r[n];
    if(n==0)
        q=0;
    else
    {
        q=INT_MIN;
        for(int i=1;i<=n;i++)
            q=max(q,p[i-1]+memoized_cutRod_aux(p,n-i,r));
    }
    r[n]=q;
    return r[n];
}

int memoized_cutRod(int* p,int n)
{
    int r[n+1];
    for(int i=0;i<=n;i++)
    {
        r[i]=INT_MIN;
    }
    return memoized_cutRod_aux(p,n,r);
}

自底向上方法，不适用递归

int bottom_up_cutRod(int* p,int n)
{
    int r[n+1];
    r[0]=0;
    for(int j=1;j<=n;j++)
    {
        int q=INT_MIN;
        for(int i=1;i<=j;i++)
        {
            q = max(q,p[i-1]+r[j-i]);
        }
        r[j]=q;
    }
    return r[n];
}