暴力递归与动态规划

最新推荐文章于 2024-09-28 22:05:59 发布
最新推荐文章于 2024-09-28 22:05:59 发布
阅读量47 收藏
点赞数
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54953282/article/details/133344058
版权

【机器人运动问题】

参数n：表示有n个位置  1 ~ n

参数s：机器人初始位置

参数e：机器人目标位置

参数k：机器人必须走k步

机器人每次可往左或往右走，但每次只能走一步

递归调用：

// 一共1~N个位置，目标位置是E，当前位置是cur，还要走rest步
int f(int N, int E, int rest, int cur){
    if(rest == 0){
        return cur == E ? 1 : 0;
    }
    if(cur == 1){
        return f(N, E, rest - 1, 2);
    }
    if(cur == N){
        return f(N, E, rest - 1, N - 1);
    }
    return f(N, E, rest - 1, cur - 1) + f(N, E, rest - 1, cur + 1);
}

记忆化搜索：

// 一共1~N个位置，目标位置是E，当前位置是cur，还要走rest步
int f(int N, int E, int rest, int cur, vector<vector<int>>& dp){
    if(dp[rest][cur] != -1){
        return dp[rest][cur];
    }
    if(rest == 0){
        dp[rest][cur] = cur == E ? 1 : 0;
        return dp[rest][cur];
    }
    if(cur == 1){
        dp[rest][cur] = f(N, E, rest - 1, 2, dp);
    }
    else if(cur == N){
        dp[rest][cur] = f(N, E, rest - 1, N - 1, dp);
    }
    else{
        dp[rest][cur] = f(N, E, rest - 1, cur - 1, dp) + f(N, E, rest - 1, cur + 1, dp);
    }
    return dp[rest][cur];
}

int walkWays(int N, int E, int rest, int cur){
    vector<vector<int>> dp(rest + 1, vector<int> (N + 1, -1));
    return f(N, E, rest, cur, dp);
}

动态规划：

int dpWay(int N, int E, int rest, int cur){
    vector<vector<int>> dp(rest + 1, vector<int>(N + 1, 0));
    dp[0][E] = 1;
    for(int i = 1; i <= rest; i++){
        for(int j = 1; j <= N; j++){
            if(j == 1){
                dp[i][j] = dp[i - 1][j + 1];
            }
            else if(j == N){
                dp[i][j] = dp[i - 1][j - 1];
            }
            else{
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
            }
        }
    }
    return dp[rest][cur];
}

【题目】

一个正整数数组，每个元素表示一枚硬币的面值，找到总面值为aim的最少个数的硬币。

如 arr = [2, 7, 3, 5, 3]   aim = 10   最少个数硬币：2（7 + 3 = 10）

int process(vector<int>& arr, int index, int rest){
    if(rest < 0){
        return -1;
    }
    if(rest == 0){
        return 0;
    }
    if(index == arr.size()){
        return -1;
    }
    int p1 = process(arr, index + 1, rest);
    int p2 = process(arr, index + 1, rest - arr[index]);
    if(p1 == -1 && p2 == -1){
        return -1;
    }
    else if(p1 == -1){
        return p2 + 1;
    }
    else if(p2 == -1){
        return p1;
    }
    else{
        return min<int>(p1, p2 + 1);
    }
}

int minCoins(vector<int>& arr, int aim){
    return process(arr, 0, aim);
}

记忆化搜索：

int process(vector<int>& arr, int index, int rest, vector<vector<int>>& dp){
    if(rest < 0){
        return -1;
    }
    if(dp[index][rest] != -2){
        return dp[index][rest];
    }
    if(rest == 0){
        dp[index][rest] = 0;
        return dp[index][rest];
    }
    if(index == arr.size()){
        dp[index][rest] = -1;
        return dp[index][rest];
    }
    int p1 = process(arr, index + 1, rest, dp);
    int p2 = process(arr, index + 1, rest - arr[index], dp);
    if(p1 == -1 && p2 == -1){
        dp[index][rest] = -1;
    }
    else if(p1 == -1){
        dp[index][rest] = p2 + 1;
    }
    else if(p2 == -1){
        dp[index][rest] = p1;
    }
    else{
        dp[index][rest] = min<int>(p1, p2 + 1);
    }
    return dp[index][rest];
}

