动态规划之三：线形，树型，矩阵动规

1. 动态规划的基本类型

1.1线形

1.1.1 一推一类型：比如等比等差数列 q(n)=q(n-1)*p(p为公比），a(n)=a(n-1)+d(d为公差）

累加和：s(n)=s(n-1)+n ，累乘积：f(n)=f(n-1)*n

1.1.2 多推一类型：比如兔子数列 f(n)=f(n-1)+f(n-2) ，最长不降子序列。

1.2树形

1.2.1 父推子（一推多）

1.2.2 子推父（多推一）

1.3矩阵形

1.3.1 一推多（我为人人）：数塔问题

1.3.2 多推一（人人为我）：数塔问题，背包问题，最长公共子序列问题

2，实例

2.1 最长不降子序列问题

#include<bits/stdc++.h>
using namespace std;
int a[1000];
int f[1000];//表示前i个数的最长不降子序列数长度
int father[1000]; //记录父亲 
int k=0;//记录最长不降子序列最后一个元素的位置 
int main()
{
    int n, ans=1;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        f[i]=1;
        father[i]=i; 
    } 
    for(int i=2;i<=n;i++)
    {
        int maxf=0;
        
        for(int j=1;j<i;j++)
        {
            if(f[j]>maxf && a[j]<=a[i])
            {
                maxf=f[j];
                father[i]=j;
            }
        }
        f[i]=maxf+1;
        if(f[i]>ans)
        {
            ans=f[i];
            k=i;//记录最长不降子序列最后一个元素的位置 
        } 
    }
    stack<int>s;
    int p=k;
    while(father[p]!=p)
    {
        s.push(p);
        p=father[p];
    }
    s.push(p);//第一个元素入栈 
    cout<<"max="<<ans<<endl;
    while(!s.empty())
    {
        cout<<a[s.top()]<<" ";
        s.pop();
    }
    return 0;
}
/*
14
13 7 9 16 38 24 37 18 44 19 21 22 63 15
*/

2.2 数塔问题

解题方法一共有四种：我为人人，自顶向下；人人为我，自顶向下；我为人人，自下向上；人人为我，自下向上。

#include<bits/stdc++.h>
using namespace std;
int R;
int a[1001][1001];
int main()
{
    cin>>R;
    for(int i=1;i<=R;i++)
    {
        for(int j=1;j<=i;j++)
        {
            cin>>a[i][j];
        }
    }
    for(int i=R-1;i>=1;i--)//自下向上 
    {
        for(int j=1;j<=i;j++)
        {
            a[i][j]+=max(a[i+1][j],a[i+1][j+1]);//人人为我 
        }
    }
    cout<<a[1][1];
    return 0;
}

2.3 最长公共子序列问题

#include<bits/stdc++.h>
using namespace std;
string s1,s2;
int f[201][201];
int main()
{
    while(cin>>s1>>s2)
    {    
        memset(f, 0, sizeof(f));
        for(int i=1;i<=s1.size();i++)
        {
            for(int j=1;j<=s2.size();j++)
            {
                f[i][j]=max(f[i-1][j],f[i][j-1]);
                if(s1[i-1]==s2[j-1])
                {
                    f[i][j]=max(f[i-1][j-1]+1,f[i][j]);
                }
            }
        }
        cout<<f[s1.size()][s2.size()]<<endl;
    }

    return 0;
}