五.动态规划 （自用）

已于 2023-02-04 08:18:30 修改
阅读量58 收藏
点赞数
文章标签： 动态规划 算法 Powered by 金山文档
于 2023-01-30 22:32:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CaoZiQiangY/article/details/128794636
版权

    • 背包问题

（1）01背包问题 

f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i];
f[j] = max(f[j], f[j - v[i]] + w[i]);

二维写法 

for (int i = 1; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
        {
            f[i][j] = f[i - 1][j];
            if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }

一维优化

for (int i = 1; i <= n; i ++ )
        for (int j = m; j >= v[i]; j -- )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

可参考这个同学的讲解 https://www.acwing.com/solution/content/116859/

（2）完全背包问题

朴素做法 （会超时）

for (int i = 1; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
            for (int k = 0; k * v[i] <= j; k ++ )
                f[i][j] = max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);

二维优化 

for (int i = 1; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
        {
            f[i][j] = f[i - 1][j];
            if (j >= v[i]) f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
        }

一维优化 

for (int i = 1; i <= n; i ++ )
        for (int j = v[i]; j <= m; j ++ )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

（3）多重背包问题

暴力朴素做法 

for (int i = 1; i <= n; i ++ )
    for (int j = 0; j <= m; j ++ )
        for (int k = 0; k <= s[i] && k * v[i] <= j; k ++ )
            f[i][j] = max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);

（错解）用完全背包的思路优化

（正解）2^0 + 2^1 + ... + 2^(n - 1) = 2^n

凑出来 0 ~ s 的拼法 

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 12010, M = 2010;

int n, m;
int v[N], w[N];
int f[M];

int main()
{
    cin >> n >> m;

    int cnt = 0;
    for (int i = 1; i <= n; i ++ )
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s)
        {
            cnt ++ ;
            v[cnt] = a * k;
            w[cnt] = b * k;
            s -= k;
            k *= 2;
        }
        if (s > 0)
        {
            cnt ++ ;
            v[cnt] = a * s;
            w[cnt] = b * s;
        }
    }

    n = cnt;

    for (int i = 1; i <= n; i ++ )
        for (int j = m; j >= v[i]; j -- )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

    cout << f[m] << endl;

    return 0;
}

（4）分组背包问题 

for (int i = 1; i <= n; i ++ )
{
    cin >> s[i];
    for (int j = 0; j < s[i]; j ++ )
        cin >> v[i][j] >> w[i][j];
}

for (int i = 1; i <= n; i ++ )
    for (int j = 0; j <= m; j ++ )
        for (int k = 0; k < s[i]; k ++ )
            if (v[i][k] <= j)
                f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);

    • 线性DP

（1）数字三角形 

    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];
    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 = 1; i <= n; i ++ ) res = max(res, f[n][i]);

（2）最长上升子序列问题

朴素解法 O(n^2) 

    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1; // 只有a[i]一个数
        for (int j = 1; j < i; j ++ )
            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]);

如何保存最长子序列 

for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1; // 只有a[i]一个数
        g[i] = 0; // 
        for (int j = 1; j < i; j ++ )
            if (a[j] < a[i])
                if (f[i] < f[j] + 1)
                {
                    f[i] = f[j] + 1;
                    g[i] = j;
                }
    }

    int k = 1;
    for (int i = 1; i <= n; i ++ )
        if (f[k] < f[i])
            k = i;
    
    for (int i = 0, len = f[k]; i < len; i ++ )
    {
        cout << a[k] << ' ';
        k = g[k];
    }

优化解法（II）

长度相同的只存结尾数字小的

（1）q[] （2）长度是下标 （3）结尾数字大小是 q[] 的值

二分出来小于某个数的最大的数 

    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;
        }// r 是 q[r] 比 a[i] 小的下标 
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }
    cout << len << endl;

（3）最长上升公共子序列

f[i - 1][j] 包含 00 01

f[i][j - 1] 包含 00 10 

    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);
        }

（4）最短编辑距离 

    // 初始化，如果 a[] 的长度为 0，或者 b[] 的长度为 0 
    for (int i = 0; i <= m; i ++ ) f[0][i] = i;
    for (int i = 0; i <= n; i ++ ) f[i][0] = i;

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if (a[i] == b[j]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }

编辑距离 

#include <iostream>
#include <algorithm>
#include <string.h>

using namespace std;

const int N = 15, M = 1010;

int n, m;
int f[N][N];
char str[M][N];

int edit_distance(char a[], char b[])
{
    int la = strlen(a + 1), lb = strlen(b + 1);

    for (int i = 0; i <= lb; i ++ ) f[0][i] = i;
    for (int i = 0; i <= la; i ++ ) f[i][0] = i;

    for (int i = 1; i <= la; i ++ )
        for (int j = 1; j <= lb; j ++ )
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            f[i][j] = min(f[i][j], f[i - 1][j - 1] + (a[i] != b[j]));
        }

    return f[la][lb];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i ++ ) scanf("%s", str[i] + 1);

    while (m -- )
    {
        char s[N];
        int limit;
        scanf("%s%d", s + 1, &limit);

        int res = 0;
        for (int i = 0; i < n; i ++ )
            if (edit_distance(str[i], s) <= limit)
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

3.区间DP

（1）石子合并

每次合并两堆

前缀和求 i ~ j 的全部重量 

    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] = 1e8;
            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]);
        }

    printf("%d\n", f[1][n]);
每次合并 n 堆 （较复杂，等以后找题写）

4.计数类DP

（1）整数划分

用完全背包问题的思路求解 

f[i][j] = f[i - 1][j] + f[i][j - i];
f[j]    =               f[j - i];
    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;

其他解法

f [ i - 1 ][ j - 1 ] 表示把 1 去掉

f [ i - j ][ j ] 表示把每个数减去 1 

    f[1][1] = 1; // f[0][0] = 1;
    for (int i = 2; i <= n; i ++ ) // for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;

    int res = 0;
    for (int i = 1; i <= n; i ++ ) res = (res + f[n][i]) % mod;

5.数位统计DP

（1）计数问题

求 a ~ b 中 0 ~ 9 出现的次数

求前缀

边界问题：

（1）1 出现在第一位

（2）当取 0 时，前三位 从 001 ~ abc - 1 

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 10;

/*

001~abc-1, 999

abc
    1. num[i] < x, 0
    2. num[i] == x, 0~efg
    3. num[i] > x, 0~999

*/

int get(vector<int> num, int l, int r) // 求 xxx 
{
    int res = 0;
    for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
    return res;
}

int power10(int x) // 求 yyy 的位数 
{
    int res = 1;
    while (x -- ) res *= 10;
    return res;
}

int count(int n, int x)
{
    if (!n) return 0;

    vector<int> num; // 将 n 的每一位存在 num 中 
    while (n)
    {
        num.push_back(n % 10); // 低位 --> 高位 
        n /= 10;
    }
    n = num.size(); // n = n 的位数 

    int res = 0; // 出现的次数 
                      // 如果 x == 0 ，那么 0 在最高位不存在，所以从 最高位 - 1 开始计算 
    for (int i = n - 1 - !x; i >= 0; i -- ) // x 在第 i 位出现的次数 
    {
        if (i < n - 1)
        {
            res += get(num, n - 1, i + 1) * power10(i); 求 xxx 中出现的次数 
            if (!x) res -= power10(i); // 如果 x 等于 0 
        }

        if (num[i] == x) res += get(num, i - 1, 0) + 1;
        else if (num[i] > x) res += power10(i);
        //else res += 0;
    }

    return res;
}

int main()
{
    int a, b;
    while (cin >> a >> b , a)
    {
        if (a > b) swap(a, b); // 小数在前，大数在后 

        for (int i = 0; i <= 9; i ++ ) // 统计 0 ~ 9 出现的次数 
            cout << count(b, i) - count(a - 1, i) << ' '; // 用前缀和的思路求解 
        cout << endl;
    }

    return 0;
}

6.状态压缩DP（用一个整数表示一个状态，二进制数表示）

（1）蒙德里安的梦想

切割数 = 横向摆放小方格的方法数