int minCoins(vector<int>& arr, int aim){
    vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1, -2));
    return process(arr, 0, aim, dp);
}

动态规划：

int minCoins(vector<int>& arr, int aim){
    int n = arr.size();
    vector<vector<int>> dp(n + 1, vector<int>(aim + 1, 0));
    for(int row = 0; row <= n; row++){
        dp[row][0] = 0;
    }
    for(int col = 1; col <= aim; col ++){
        dp[n][col] = -1;
    }
    for(int index = n - 1; index >= 0; index--){
        for(int rest = 1; rest <= aim; rest++){
            int p1 = dp[index + 1][rest];
            int p2 = -1;
            if(rest - arr[index] >= 0){
                p2 = dp[index + 1][rest - arr[index]];
            }
            if(p1 == -1 && p2 == -1){
                dp[index][rest] = -1;
            }
            else if(p1 == -1){
                dp[index][rest] = p2 + 1;
            }
            else if(p2 == -1){
                dp[index][rest] = p1;
            }
            else{
                dp[index][rest] = min<int>(p1, p2 + 1);
            }
        }
    }
    return dp[0][aim];
}

递归 -> 记忆化搜索 -> 严格表依赖

1.分析可变参数变化范围

2.标出要计算的终止位置

3.标出直接出答案的位置（根据basecase）

4.推普遍位置是如何依赖其他位置的

5.定出严格表依次计算的顺序

【题目】

给定一个整形数组arr，代表数值不同的纸牌排成一条线。玩家A和玩家B依次拿走每张纸牌，规定玩家A先拿，玩家B后拿，但是每个玩家每次只能拿走最左或最右的纸牌，玩家A和玩家B都绝顶聪明。返回最后获胜者的分数。

【举例】

arr = [1, 2, 100, 4]

开始时，玩家A只能拿走1或4.如果开始时玩家A拿走1，则排列变为[2, 100, 4]，接下来玩家B可以拿走2或4，然后继续轮到玩家A

如果开始时玩家A拿走4，则排列变为[1, 2, 100]，接下来玩家B可以拿走1或100，然后继续轮到玩家A

玩家A作为绝顶聪明的人不会先拿4，因为拿4之后，玩家B将拿走100.所以玩家A会先拿1，让排列变为[2, 100, 4]，接下来玩家B不管怎么选，100都会被玩家A拿走，玩家A会获胜，分数为101，所以返回101。

int max(int a, int b){
    return a > b ? a : b;
}

int s(vector<int>& arr, int l, int j);

int f(vector<int>& arr, int l, int r){
    if(l == r){
        return arr[l];
    }
    else{
        return max(arr[l] + s(arr, l + 1, r), arr[r] + s(arr, l, r - 1));
    }
}

int s(vector<int>& arr, int l, int r){
    if(l == r){
        return 0;
    }
    else{
        return min(f(arr, l + 1, r), f(arr, l, r - 1));
    }
}

int cardsInLine(vector<int> arr){
    if(arr.empty()){
        return 0;
    }
    return max(f(arr, 0, arr.size() - 1), s(arr, 0, arr.size() - 1));
}

动态规划：

int dp(vector<int>& arr){
    if(arr.empty()){
        return 0;
    }
    vector<vector<int>> f (arr.size(), vector<int>(arr.size(), 0));
    vector<vector<int>> s (arr.size(), vector<int>(arr.size(), 0));
    for(int i = 0; i < arr.size(); i++){
        f[i][i] = arr[i];
    }
    for(int col = 1; col < arr.size(); col++){
        int i = 0;
        int j = col;
        while(i < arr.size() && j < arr.size()){
            f[i][j] = max<int>(arr[i] + s[i + 1][j], arr[j] + s[i][j - 1]);
            s[i][j] = min<int>(f[i][j - 1], f[i + 1][j]);
            i++;
            j++;
        }
    }
    return max<int>(f[0][arr.size() - 1], s[0][arr.size() - 1]);
}

【题目】

象棋棋盘十行九列，假设左下角为(0, 0)，右上角为(8, 9)，初始时刻棋子“马”在(0, 0)，问：该棋子走step步到达(x, y)的方法有多少种？

