动态规划（初级）

1.数字三角形（线性DP）

题目描述：
给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

测试样例：

输入：
5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5
输出：
30

代码如下：

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

const int N=520;
int f[N][N];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=i; j++)
        {
            scanf("%d",&f[i][j]);
        }
    }
    for(int i=n-1; i>0; i--)//从下向上统计
    {
        for(int j=1; j<=i; j++)
        {
            f[i][j]=f[i][j]+max(f[i+1][j],f[i+1][j+1]);
        }
    }
    printf("%d",f[1][1]);
    return 0;
}

2.最长上升子序列(线性DP)

题目描述：
给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。
测试样例：

输入：
7
3 1 2 1 8 5 6
输出：
4

代码如下：

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

const int N=1010;
int arr[N],f[N];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1; i<=n; i++) scanf("%d",&arr[i]);
    for(int i=1; i<=n; i++)//遍历所有点
    {
        f[i]=1;//只有arr[i]一个数
        for(int j=1; j<i; j++)//求某一个点的最长子序列
        {
            if(arr[j]<arr[i])
                f[i]=max(f[i],f[j]+1);
        }
    }
    int res=0;
    for(int i=1; i<=n; i++) res=max(res,f[i]);
    printf("%d",res);
    return 0;
}
//动态规划问题有一点前缀和的意思，前一步总是为后一步做铺垫

二分+单调队列+贪心：

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

const int N = 100010;
int n;
int a[N];
int q[N];
int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    int len = 0;
    for (int i = 0; i < n; i ++ )
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }

    printf("%d\n", len);

    return 0;
}

3. 最长上升子序列2

输入：
7
3 1 2 1 8 5 6
输出：
4

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

const int N = 100010;
int n;
int a[N];
int q[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);
    int len = 0;
    for (int i = 0; i < n; i ++ )
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }
    printf("%d\n", len);
    return 0;
}

4. 最长公共子序列（线性DP）

输入：
4 5
acbd
abedc
输出：
3

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

int n,m;
char s1[1010],s2[1010];
int f[1010][1010];//第一维表示搜到第一个字符串的位置，第二维表示搜到第二个字符串的位置，f表示当前位置公共子序列大小

int main()
{
    cin>>n>>m;
    scanf("%s",s1+1);
    scanf("%s",s2+1);
    
    for(int i=0;i<=n;i++) f[i][0]=0;//注意初始化
    for(int i=0;i<=m;i++) f[0][i]=0;
    
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(s1[i]==s2[j]) f[i][j]=f[i-1][j-1]+1;//当前相等，必然等于他俩上一个加一
            else f[i][j]=max(f[i-1][j],f[i][j-1]);//不相等就要一边一边的试，此处上升到哲学问题
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

5.跳格子

#include<iostream>
#include<algorithm>
using namespace std;
const int N=10010;
int f[N];
int a[N];
int main()
{
    int n;
    cin>>n;
    for(int i=1; i<=n; i++)
    {
        cin>>a[i];
        f[i]=1e9+7;
    }
    f[1]=0;//第一个位置不需要跳
    for(int i=2; i<=n; i++)
    {
        for(int j=1; j<i; j++)
        {
            if(a[j]+j>=i)//选中的某个地方能走到当前位置
                f[i]=min(f[i],f[j]+1);
        }
    }
    cout<<f[n]<<endl;
    return 0;
}

6.摘花生（线性DP）

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

int w[110][110];
int f[110][110];

int main()
{
    int t,r,c;
    cin>>t;
    while(t--)
    {
        cin>>r>>c;
        for(int i=1;i<=r;i++)
        {
            for(int j=1;j<=c;j++)
            {
                cin>>w[i][j];
            }
        }

        for(int i=1;i<=r;i++)
        {
            for(int j=1;j<=c;j++)
            {
                f[i][j]=max(f[i][j-1],f[i-1][j])+w[i][j];
            }
        }
        cout<<f[r][c]<<endl;
        //memset(w,0,sizeof w);
        //memset(f,0,sizeof f);
    }
    return 0;
}

7. 最大正方形（线性DP）

#include<iostream>
using namespace std;

int f[110][110];
int maxn;

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            int a;
            scanf("%d",&a);
            if(a)
            {
                f[i][j]=min(min(f[i-1][j],f[i][j-1]),f[i-1][j-1])+1;//这三个点可以任意交换顺序
            }
            maxn=max(maxn,f[i][j]);
        }
    }
    cout<<maxn<<endl;
    return 0;
}

8. 整数划分（计数DP,类似完全背包）

输入：
5
输出：
7

类似完全背包解法

f[i][j] 表示前i个整数（1,2…,i）恰好拼成j的方案数
求方案数：把集合选0个i，1个i，2个i，…全部加起来
f[i][j] = f[i - 1][j] + f[i - 1][j - i] + f[i - 1][j - 2 * i] + …;
f[i][j - i] = f[i - 1][j - i] + f[i - 1][j - 2 * i] + …;
因此 f[i][j]=f[i−1][j]+f[i][j−i];(这一步类似完全背包的推导）

二维：

#include<iostream>
using namespace std;

const int mod=1e9+7;
int n;
int f[1010][1010];

int main()
{
    cin>>n;
    
    for(int i=0;i<=n;i++) f[i][0]=1;//前i个物品不选也是一种方案，初始化
    
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=n;j++)
        {
            f[i][j]=f[i-1][j]%mod;
            if(j>=i) f[i][j]=(f[i-1][j]+f[i][j-i])%mod;
        }
    }
    cout<<f[n][n]<<endl;
}

一维：

#include<iostream>
using namespace std;

const int mod=1e9+7;
int n;
int f[1010];//和为j的方案数

int main()
{
    cin>>n;
    
    f[0]=1;//不选也是一种方案，初始化
    
    for(int i=1;i<=n;i++)
    {
        for(int j=i;j<=n;j++)
        {
            f[j]=(f[j]+f[j-i])%mod;
        }
    }
    cout<<f[n]<<endl;
}

递归实现整数划分

#include<iostream>
using namespace std;

int nn;

// 递归计算划分数
int int_HuaFen(int n, int m)
{
    if (n == 1 || m == 1)
        return 1;
    else if (n < m)
        return int_HuaFen(n, n);
    else if (n == m)
        return 1 + int_HuaFen(n, n - 1);
    else
        return int_HuaFen(n, m - 1) + int_HuaFen(n - m, m);
}

int main()
{
    cin>>nn;
    cout<<int_HuaFen(nn,nn)<<endl;
    return 0;
}