【动态规划】 线性DP1——经典回顾

【动态规划】

系列文章

线性DP
1.【动态规划】 线性DP1——经典回顾
2.【动态规划】 线性DP2——进阶1

---

新的开始

这是动态规划系列的第一篇文章，也是在CSDN开始的第一篇文章。选择动态规划作为开篇，一方面是因为动态规划在算法领域占有十分重要的一席，且其灵活性和技巧性常常令初学者不知所措； 另一方面是因为笔者在做算法题的过程中，发现对其的理解不是十分深刻，处于自己想抓耳挠腮，看题解醍醐灌顶的尴尬境地。基于此，为了巩固经典的DP问题，拓展更高阶的DP技巧，计划阅读李煜东《算法竞赛进阶指南》动态规划章节，作好记录。

经典DP回顾

本节将介绍常见的经典DP题，这些题考察的内容经常作为其他题的子部分。因此，熟练掌握并了解这些题的内部逻辑是十分必要的。

最长递增子序列 （LIS）

题目链接

题目分析

要求得到数组的最长递增子序列的长度。令$dp[i]$记录以第$i$位结尾的最长递增子序列, 初始状态 为：$$dp[i]=1(0<=i<n)$$ 即以第$i$位结尾的的最长递增子序列长度至少为1（该位数字本身）。又由于当前状态可通过遍历所有之前比该位数字小的状态得到，故状态转移方程可表示为：$$dp[i]=\underset{0\le j<i}{\max }(dp[i],dp[j]+1)$$

DP代码 $O(n^2)$

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

int main(){
    
    int n;
    cin >> n;
    vector<int> v(n, 0);
    vector<int> dp(n, 1);
    for(int i = 0; i < n; ++i){
        cin >> v[i];
    }
    int ans = 0;
    for(int i = 0; i < n; ++i){
        for(int j = i-1; j >= 0; --j){
            if(v[i] > v[j]) dp[i] = max(dp[i], dp[j] + 1);
        }
        ans = max(ans, dp[i]);
    }
    cout << ans << endl;
    return 0;
}

补充算法 $O(nlogn)$

本题还有复杂度为$O(nlogn)$的解法，定义递增序列dp， dp[i]为所有递增子序列中最小的第$i$位的值；每次通过二分的方法更新数组dp, 其最终的长度即为所求结果；

#include<iostream>
#include<vector>

using namespace std;

void update(vector<int>& dp, int a){
    auto it = lower_bound(dp.begin(), dp.end(), a);
    if(it == dp.end()) dp.push_back(a);
    else *it = a;
}
int main(){
    int n;
    cin >> n;
    vector<int> dp;
    
    for(int i = 0; i < n; ++i){
        int a; cin >> a;
        update(dp, a);
    }
    cout << dp.size() << endl;
    
    return 0;
}

最长公共子序列 （LCS）

题目链接

题目分析

要求得到两个字符串的最长公共子序列的长度。设两个字符串分别为$A、B$，长度分别为$n、m$。 令$dp[i][j]$记录$A$字符串的前$i$位与$B$字符串的前$j$位的最长公共子序列的长度。
Trick: 为简化边界条件，默认在两个字符串前面加上与其他字符不同的两个字符。例如，如果原$A、B$数组中不包含 *、# 两个字符，可在$A$字符串前加*, 在$B$字符串前加#。 值得注意的是，实际操作中并不需要真的加上这两个字符，只需要知道其存在来写转移方程即可。
初始状态： $$dp[0][0]=0$$ 即$A、B$的首个字符不相等。
状态转移方程：
$$dp[i][j]=\{\begin{array}{c}dp[i-1][j-1]+1,A[i-1]==B[j-1]\\ max(dp[i-1][j],dp[i][j-1])\end{array}1\le i\le n,1\le j\le m$$
上述状态转移方程分为两种情况：

• 当A[i-1] == B[j-1]时，当前的dp[i][j]可直接由dp[i-1][j-1]得到；
• 当A[i-1] != B[j-1]时，当前的dp[i][j]为两个子问题的较大值；而这两个子问题在计算dp[i][j]之前已经得到，故能实现状态的转移。

代码

#include<iostream>
#include<string>
#include<vector>

using namespace std;

int main(){
    
    int n, m, ans;
    string a, b;
    ans = 0;
    cin >> n >> m;
    cin >> a >> b;
    
    vector<vector<int>> dp(n+1, vector<int>(m+1, 0));
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < m; ++j){
            if(a[i] == b[j]) dp[i+1][j+1] = dp[i][j] + 1;
            else{
                dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
            }
            ans = max(ans, dp[i+1][j+1]);
        }
    }
    cout << ans << endl;
    return 0;
}

数字三角形

题目链接

题目分析

要求找出一条路径，使路径上的数字的和最大。考虑将二维压缩成一维。

• 自上而下分析时，一维dp更新需要从后往前更新，避免覆盖的值造成影响；
• 自下而上分析时，需用二维数组保存整个数字三角形，内存消耗较大；(写起来容易，在比赛、面试中推荐)

易错点： 1) ans设置时注意负数； 2）后往前遍历时边界放在循环外计算；

自上而下代码

// 自上而下，空间复杂度较低，需考虑边界条件，且需从后往前遍历
#include<iostream>
#include<vector>
using namespace std;

int main(){
    int n;
    cin >> n;
    vector<int> dp(n, 0);
    vector<int> line(n, 0);
    
    for(int i = 1; i <= n; ++i){
        for(int j = 0; j < i; ++j){
            cin >> line[j];
        }
        if(i > 1) dp[i-1] = line[i-1] + dp[i-2];
        
        for(int j = i-2; j > 0; --j){
            dp[j] = max(dp[j], dp[j-1]) + line[j];
        }
        
        dp[0] += line[0];
    }
    int ans = 0x80000000;
    for(int i = 0; i < dp.size(); ++i){
        ans = max(dp[i], ans);
    }
    cout << ans << endl;
    return 0;
}

自下而上代码

#include<iostream>
#include<vector>
// 自下而上，空间消耗大，写法简单
using namespace std;

int main(){
    int n;
    cin >> n;
    vector<vector<int>> v(n, vector<int>(n, 0));
    for(int i = 0; i < n; ++i){
        for(int j = 0; j <= i; ++j){
            cin >> v[i][j];
        }
    }
    for(int i = n-2; i >= 0; --i){
        for(int j = 0; j <= i; ++j){
            v[i][j] += max(v[i+1][j], v[i+1][j+1]);
        }
    }
    cout << v[0][0] << endl;
    return 0;
}