int process(int x, int y, int step){
    if(x < 0 || x > 8 || y < 0 || y > 9){
        return 0;
    }
    if(step == 0){
        return (x == 0 && y == 0) ? 1 : 0;
    }
    return process(x - 1, y - 2, step - 1)
        + process(x - 2, y - 1, step - 1)
        + process(x + 2, y + 1, step - 1)
        + process(x + 1, y + 2, step - 1)
        + process(x + 1, y - 2, step - 1)
        + process(x + 2, y - 1, step - 1)
        + process(x - 1, y + 2, step - 1)
        + process(x - 2, y + 1, step - 1);
}

int getWays(int x, int y, int step){
    return process(x, y, step);
}

动态规划：

int getValue(vector<vector<vector<int>>>& dp, int x, int y, int h){
    if(x < 0 || x > 8 || y < 0 || y > 9){
        return 0;
    }
    return dp[x][y][h];
}

int dpWays(int x, int y, int step){
    if(x < 0 || x > 8 || y < 0 || y > 9 || step < 0){
        return 0;
    }
    vector<vector<vector<int>>> dp (9, vector<vector<int>> (10, vector<int>(step + 1, 0)));
    dp[0][0][0] = 1;
    for(int h = 1; h <= step; h++){
        for(int row = 0; row <= 8; row++){
            for(int col = 0; col <= 9; col++){
                dp[row][col][h] += getValue(dp, row - 1, col - 2, h - 1);
                dp[row][col][h] += getValue(dp, row - 2, col - 1, h - 1);
                dp[row][col][h] += getValue(dp, row + 1, col + 2, h - 1);
                dp[row][col][h] += getValue(dp, row + 2, col + 1, h - 1);
                dp[row][col][h] += getValue(dp, row - 1, col + 2, h - 1);
                dp[row][col][h] += getValue(dp, row - 2, col + 1, h - 1);
                dp[row][col][h] += getValue(dp, row + 1, col - 2, h - 1);
                dp[row][col][h] += getValue(dp, row + 2, col - 1, h - 1);
            }
        }
    }
    return dp[x][y][step];
}

【题目】

有N行M列的棋盘，左下角坐标为(0, 0)，右上角坐标为(M - 1, N - 1)，棋子的初始坐标为(a, b)，棋子每次随机从“上下左右”中一个方向走一步，棋子需要走k步，如果棋子某一刻走出棋盘外，棋子死掉。求棋子生存的概率。

long process(int N, int M, int row, int col, int k){
    if(row < 0 || row >= N || col < 0 || col >= M){
        return 0;
    }
    if(k == 0){
        return 1;
    }
    long live = process(N, M, row - 1, col, k - 1);
    live += process(N, M, row + 1, col, k  - 1);
    live += process(N, M, row, col - 1, k - 1);
    live += process(N, M, row, col + 1, k - 1);
    return live;
}

double live(int N, int M, int row, int col, int k){
    long all = pow(4, k);
    long live = process(N, M, row, col, k);
    return (double)(live)/all;
}

动态规划：

double dplive(int N, int M, int a, int b, int k){
    vector<vector<vector<long>>> dp (N + 2, vector<vector<long>> (M + 2, vector<long> (k + 1, 0)));
    for(int row = 1; row <= N; row++){
        for(int col = 1; col <= M; col++){
            dp[row][col][0] = 1;
        }
    }
    for(int rest = 1; rest <= k; rest++){
        for(int row = 1; row <= N; row++){
            for(int col = 1; col <= M; col++){
                dp[row][col][rest] = dp[row - 1][col][rest - 1];
                dp[row][col][rest] += dp[row + 1][col][rest - 1];
                dp[row][col][rest] += dp[row][col - 1][rest - 1];
                dp[row][col][rest] += dp[row][col + 1][rest - 1];
            }
        }
    }
    long all = pow(4, k);
    long live = dp[a + 1][b + 1][k];
    return (double)(live) / all;
}

【题目】

一个整形数组arr，元素表示一种货币的面值，货币数量不限。现在要凑出的总面值为aim，求出货币组合的方法数。

int process(vector<int>& arr, int index, int rest){
    if(index == arr.size()){
        return rest == 0 ? 1 : 0;
    }
    int ways = 0;
    for(int zhang = 0; arr[index] * zhang <= rest; zhang++){
        ways += process(arr, index + 1, rest - arr[index] * zhang);
    }
    return ways;
}

