算法——动态规划

动态规划算法

动态规划是运筹学的一个分支，其是用来解决决策过程最优化的数学方法。

1）思想（注意与常规的回溯法区分开）：动态规划通过找到衡量题目量的状态、状态转移的变化和最优子结构，从而写出状态转移方程。其中，核心是状态和状态转移方程

动态规划有几个典型特征，最优子结构、状态转移方程、边界、重叠子问题。在青蛙跳阶问题中：

• f(n-1)和f(n-2) 称为 f(n) 的最优子结构
• f(n)= f（n-1）+f（n-2）就称为状态转移方程
• f(1) = 1, f(2) = 2 就是边界
• 比如f(10)= f(9)+f(8),f(9) = f(8) + f(7) ,f(8)就是重叠子问题。

2）计算方法：

• 递归计算（通过函数进行递归运算）
• 递推运算（非递归的方法）

时间复杂度：状态总数每个状态的决策个数决策时间

• 记忆化搜索（剪枝的方式，递归方法优化）

3）动态规划一般采用自底向下的方法进行书写，模板如下：

dp[0][0][...] = 边界值
for(状态1 ：所有状态1的值){
    for(状态2 ：所有状态2的值){
        for(...){
          //状态转移方程
          dp[状态1][状态2][...] = 求最值
        }
    }
}

leetcode：最大子序和

题目描述：也就是在一列数中找到最大的连续和

1）动态规划（线性结构）

class Solution{
public:
	int maxSubArray(vector<int>& nums){
		for(int i = 0; i < nums.size()-1; i++){
			if(nums[i]>=0) nums[i+1]+= nums[i];
		}
		return *max_element(nums.begin(), nums.end());
	}
}

2）贪心法

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        //在写代码之前，一定要有清晰的思路，不要随意下手，否则容易陷入迷茫的困境
        int ts = 0, ms = -10000;
        for(const auto&x: nums){
        	ts += x;
        	ms = max(ms, ts);
        	if(ts < 0) ts = 0;//如果前面的序列和是负的，直接舍弃就行
        }
    }
};

leetcode10正则表达式

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素

所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

• 分析过程：

由于需要进行匹配，那必定是需要遍历字符串。考虑到正向遍历过程时，会出现需要判断字符和字符加心号两种情况，可能会有冲突，会引发不便。所以可以考虑使用逆向遍历。

同时，可以将问题分成前i个字符已经匹配，加上现在这个字符是否匹配的问题。也就是分成子问题加状态。所以可以设计一个动态规划算法解决该问题。

func isMatch(s string, p string) bool {
    m, n := len(s), len(p)
    matches := func(i, j int) bool {
        if i == 0 {
            return false
        }
        if p[j-1] == '.' {
            return true
        }
        return s[i-1] == p[j-1]
    }

    f := make([][]bool, m + 1)
    for i := 0; i < len(f); i++ {
        f[i] = make([]bool, n + 1)
    }
    f[0][0] = true
    for i := 0; i <= m; i++ {
        for j := 1; j <= n; j++ {//下面的三个不是很理解
            if p[j-1] == '*' {
                f[i][j] = f[i][j] || f[i][j-2]
                if matches(i, j - 1) {
                    f[i][j] = f[i][j] || f[i-1][j]
                }
            } else if matches(i, j) {
                f[i][j] = f[i][j] || f[i-1][j-1]
            }
        }
    }
    return f[m][n]
}

问题一

为什么在程序的递推部分中的表达式和动态规划方程所表现的不太一样呢？

https://leetcode-cn.com/problems/regular-expression-matching/

动态规划中的递推部分，有时候会有一些看似没有用处的计算。但是必须要知道的一点是，这些计算都是为了处理那些特殊情况所不可缺少的。

所以下次做dp问题时，记得把问题考虑得更复杂一点。（所有情况都考虑一遍，然后再动手写题目、想算法）

洛谷P1216数字三角形（dp模板）

模板题：核心是状态和状态转移方程

//递推求解f函数的值（dp）
    for(int i = n-1; i > 0; i--)
        for(int j = 1; j <= i; j++)
            f[i][j] = d[i][j] + max(f[i+1][j], f[i+1][j+1]);

洛谷P1095守望者的逃离（进阶dp）

可以将守望者的能量m和时间t作为变量，将守望者所经过的距离作为状态。

也就是 f [m] [t] 。

状态转移方程为

f[m][t] = max(17+f[m][t-1], f[m+4][t-1], 60+f[m-10][t-1]); // m >= 10

80分代码

