算法--动态规划（线性DP、区间DP）

tip

数组下标从0开始还是从1开始

如果代码中涉及到数组下标为i-1（有时候哪怕不是同一个数组也符合情况，因为是针对同一组数据进行的多个数组设置），那么我们可以使 i 从 1开始，这样，当 i = 1 时，就取到了[0]，如果这个位置有特殊情况，那么这样一来我们也不必使用 if ，直接对 f [0]设置一个特殊值即可

注意，“输入”与“使用”是统一的，即如果输入数组时决定了使用 i 从 1 开始，那么到时候使用或者取元素时，一定要记得是从 1 开始，
如果输入决定了是从0开始，那么到时候取元素的时候，记得从0开始

线性DP

数学三角形

介绍

从顶部出发，可以向左下或者右下移动，最后形成一条路径，找到一条路径使得路径上的数字之和最大

算法思想

首先我们对三角形的各个数进行编码，从上到下每行从1开始表上行号，之后，东北方向偏45度进行列号的编排，最左边是1列，之后往右依次是2，3，…，这样一来，我们就可以标定某个元素的位置，这也符合三角形位置的数据在数组内存储时的位置

对于动态规划，仍然是状态表示和状态计算，
状态表示：因为每个元素由一个二维数对进行位置表示，所以，状态表示仍然是一个二维的，如上图所示，属性是max
状态计算：由前面的经验可以总结出：状态计算是一个情况的划分，划分的是上一层的情况，即仅研究上一层即可，之后递推原理会帮助代码完成
上一层的状态有两个，一个来自左上，一个来自右上。
两种划分都是曲线救国的思路，即 f [ i - 1 , j - 1 ] + a[ i , j ]，另一个是 f [ i - 1 , j ] + a[ i , j ]
其中 a数组存储了所有的数据，a [ i , j ]就是表示[ i , j ]位置的值

例题+代码

首先，a[N][N]数组是用来存储所有的数据的
f[N][N]是状态表示

之后，main函数里
首先读入n
之后由于这组数据会涉及到 i-1 ，所以使用数组存数据时，i从1开始到小于等于n，j从1开始到小于等于 i （因为是三角形），读入到a[][]数组中，给[0][x] [x][0]这些位置空出来，方便一些特殊情况时拿来使用（包括a数组自己使用或者其他数组使用，总之这个位置要留出来）
之后初始化状态表示，因为状态表示数组涉及到某一点的上边两个角，所以，要处理好边界问题，我们的 i 从 0开始到等于n，j 从 0开始到等于 i + 1 （这样做可以在原来的数据基础上，多加一个0行和0列被初始化，这样的话，当我们遇到如下图所示情况时，就不会出错了），且f[i][j] = - INF，将所有的位置初始化为负无穷，这样的话，最终原数据的外面的位置下标，f[][]的值是负无穷，这样做是为了当我们有路径来到了原数据的外面，那最后的值一定是负无穷，这样我们就可以筛选出来哪些路径是经过了原数据的外面的位置得到的，这些数据可以排除
之后初始化f[1][1] = a[1][1]，因为第一个还没有经过任何其他的点，可以初始化为a[1][1]
之后for循环，i 从 2 开始到等于n（之所以从2开始，是因为1就一个节点，已经被赋值了）
二层循环 ，j 从 1 开始到等于i （仍然是因为输入时是三角形输入）
f[ i ][ j ] = max（f[ i - 1 ][j - 1] + a[ i ][ j ] , f[ i - 1 ][ j ] + a[ i ][ j ]）
（这里我们可能会感觉到与背包问题的不一致，这里，f[i][j]并不亲自进入max参与比较了，原因是，背包问题的 f 代表的就是当前状态下所有情况的最大值，而这里的 f 是代表的是每个 i j 点的值，所以，只将其上一层的状态进行放入max中，进行递归即可，他本身不用进行比较）
到此为止，我们就已经可以拿到所有以 i j 点为终点的路径和的最大值了，我们由于是想求最大路径，所以对叶子结点的状态进行求max即可，这里由于之前所有的f都被初始化为了负无穷，所以这样答案也初始化为负无穷去进行比较，而就算有路径经过了负无穷，那最后的值是-INF+一些正数，肯定比-INF要大一点点，所以，res用-INF存储，最后参与到max中