int coinWays(vector<int>& arr, int aim){
    return process(arr, 0, aim);
}

动态规划：

int dpCoins(vector<int>& arr, int aim){
    if(arr.empty()){
        return 0;
    }
    int n = arr.size();
    vector<vector<int>> dp (n + 1, vector<int>(aim + 1, 0));
    dp[n][0] = 1;
    for(int index = n - 1; index >= 0; index--){
        for(int rest = 0; rest <= aim; rest++){
            int ways = 0;
            for(int zhang = 0; arr[index] * zhang <= rest; zhang++){
                ways += dp[index + 1][rest - arr[index] * zhang];
            }
            dp[index][rest] = ways;
        }
    }
    return dp[0][aim];
}

斜率优化：

int dpCoins(vector<int>& arr, int aim){
    if(arr.empty()){
        return 0;
    }
    int n = arr.size();
    vector<vector<int>> dp (n + 1, vector<int>(aim + 1, 0));
    dp[n][0] = 1;
    for(int index = n - 1; index >= 0; index--){
        for(int rest = 0; rest <= aim; rest++){
            dp[index][rest] = dp[index + 1][rest];
            if(rest - arr[index] >= 0){
                dp[index][rest] += dp[index][rest - arr[index]];
            }
        }
    }
    return dp[0][aim];
}

总结：

1.尝试版本（从左往右试，范围尝试），70%题目

2.记忆化搜索

3.严格表结构动态规划

4.更精致版本dp

可变参数最好是零维，比如整型，不要是数组。