#include<iostream>
#include<algorithm>
using namespace std;
const int Maxm = 10005;
int f[Maxm][Maxm];
int M, S, T;
int ans[3], an, anT, flag;
int main() {
    cin >> M >> S >> T;
    for(int i = 0; i <= 9; i++) f[i][1] = 17;
    for(int i = 10; i < Maxm; i++) f[i][1] = 60;
    if(f[M][1] >= S) {
        cout << "Yes" << endl;
        cout << 1 << endl;
        return 0;
    }
    for(int t = 2; t <= T; t++) {
        for(int m = 0; m <= M; m++) {
            ans[0] = 17 + f[m][t-1];
            ans[1] = f[m+4][t-1];
            if(m >= 10) ans[2] = 60 + f[m-10][t-1];
            else ans[2] = 0;
            f[m][t] = *max_element(ans, ans+3);
            an = max(an, f[m][t]);
            if(flag) break;
            if(an >= S) { anT = t; flag = 1; break;}
        }
        if(flag) break;
    }
    if(an >= S) {
        cout << "Yes" << endl;
        cout << anT << endl;
    } else {
        cout << "No" << endl;
        cout << an << endl;
    }
    return 0;
}

leetcode1220统计字符串数量

这道题目之所以可以使用动态规划，就是因为其状态之间存在转移关系。但是题目给出的是，一个元音字母后面可以跟什么字母，也就是说从状态1可以抵达到哪一步。

但是我们dp所需要的是，从哪些状态才能到状态1，这也是题解中将题目含义进行转换的根本原因，就是为了方便后面书写dp状态转换方程。

func countVowelPermutation(n int) (ans int) {
	const mod int = 1e9 + 7
	dp := [5]int{
		1, 1, 1, 1, 1,
	}
	for i := 1; i < n; i++ {
		dp = [5]int{
			(dp[1] + dp[2] + dp[4]) % mod,
			(dp[0] + dp[2]) % mod,
			(dp[1] + dp[3]) % mod,
			(dp[2]) % mod,
			(dp[2] + dp[3]) % mod,
		}
	}
	for _, v := range dp {
		ans = (ans + v) % mod
	}
	return
}

洛谷P1131时态同步——递归类型的树型dp问题

采用链式前向星的存树方式。先递归到叶子节点，然后再自底向上维护状态，并保存结果。

题目意思是从激发点开始激发，最终到所有的叶子节点的时间为同一时间。为了方便递归后自底向上维护，我们可以反向理解，也就是说，我们可以考虑为所有的叶子节点同时开始传递信号，最后同时到达激发点。

AC代码

#include<iostream>
using namespace std;
const int MaxN = 10000005;
int maxm, n, s;
int a, b, t;
long long ans;
struct Edge {
    int to, w, next;
} E[MaxN];
int tot = 1, head[MaxN];
void AddEdge(int u, int v, int w) {
    E[tot].to = v;
    E[tot].w = w;
    E[tot].next = head[u];
    head[u] = tot++;
}
void dfs(int x, int fa) {
    //先搜索到叶子节点
    maxm = 0;
    for(int i = head[x]; i; i = E[i].next) {
        if(E[i].to != fa) dfs(E[i].to, x);
    }
    //抵达叶子节点之后开始维护maxm
    for(int i = head[x]; i; i = E[i].next) {
        if(E[i].to != fa) maxm = max(E[i].w, maxm);
    }
    //然后维护答案ans
    for(int i = head[x]; i; i = E[i].next) {
        if(E[i].to != fa) ans += (maxm - E[i].w);
    }
    //最后保存maxm值到与父节点所连接的那条边上
    for(int i = head[fa]; i; i = E[i].next) {
        if(E[i].to == x) E[i].w += maxm;
    }
}

int main() {
    cin >> n >> s;
    for(int i = 1; i <= n-1; i++) {
        cin >> a >> b >> t;
        AddEdge(a, b, t);
        AddEdge(b, a, t);
    }
    dfs(s, 0);
    cout << ans;
    return 0;
}

背包问题分类

01背包问题

洛谷P1048、P1060

这两道题目属于最常规的01背包问题，解题思路没有什么区别。

注意一个小技巧，可以通过逆向遍历的方式进行空间优化，这样可以将原本二维的dp数组优化为一维。

状态转移方程：

dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]) // j >= w[i]

AC代码

#include<iostream>
#include<algorithm>
using namespace std;
int m, T;
int dp[1005], v[105], t[105];
int main() {
    cin >> T >> m;
    for(int i = 1; i <= m; i++) cin >> t[i] >> v[i];
    for(int i = 1; i <= m; i++) 
    //此处通过逆向遍历，防止遍历的过程中错误覆盖了上一维的dp值
    for(int j = T; j >= t[i]; j--)
    dp[j] = max(dp[j], dp[j-t[i]]+v[i]);
    cout << dp[T];
    return 0;
}