朴素写法（1000ms）

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 12, M = 1 << N; // M = 2^N 

int n, m;
long long f[N][M]; // 存储状态 
bool st[M]; // 判断每列是否合法 

int main()
{
    while (cin >> n >> m, n || m)
    {
        for (int i = 0; i < 1 << n; i ++ ) // 预处理 st[] ，判断每列相邻 0 的个数是不是偶数 
        {             // i < 2^n
            int cnt = 0;
            st[i] = true;
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1) // 等价于 i 除以 2^j ，然后与 1 做与运算 
                { // 如果最后一位是 1 
                    if (cnt & 1) st[i] = false;// 判断 cnt 是不是偶数 
                    cnt = 0;
                }
                else cnt ++ ;
            if (cnt & 1) st[i] = false;
        }

        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for (int i = 1; i <= m; i ++ )
            for (int j = 0; j < 1 << n; j ++ )
                for (int k = 0; k < 1 << n; k ++ )
                    if ((j & k) == 0 && st[j | k]) // j 和 k 在相邻列是合法的 
                        f[i][j] += f[i - 1][k];

        cout << f[m][0] << endl;
    }
    return 0;
}

视频中提前将 j 和 k 相邻列合法的情况提取出来

（2）最短Hamilton路径 

#include <cstring> // memset(f, 0x3f, sizeof f)
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 20, M = 1 << N;

int n;
int w[N][N];
int f[M][N];

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            cin >> w[i][j]; // 权重 

    memset(f, 0x3f, sizeof f); // 初始化，将距离初始化为正无穷 
    f[1][0] = 0;

    for (int i = 0; i < 1 << n; i ++ ) // i 和 j 枚举每种状态 
        for (int j = 0; j < n; j ++ )
            if (i >> j & 1) // 如果从 0 走到 j ，那么 i 里一定要包含 j 
                for (int k = 0; k < n; k ++ ) // 枚举所有转移的状态，从哪个点转移过来 
                    if (i >> k & 1) // if ((i - (1 << j)) >> k & 1) 
                  // 第 k 位一定要是 1 // 如果想从 k 转移过来，那么 i 除去 j 这个点之后，一定要包含 k 
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);

    cout << f[(1 << n) - 1][n - 1] << endl;

    return 0;
}

7.树形DP

（1）没有上司的舞会（深搜）

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 6010;

int n;
int h[N], e[N], ne[N], idx;
int happy[N];
int f[N][2];
bool has_fa[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    f[u][1] = happy[u];
                  // i != -1
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        dfs(j);

        f[u][1] += f[j][0];
        f[u][0] += max(f[j][0], f[j][1]);
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &happy[i]);

    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b); // b 是上司 
        add(b, a); // b --> a 
        has_fa[a] = true; // a 有上司 
    }

    int root = 1;
    while (has_fa[root]) root ++ ; // 找根节点 

    dfs(root);

    printf("%d\n", max(f[root][0], f[root][1]));

    return 0;
}

8.记忆化搜索（递归）

（1）滑雪 

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 310;

int n, m;
int g[N][N]; // 高度 
int f[N][N];

int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1}; // 偏移量，四个方向 

int dp(int x, int y)
{
    int &v = f[x][y]; // 简化代码，用 v 来表示这个状态，C++ 特性，等价于 f[x][y] 
    if (v != -1) return v; // v 算过了，就返回 

    v = 1; // 初始化，最小值是 1 
    for (int i = 0; i < 4; i ++ ) // 枚举四个方向 
    {
        int a = x + dx[i], b = y + dy[i];
         // 在棋盘范围内                            // 高度要下降 
        if (a >= 1 && a <= n && b >= 1 && b <= m && g[x][y] > g[a][b])
            v = max(v, dp(a, b) + 1);
    }

    return v;
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &g[i][j]);

    memset(f, -1, sizeof f);

    int res = 0;
    for (int i = 1; i <= n; i ++ ) // 枚举从每个点出发 
        for (int j = 1; j <= m; j ++ )
            res = max(res, dp(i, j));

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

    return 0;
}

记忆化搜索的优点

代码复杂度 低

思路简单

