第五章——动态规划2

线性DP

数字三角形

像二维数组一样，设置行和列，只不过这里的列是斜着的，如圈出来的7，坐标可以表示为(4,2)

集合划分，所有路径可以分成俩类，某点左上方一类，右下方一类。

我们先把7去掉，左边计算的就是从起点到8路径的最大值，8的坐标是i-1,j-1，即左边状态可以表示为f[i-1,j-1]含义是从起点走到8这个位置的最大值，最后再给加7

右边计算也同理

f[i,j]=max（左边，右边）

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 510,INF=1e9;
int n, m;
int a[N][N];//a存点
int f[N][N];//f数组表示状态
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            scanf("%d", &a[i][j]);
    for (int i = 0; i <= n; i++)
        for (int j = 0; j <= i+1; j++)
            f[i][j] = - INF;//给状态数组初始化
    f[1][1] = a[1][1];//从第一个点走到第一个点的最大值只有一个就是a[1][1]
    for (int i = 2; i <= n; ++i)
        for (int j = 1; j <= i; j++)
            f[i][j] = max(f[i - 1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);
    int res = -INF;
    for (int i =2; i <= n; i++)
        res = max(res, f[n][i]);
    cout << res << endl;
    return 0 ;
}

最长上升子序列

该题1 2 5 6严格递增，所以输出是4

我们以第i-1个数来分类，第一个格子0，表示没有第i-1个数，即序列长度是1，之后分别是 i-1是第一个数，i-1是第2个数，i-1是第三个数……倒数第二个数是i-1

由于是上升子序列，aj<ai，aj在ai前面，设最后一个数是ai,倒数第二个数是aj，这样的最大长度上升子序列是f[j]+1，即以j为结尾的最大上升子序列+1

时间复杂度O(N^2)

const int N = 1010;
int n;
int a[N], f[N];
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1;//f[i]至少为1，即上升子序列只有一个数
        for (int j = 1; j < i; j++)//枚举到i的前一个数，所以这里不能是j<=i
            if (a[j] < a[i])
                f[i] = max(f[i], f[j] + 1);
    }
    int res = 0;
    for (int i = 1; i <= n; i++)
        res = max(res, f[i]);
    cout << res << endl;

    return 0;
}

把上述的最长序列保存下来

const int N = 1010;
int n;
int a[N], f[N],g[N];//g用来保存f[i]是由哪个状态转移来的
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1;//f[i]至少为1，即上升子序列只有一个数
        g[i] = 0;
        for (int j = 1; j < i; j++)//枚举到i的前一个数，所以这里不能是j<=i
            if (a[j] < a[i])
                if(f[i]<f[j]+1)
                    {
                        f[i]=f[j]+1;
                        g[i] = j;//存一下f[i]是由哪个状态转移来的
                    }
    }
    int k=1;
    for (int i = 1; i <= n; i++)
        if (f[k] < f[i])
            k = i;//k记录最优解的下标
    printf("最大上升子序列长度：%d\n", f[k]);
    for (int i = 0, len = f[k]; i < len; i++)
    {
        printf("%d ", a[k]);
        k = g[k];
    }
    return 0;
}

最长公共子序列问题

这里abd满足条件，所以输出3。

f[i,j]表示的是第一个序列的前i个字母和第二个序列的前j个字母构成的公共子序列。

以a[i]和b[j]是否包含在子序列当中作为划分的依据。a[i]和b[j]选不选共有四种组合情况，我们划分成四个子集，00表示都不选，01不选a[i]，选b[j]，10选a[i]，不选b[j]，11俩个都选

00用f[i-1,j-1]来表示，因为f[i,j]没被选，a[i],b[j]没被选

11f[i-1,j-1]+1，去掉最后一组，最后给加回来

中间用f[i-1,j]和f[i,j-1]表示。一般不写00这个状态，因为后面的这些状态里包含该状态。

const int N = 1010;
int n, m;
char a[N], b[N];
int f[N][N];
int main()
{
    scanf("%d %d", &n, &m);
    scanf("%s%s", a + 1, b + 1);//下标从1开始保存
    for(int i=1;i<=n;i++)
        for (int j = 1; j <= m; j++)
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if (a[i] == b[j])
                f[i][j] = max(f[i][j], f[i - 1][j - 1]+1);
        }
    cout << f[n][m] <<endl;
    return 0;
}

石子合并

设有N堆石子排成一排，其编号为1，2，3，…，N。
每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆 石子合并成为一堆。
每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。
例如有4堆石子分别为 1 3 5 2， 我们可以先合并1、2堆，代价为4，得到4 5 2， 又合并 1，2堆，代价为9，得到9 2 ，再合并得到11，总代价为4+9+11=24；
如果第二步是先合并2，3堆，则代价为7，得到4 7，最后一次合并代价为11，总代价为4+7+11=22。
问题是：找出一种合理的方法，使总的代价最小，输出最小代价。
输入格式
第一行一个数N表示石子的堆数N。
第二行N个数，表示每堆石子的质量(均不超过1000)。
输出格式
输出一个整数，表示最小代价。
数据范围
1≤N≤300
输入样例：
4
1 3 5 2
输出样例：
22

我们以最后一次分界线的位置来分类，可以分成很多类。

含义：左边分一个，左边分2个，左边分3个......一直到k-1个

假设最后合并的是这俩堆，我们可以先将这俩堆去掉，因为无论怎么合并，最后都会合并这俩堆，即去掉最后一步求最大值

左边的最小代价+右边的最小代价+最后一步的代价。

最后一步的代价其实是第i堆到第j堆实际的总重量，最后一堆用前缀和表示为s[j]-s[i-1]。

最终结果从取最小值，k从i枚举到j-1

时间复杂度：O(N^3)。

const int N = 310;
int n;
int s[N];//前缀和
int f[N][N];//状态
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
    for (int i = 1; i <= n; i++)
        s[i] += s[i - 1];
    //按照从小到大枚举所有状态
    for(int len=2;len<=n;len++)
        for (int i = 1; i + len - 1 <= n; i++)
        {
            int l = i, r = i + len - 1;//左右端点
            //如果只有一堆，和并不需要代价
            f[l][r] = 1e9;
            for (int k = l; k < r; k++)
                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
        }
    cout << f[1][n] <<endl;
    return 0;
}