完全背包问题

完全背包问题与01背包问题的区别在于，完全背包问题中，每种物品的数量没有限制，可以无限取。所以在进行决策第i种物品的最优值时，可以决定不取或者取多个。与01背包不同，01背包只能决定取或者不取。所以完全背包问题在遍历时，采用正向遍历的方式。

状态转移方程：（注意与01背包进行比较）

dp[i][j] = max(dp[i-1][j], dp[i][j-w[i]]+v[i]) // j >= w[i]

洛谷P1616疯狂的采药

AC代码

#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll m, T;
ll dp[10000005], v[10005], t[10005];
int main() {
    cin >> T >> m;
    for(int i = 1; i <= m; i++) cin >> t[i] >> v[i];
    for(int i = 1; i <= m; i++) 
    //这里采用正向遍历的方式
    for(int j = t[i]; j <= T; j++)
    dp[j] = max(dp[j], dp[j-t[i]]+v[i]);
    cout << dp[T];
    return 0;
}

分组背包问题

洛谷P1757通天之分组背包

基本思路：由于至多只能从同一组的物品中拿出一个物品，如果以组每单位的话，就可以看成是一个以组为单位的01背包问题。我们只需要以组为单位进行01背包的dp模板即可。

与一般的01背包所不同的是，在决策每一组选与不选的情况下，我们需要对每一种限重 j ，都要找到在前 i 组中的最大值，即dp[j]。

状态转移方程为：

dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[k]]+v[k]) // for every k in i-th group

AC代码

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxm = 1005;
int m, n, kind, gn;
int w[maxm], v[maxm], dp[maxm];
vector<int> g[maxm]; // g[i]为一个vector，保存属于第i组元素的下标
bool cmp(int i, int j) {
    return w[i] < w[j];
}
int main() {
    cin >> m >> n;
    for(int i = 1; i <= n; i++) {
        cin >> w[i] >> v[i] >> kind;
        g[kind].push_back(i);
        // gn 表示最大的组数
        gn = max(gn, kind);
    }
    //将每一组中元素按照重量从小到大进行排序，方便后序dp时对限重j做出条件判断
    for(int i = 1; i <= gn; i++) sort(g[i].begin(), g[i].end(), cmp);
    for(int i = 1; i <= gn; i++) {
        //对于每一个限重j，我们都找到在前i组中不选或者选一个的最大值，即dp[j]
        for(int j = m; j >= w[g[i][0]]; j--){
            int co = g[i].size();
            for(int k = 1; k <= co; k++){ // 遍历第 i 组中每一个元素，进行dp取舍
                int x = g[i][k-1];
                if(j >= w[x]) 
                    dp[j] = max(dp[j], dp[j-w[x]]+v[x]);
            }
        }
    }
    cout << dp[m];
    return 0;
}

多维背包问题

洛谷P1541乌龟棋——四维dp问题

1.dp[a][b][c][d]: 表示你出了a张爬行牌1，b张爬行牌2，c张爬行牌3，d张爬行牌4时的得分

2.card[x]: 表示牌x一共有多少张

因为在前面取的牌所得到的分数大小会影响后面取牌的决策，那我们就不妨DP一下每一种牌的出牌张数，然后从前往后递推。

其实从题目的条件就可以看出来这道题目是一道递推的动态规划题目。题目中乌龟是从起点走到终点，每次只会前进不会后退，正是这句话告诉我们，这道题目是从前递推到后面的。

AC代码

#include<iostream>
#include<algorithm>
using namespace std;
//四维dp问题
int n, m, x;
int chessboard[355], card[5];
int dp[45][45][45][45]; // 表示用了四种额度的卡片，所获得的分数
int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i++) cin >> chessboard[i];
    for(int i = 1; i <= m; i++) { // 存储额度为i的卡片的数量
        cin >> x;
        card[x]++;
    }
    dp[0][0][0][0] = chessboard[1];
    for(int a = 0; a <= card[1]; a++) {
        for(int b = 0; b <= card[2]; b++) {
            for(int c = 0; c <= card[3]; c++) {
                for(int d = 0; d <= card[4]; d++) {
                    int pos = 1+a*1+b*2+c*3+d*4; // 表示位置
                    if(a) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a-1][b][c][d]+chessboard[pos]);
                    if(b) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b-1][c][d]+chessboard[pos]);
                    if(c) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b][c-1][d]+chessboard[pos]);
                    if(d) dp[a][b][c][d] = max(dp[a][b][c][d], dp[a][b][c][d-1]+chessboard[pos]);
                }
            }
        }
    }
    cout << dp[card[1]][card[2]][card[3]][card[4]];
    return 0;
}