最长上升子序列

介绍

例如这样一个序列，最长子序列就是 1 2 5 6，长度最长是4

算法思想

状态表示可以使用一维的，即所有以“第” i 个数结尾的上升子序列，属性是max
状态计算：
划分依据：上一层是第几个数
如果上一层没有数，那么说明只有“第i个数”这一个数
如果上一层的数是第 j 个数，那么可以递推为 f [ j ] + 1（这个j是有条件的，要满足aj < ai）
最后对所有的f[ j ] + 1 （j从0开始到 i - 1）取max就是答案

例题+代码

a数组表示将数据进行存储，f数组表示状态表示
在mian函数中
首先输入n
i 从 1 到等于n ，输入a[ i ]
之后对for从1到等于n
f[ i ] = 1 ,（所有的 f 最少是1，所以先初始化为1）
之后，对于for循环，j 从 1 开始到小于 i （因为状态计算时，是以" "前一个数"是第几个数 " 进行划分的，所以j从1到小于i，表示遍历所有划分的情况，为后续取max做准备，这样就可以找到最大的子序列对应的是哪个 j ，因为每个j对应的f[j] 是不同的）
同时判断 if （a[j] < a[i]）才是合法的（因为是上升子序列，要求单调）
之后 f[i] = max(f[i] , f[j]+1)（对所有的划分进行max）

最后，把所有的 f[i] 进行取max，即，将所有的情况取最大值，就是最大子序列

补充：

在“动态规划（2）”中00：54时，介绍了如何将最长子序列保存下来

最长公共子序列

介绍

算法思想

首先，对于状态表示，集合方面，表示所有在第一个序列的前i个字母中出现，且在第二个序列的前 j 个字母中出现的公共子序列，属性是max

之后对于状态计算
可以对公共子序列是否包含a[i] b[j]进行划分，0表示不包含，1表示包含，如上图
之后对于00：
f [ i - 1 , j - 1]
对于11：
f [ i - 1 , j - 1]
对于上面这两个，毫无疑问，确实是这样表示的，
但是对于01和10，我们下面这种表示，是错误的，拿01举例来说，我们想要的是不包含ai但是必须要有bj，而f [i - 1 , j ]表示不包含ai，但是可以有bj也可以没有，所以他是错的，但是f [i - 1 , j ]包含了01这种情况，由于我们是求最大值，而且f的属性也是max，所以，既然f [i - 1 , j ]包含了01的情况，那么就可以拿来进行对比，因为如果对于f [i - 1 , j ]来说，如果01是其所有情况的最大值，那么就符合我们的要求，如果不是，那么我们也没必要再关注01了，而是其他某种情况，所以可以直接用f [i - 1 , j ]。10同理
对于01：
f [i - 1 , j ]
对于10：
f [ i , j - 1 ]

最后补充：

我们在写代码时，不用写00的情况，因为这种情况也被包含在了f [i - 1 , j ]和f [i , j - 1]两种情况里，所以我们在写代码时只需要考虑后面三种情况即可

例题+代码

n和m表示a和b字符串的长度
char a b数组用来存储字符串
f数组是状态表示

之后在main里：
首先输入n 和 m
之后输入字符串，使用%s，以及数组名(这里是数组名+1，可以从数组的第二个位置，也就是下标为1的位置开始将整个字符串都读入,因为代码中出现了i-1)
之后for i 从1~=n
二重循环 j 从1~=m（也就是将所有的 f 进行了遍历）
f[i][j] = max (f[i-1][j] , f[i][j-1])，先将这两个进行取max
之后对11这种情况进行判断
只有当a[i] == b[j]时，才会有第三种情况，所以只有该条件成立，将第三种情况放入max中
最后输出 f[n][m]