芜湖高学成
关注
一篇文章带你搞懂动态规划（由暴力递归到动态规划）
三分梦的博客
02-12 1353
这里进行初始化构建两个表：fmap 和 gmap 来存储状态， 进行优化， 分析取值范围， 在每次调用的时候加入两个表， 且在每次调用函数的时候返回当前状态值， 且如果没有计算过当前状态的话， 那么进行计算并更新此状态。两种情况： 先手 - > 10， 后手 - > 30 || 先手 - > 30， 后手 - > 20。这里因为最优策略， 先手肯定会聪明的选取好的方案， 把较次的留给后手（20）， 而动态规划相当于是对已经计算的状态结果进行存储， 从而在调用的时候。此题发现在构建dp表的时候， 两个变量。
暴力递归：动态规划的雏形
m0_65431718的博客
03-19 1252
从暴力递归到动态规划1
从暴力递归到动态规划
wk_bjut_edu_cn的博客
12-09 610
动态规划 什么是动态规划方法？ 1.其本质是利用申请的空间来记录每一个暴力搜索的结果，下次要用结果的时候就可以直接使用，而不需要在进行重复的递归过程。 2.动态规划规定每一种递归状态的计算顺序，依次进行计算。 1.动态规划算法是从暴力搜索算法优化过来的，如果我们不清楚暴力搜索的过程，就难以理解动态规划的实现，当我们了解了动态规划算法的基本原理的文字概述，实现条件之后，这时可能并不是太理...
从暴力递归到动态规划进阶
清崎教练
10-11 222
“从0开始做LeetCode”之从暴力递归到动态规划进阶   1.换钱的方法数
暴力递归转动态规划（十三）
weixin_43936962的博客
11-04 467
暴力递归转动态规划（十三）— 打小怪兽问题
暴力递归到动态规划
weixin_60343465的博客
09-20 125
精髓就是遵照题意，先写出暴力递归，然后可以发现有好多重复计算过程，浪费时间。这时候写一个dp缓存数组，将每一次暴力递归的结果存在dp里。这几种模型可以尝试动态规划。
1.2.1-斐波那契数列4种解法(暴力递归+动态规划)
qq_39444290的博客
05-20 606
Reference LeetCode 509. 斐波那契数列 labuladong的算法小抄 Markdown语法 Labuladong的算法小抄(纸质书籍 2021年1月第1版，2022年1月第七次印刷 第2章，第1节) 此问题解法和下一个凑零钱问题解法，我都会详细介绍解法原理，再后续动态规划算法原理和此相同，我只会解释题目解决方案窍门(即找到“状态”、“选择”和状态转移方程)，不会再详细解释其他相关知识。 动态规划一般解法 暴力穷举 -> 带备忘录的递归解法 -> dp 数组的迭代解法
从【暴力递归】到【动态规划】，刷新你的认知
saoboy666的博客
08-11 248
动态规划没思路？来看看【暴力递归 】到 【动态规划】
汉诺塔递归的空间复杂度_暴力递归与动态规划 1.0
weixin_39666550的博客
11-20 485
有些暴力递归不能被改成动态规划，因为他本身要求的解空间无法被压缩了。eg：汉诺塔问题，我们必须打印那些步骤。如果要写一个动态规划，先写成暴力递归的版本，然后模板化修改。 先写递归版本：不妨记递归函数是f（）1.base case 是啥？ 如果这个点在右下角，直接返回这个点的数值就可以了。 a[i][j]如果这个点在最后一行。 返回当前位置的数字+下一步需要的即： a[i][j] + f[i...
暴力递归转动态规划（四）
weixin_43936962的博客
09-01 549
暴力递归转动态规划——数字字符串转成字母的转化结果
暴力、递归与分治、动态规划、贪心算法、回溯经典习题
03-13
暴力、递归与分治、动态规划、贪心算法和回溯是算法设计中常见的几种思路和方法,经典习题是帮助我们更好掌握这些算法思想的重要途径。以下是对这些经典习题的详细说明: 1. 暴力解法习题 暴力解法往往是最直观、最...
递归和动态规划(Python)
weixin_44986581的博客
04-28 929
递归和动态规划在解题上有何相似之处，为什么将递归和动态规划放在一起。在这里你将找到答案，这可能是你能够找到动态规划和递归的全网最详细、最基础的文章。
动态规划之二—— 从暴力递归到动态规划_背包问题
xinran0703的专栏
07-22 654
所以做出这样的修改，当bag < 0 时，返回-1， 即一个错误值，然后每次选择“要”这个货物时，要预判一下如果“要了”这个货物是否会返回错误值，只有在返回值合法的情况的，才可以选择要这个index的货物。因为当bag == 0 时，但如果依然有货物，且货物的重量为0，但价值不为0，依然是可以放入背包的，因为根据题目要求，重量和价值仅仅是不为负，所以为零的可能性还是有的。（例图中 n == 3）1. 根据暴力递归可知，当index == 4，即index == W.size() 时， 返回值为0；
从暴力递归到动态规划，记忆化搜索
Harrison的学习博客
12-28 3070
动态规划 暴力递归之所以暴力是因为存在大量的重复计算，比如一个很经典的问题——斐波那契数列。 public static int fibonacci(int n) { if(n==1) { return 1; } if(n==2) { return 1; } return fibonacci(n-1)+fibonacci(n-2); } 上面的试法，存在大量的重复计算，浪费时间。 由此引出我们的动态规划，之前写了8篇暴力递归的文章，就是为了这个目的。 因为动态规划就是某
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 461
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1104
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
【算法】贪心+堆排序实现大根堆及标准库容器类的融合使用
2301_77954967的博客
09-25 1734
先看题这个算法，是要通过循环找到所有元素中最大的那个偶元素，对其除以2，然后再找这之后的最大的那个偶元素以此类推笔者的经历不多，第一次做的时候没有想到大根堆的算法，只是用sort将每次除以2后的整个数组进行降序排序，这样的作法使用sort对数组进行排序后，虽然可以确定数组中的元素大小顺序，但在每次选择偶数进行减半操作时，需要遍历整个数组来找到合适的偶数，效率较低。对于一个较大的数组，排序后可能需要花费较多的时间来找到下一个要进行减半操作的偶数，尤其是当操作次数较多时，这种遍历的方式会变得非常耗时。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 130
初识算法之二分查找
189. 轮转数组（C++）
weixin_45813121的博客
09-25 397
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
动态规划避免暴力：解决经典问题策略
动态规划通过动态构建一个二维数组或递归关系，可以计算出两个序列的LCS长度，通过回溯找到最长公共子序列。 总结来说，动态规划是一种强大的工具，通过避免重复工作和利用问题的结构，解决了暴力方法在大规模问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芜湖高学成

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值