动态规划

      动态规划的实质是将较大问题问题分解为较小的同类子问题。与分治法和贪心法不同的是，动态规划法利用最优子结构，自底向上从子问题的最优解逐步构造出整个问题的最优解。

      设计一个动态规划算法，通常可以按一下4个步骤进行：

      （1）刻画最优解的结构特性；

      （2）递归定义最优解值；

      （3）自底向上计算最优解值；

      （4)根据计算得到的信息构造一个最优解。

      一个最优化多步决策问题是否适合用动态规划方法求解有两个要素：最优子结构核重叠子问题。

     虽然动态规划法也是基于分解思想的，但由于子问题往往是重叠的，为了避免重复计算，动态规划算法采用字自底向上的方式进行计算，并且保存已求解的子问题的最优解值。当这些子最优解值被重复引用时无需重新计算，因而节省大量计算时间。

     下面是我的题解，记录于此。

1.斐波拉契数列

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1003

     先从斐波拉契数来窥探动态规划问题。既然斐波那契数就由之前的两数相加得到，那么循环中我们记录它的前两个数，自底向上求到斐波拉契数。

#include<iostream>
using namespace std;

int main()
{
    int n,i;
    cin>>n;
    if(n==0||n==1) 
        cout<<n<<endl;
    else
    {
        int f1=0,f2=1,f3;
        for(i=2;i<=n;i++)
        {
            f3=f1+f2;
            f1=f2;
            f2=f3;        
        }
        cout<<f3<<endl;
    }
    return 0;
}

2.最长递减子序列

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1161

     当前每个数的最长子序列依赖于它的子序列，因此我们自后向前记录每个数的最长子序列，最后输出最大值即可。

#include<iostream>
using namespace std;

int main()
{
    int n,*a,*count,i,j,max;
    cin>>n;
    a=new int[n];
    count=new int[n];
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        count[i]=1;
    }
    for(i=n-1;i>=0;i--)
    {
        max=0;
        for(j=i+1;j<n;j++)
            if(a[j]<a[i]&&max<count[j]) 
                max=count[j];
        count[i]+=max;
    }
    for(i=0;i<n;i++)
    {
        if(max<count[i])
            max=count[i];
    }
    cout<<max<<endl;
    delete []a;
    delete []count;
    return 0;
}

 3.最少硬币问题

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1221

      最开始考虑贪心法，WA。换DP，AC！看来还是没有深刻区分两类问题。其中，num数组记录要使用当前种类硬币的个数，count数组记录需要找的钱数的最少硬币个数。这里18块由13块跟硬币5组成，13块由8块跟硬币5组成，8块由3块跟硬币5组成，3块由1块跟硬币2组成，1块由硬币1得到。反过来也就是从1块钱开始，自底向上记录需要找的钱数的最少硬币个数。

#include<iostream>
using namespace std;

int main()
{
    int n,*T,*Coins,i,j,m,*count,*num;
    cin>>n;
    T=new int[n];
    Coins=new int[n];
    for(i=0;i<n;i++)
        cin>>T[i]>>Coins[i];
    cin>>m;
    count=new int[m+1];
    num=new int[m+1];
    for(i=1;i<=m;i++)
        count[i]=0xfffffff;
    count[0]=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<=m;j++)
            num[j]=0;
        for(j=0;j<=m-T[i];j++)
        {
            if(num[j]<Coins[i]&&count[j]+1<count[j+T[i]])
            {
                count[j+T[i]]=count[j]+1;
                num[j+T[i]]=num[j]+1;
            }
        }        
    }
    if(count[m]!=0xfffffff)
        cout<<count[m]<<endl;
    else
        cout<<"-1"<<endl;
    delete []T;
    delete []Coins;
    delete []count;
    delete []num;
    return 0;
}

4.数字三角形

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1989

#include<iostream>
using namespace std;

inline int max(int a,int b)
{
    return a>b?a:b;
}
const int MAX=101;

int main()
{
    int t,n,i,j;
    int a[MAX][MAX];
    int p[MAX][MAX];
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(i=0;i<n;i++)
            for(j=0;j<=i;j++)
                cin>>a[i][j];        
        for(i=0;i<n;i++)
            p[n-1][i]=a[n-1][i];
        for(i=n-2;i>=0;i--)
        {
            for(j=0;j<=i;j++)
            {
                p[i][j]=a[i][j]+max(p[i+1][j],p[i+1][j+1]);
            }
        }
        cout<<p[0][0]<<endl;
    }
    return 0;
}

5.吃苹果

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1060

      动态方程p[i][j]=max(p[i-1][j]+p[i-1][j-1])+(有苹果+1)。

#include<iostream>
using namespace std;
#define MAXT 1001
#define MAXK 31
inline int max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int t,k,i,j;
    cin>>t>>k;
    int a[MAXT];
    int p[MAXT][MAXK];
    for(i=1;i<=t;i++)
        cin>>a[i];
    p[0][0]=0;
    for(i=1;i<=t;i++)
    {
        p[i][0]=p[i-1][0]+a[i]%2;
        for(j=1;j<=k;j++)
        {
            p[i][j]=max(p[i-1][j-1],p[i-1][j])+(j%2==(a[i]-1)?1:0);    
        }
    }
    int max=0;
    for(j=1;j<=k;j++)
        if(p[t][j]>max) max=p[t][j];
    cout<<max<<endl;
    return 0;
}

6.最长公共子序列

      动态方程c[i][j]=c[i-1][j-1]                      s1[i]=s2[j];

                 c[i][j]=max(c[i][j-1],c[i-1][j])    s1[i]≠s2[j];

#include<iostream>
#include<string>
using namespace std;

void LCS(const string s1,const string s2)
{
    int i,j;
    int len1=s1.length();
    int len2=s2.length();
    int **c=new int*[len1+2];
    for(i=0;i<=len1;i++)
        c[i]=new int[len2+2];
    for(i=0;i<=len1;i++)
        c[i][0]=0;
    for(i=0;i<=len2;i++)
        c[0][i]=0;
    for(i=1;i<=len1;i++)
    {
        for(j=1;j<=len2;j++)
        {
            if(s1[i-1]==s2[j-1])
                c[i][j]=c[i-1][j-1]+1;
            else if(c[i-1][j]>=c[i][j-1])
                c[i][j]=c[i-1][j];
            else
                c[i][j]=c[i][j-1];
        }
    }
    /******* c矩阵 *********
    for(i=0;i<=len1;i++)
    {
        for(j=0;j<=len2;j++)
            cout<<c[i][j]<<" ";
        cout<<endl;
    }
    ************************/
    cout<<c[len1][len2]<<endl;
    for(i=0;i<=len1;i++)
        delete []c[i];
    delete []c;
}

int main()
{
    string s1,s2;
    while(cin>>s1>>s2)
    {
        LCS(s1,s2);
    }
    return 0;
}

7.待续

...

      通过这几题的练习，应该可以解决一些简单的DP问题了。