注意，因为我们是存储字符串，a b数组一定要用char数组，而不能使用int数组，首先这是一个规范问题，其次：

因为int型有四个字节，而字符只占一个字节，所以，从a[ 1 ]开始存入四个字符的话，就会如上图所示效果，四个字符才占满一个int，从而会导致程序错误

编辑距离

介绍

例题+代码

区间DP问题

石子合并

介绍

不同的合并顺序，所耗费的总代价是不同的，这是因为我们每次合并的之后产生的代价都会被计算在内，所以，虽然最后的总质量是不变的，但是前期每一个步骤花费的代价都被计算在内，所以，关键就在于前期合并时的代价要尽可能的小

算法思想

状态表示如上图所示，属性为min
状态计算：
划分的依据是合并成 f[i , j ]的过程中，最后一次合并时，左右两边的大堆是由多少个小堆合并而来的。
我们以左边大堆的基础堆数为依据进行图示，如上图，从1、2、3、…k-1，k表示基础石碓的总堆数：j-i+1

接上面状态计算，我们这里由数量转换到区间，注意，这时这里的k表示区间的分界点，而不是总堆数，代码中或者理解上换个字母也可以，
从 i 堆到 j 堆，我们看这个过程中最后一堆的合成，我们假设是区间【i，k】和区间【k+1，j】，分别表示左边大堆和右边大堆，然后，因为根据题意，我们最后还有加上目前的总研究范围内的堆数之和，因为最后总会加上总堆数，而目前我们的总研究范围是i到j，所以我们不能确定 i 和 j 是什么，所以使用前缀和进行计算，即s[ j ] - s[ i-1 ]，表示 i 到 j 的总堆数。
因为总堆数是一个定数，所以划分上一层时，可以将总堆数排除计算，最后再加回来即可，所以就是用f[i , k] + f[k + 1 , j]进行划分，最后加上总堆数s[ j ] - s[ i-1 ]
而我们的f[i , j]=min{f[i , k] + f[k + 1 , j]+s[ j ] - s[ i-1 ]}，k从i遍历到j-1（之所以遍历到j-1，是因为右边堆最少有一个基础堆，所以不能是j。表示左边堆的数量从1到k-1）
这里之所以k从 i 到 j-1，是因为当k=i时，区间划分为【i，i】【i+1，j】，这是左边只有一堆的情况，当k=j-1时，区间为【i，j-1】【j，j】，这是右边只有一堆的情况，两边的端点情况都被包括了。是合理的
时间复杂度是o（n的三次方）

例题+代码

注意，因为区间dp的递归中，没有明显的归的代码，也就是一些基础数据没有被计算，所以我们在做区间划分递归时，要用一个手段，来保证每次状态的计算所用到的状态都已经被计算好了，这个手段就是根据区间长度进行循环，先算区间长度小的状态

数据分析：s数组用来计算前缀和，f数组是状态表示

在main函数中：
首先输入n
之后，i从1~=n输入各个堆的重量到s数组中，之后i从1到等于n，进行前缀和的求和：s[ i ] += s[ i -1]
之后开始长度循环，长度从1开始到小于等于n，但是由于长度为1时，总共只有一堆石子，没有仍和代价的耗费，而f数组定义在全局位置，所以自动初始化为0，所以不用管len=1的情况，len直接从2开始到小于等于n
之后二重循环，对起点进行循环，因为给定一个长度之后，不同的起点对应不同的石子，所以起点 i 从1到 i + len -1 <= n（即由起点确定的右端点不能超出石子的个数n），i++
之后有了长度和起点，就可以确定左右端点了，l = i ，r = i + len - 1
之后初始化f[ l ][ r ] = 1e8，要对f数组初始化为一个很大的数，因为我们最终要取min，所以初始化时尽可能大
最后for循环k从l 到 小于r
f[ l ][ r ] = min （…）

最后输出f[ 1 ][ n ]即可