曹自强888
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划学习记录
m0_45273931的博客
04-07 116
动态规划学习记录
自用记载-机械臂轨迹规划代码-持续整理中
m0_53097387的博客
11-04 445
。。
2020-10-15
wingacd的博客
10-15 178
有 N 种物品和一个容量是 V 的背包。 第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤100 0<vi,wi,si≤100 输入样例 4 5 1
力扣-动态规划问题总结
weixin_44965579的博客
02-23 1140
动态规划-自用
背包问题（自用笔记）
qq_45412824的博客
06-03 51
【代码】背包问题（自用笔记）
[动态规划]代码随想录总结（自用）
Littleflowers的博客
04-03 670
代码随想录动态规划部分的总结
数学规划第七章 动态规划问题【复习自用】
weixin_51772802的博客
05-26 96
个人认为，动态规划的特点在于多阶段性，分步骤解决，上一阶段的问题解决后，上一阶段即为最优。按照步骤算，第i步找到所有i步能够到达的节点，算出他们的最短路径，作为该节点的价值。的方法，先求出最后一步的最优策略，并列出该步骤最优策略的函数表达式。以数量为x(万元)的资金分配给前k个工厂所得到的最大总利润值。出仅1、2、3、4个工厂时，怎么分配。从后往前推，从前往后推，都可以。需要的最小费用【每个阶段的每个。同阶段的节点之间，彼此无联系。种物品时的最大使用价值。个工厂的资金数(万元)同理，算出剩下的阶段。
算法自用复习
xuge520的博客
12-21 373
【代码】算法自用复习。
自用ppt整理
Nettie777的博客
05-17 245
我们可以先这样理解class和subclass，allegro为了精确定义工程中的对象（防止错误），对工程中的对象进行了细致的分组。Class是命令操作对象的群组，subclass是群组中的某个对象。
动态规划算法-手写笔记-自用
03-21
动态规划算法_手写笔记
敬业签免登陆版...自用
04-03
自用"是一款专为个人用户设计的软件，它允许用户在无需登录账号的情况下使用部分功能，提供便捷的记事服务。这个压缩包文件名为"jyqmfb_40710"，可能是该软件的一个特定版本或者更新包。 敬业签是一款流行的桌面...
jshell.war jsp 自用
10-13
javawebshell脚本适用于tomcat
【自用】Tools.cpp
03-03
【自用】Tools.cpp 是一个个人使用的C++源代码文件，通常包含了一些特定于开发者或者项目需要的工具函数或类。这些工具可能涉及到各种编程任务，如数据处理、文件操作、算法实现等。从提供的文件名来看，我们可以...
vue.js自用web前端
03-28
vue.js自用web前端
LeetCode 算法：二叉树的最近公共祖先 III c++
小金牛来了
07-05 992
LeetCode 算法：二叉树的最近公共祖先 III c++
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 597
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 662
后缀表示法。
[Leetcode 136][Easy]-只出现一次的数字
2201_75413354的博客
07-03 224
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
文化财经五指标共振自用成功率99短线指标无未来筹码动向公式源码.doc
11-19
文化财经五指标共振自用成功率99是指在文化财经领域中，使用五个指标进行共振分析，成功率达到99%。这意味着这种分析方法在实际操作中取得了极高的准确性和成功率。短线指标无未来筹码动向公式源码.doc是指在短期投资中，通过运用未来筹码动向的公式源码来分析短线指标，以期获得更高的投资收益。 这两个方法都是在文化财经领域中进行分析和预测的工具。对于普通投资者来说，利用这些工具可以更好地把握市场趋势，做出更理性的投资决策，从而提高投资成功的概率。 通过文化财经五指标共振自用成功率99的分析方法，投资者可以更准确地了解市场动向和趋势，找到更好的投资机会，最大限度地降低投资风险。而短线指标无未来筹码动向公式源码.doc则可以帮助投资者分析短期内的市场波动，更精准地进行短线投资，获得更高的收益。 总之，这些分析方法对于投资者来说都是有益的工具，可以帮助他们更好地理解和把握市场走势，做出更具策略性的投资决策。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值