动态规划一

已于 2022-09-25 20:23:06 修改
阅读量718 收藏
点赞数
分类专栏： 算法刷题 文章标签： 动态规划 leetcode 算法
于 2022-09-25 20:07:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46118239/article/details/126999199
版权

动态规划一

动态规划总论:状态设计的要点和技巧

再探:零钱兑换问题

零钱兑换
https://leetcode.cn/problems/coin-change/
给一个硬币面额的可选集合coins，求拼成金额amount最少需要多少枚硬币。
例: coins = [20,10,5,1],amount = 46
答案:46= 20+ 20+5+1

零钱兑换:搜索

状态:剩余金额、已用硬币枚数

在这里插入图片描述

零钱兑换:最优子结构

状态中没有必要包含“已用硬币枚数”
对于每个“剩余金额”，搜一次，求出“兑换这个金额所需的最少硬币枚数”就足够了

原始状态:剩余金额、已用硬币枚数，目标:到达终点(O元)
新状态:剩余金额，最优化目标:硬币枚数最少
推导关系:“兑换n元的最少硬币枚数”
opt(n)= min(opt(n - 1), opt(n - 9), opt(n- 10))+1
状态＋最优化目标＋最优化目标之间具有递推关系=最优子结构

零钱兑换:最优子结构

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

零钱兑换: 递推实现

class Solution {
    public int coinChange(int[] coins, int amount) {
        int INF = (int)1e9;
        int[] opt = new int[amount + 1];
        opt[0] = 0;
        for(int i = 1; i <= amount; i++) {
            opt[i] = INF;
            for(int j = 0;j < coins.length; j++){
                if(i - coins[j] >= 0)
                    opt[i] = Math.min(opt[i], opt[i - coins[j]] + 1);
            }
        }
        if(opt[amount] >= INF) opt[amount] = -1;
        return opt[amount];
    }
}

零钱兑换: 记忆化搜索

class Solution {
    vector<int>count;
    int dp(vector<int>& coins, int rem) {
        if (rem < 0) return -1;
        if (rem == 0) return 0;
        if (count[rem - 1] != 0) return count[rem - 1];
        int Min = INT_MAX;
        for (int coin:coins) {
            int res = dp(coins, rem - coin);
            if (res >= 0 && res < Min) {
                Min = res + 1;
            }
        }
        count[rem - 1] = Min == INT_MAX ? -1 : Min;
        return count[rem - 1];
    }
public:
    int coinChange(vector<int>& coins, int amount) {
        if (amount < 1) return 0;
        count.resize(amount);
        return dp(coins, amount);
    }
};

无论是递推实现还是记忆化搜索（递归实现)
这种定义状态＋最优子结构＋推导关系的解题方法
其实就是动态规划算法

简单的线性动态规划

**动态规划(DP, dynamic programming)**是一种对问题的状态空间进行分阶段、有顺序、不重复、决策性遍历的算法
动态规划的关键与前提:
重叠子问题——与递归、分治等一样，要具有同类子问题，用若干维状态表示最优子结构——状态对应着一个最优化目标，并且最优化目标之间具有推导关系无后效性——问题的状态空间是一张有向无环图（可按一定的顺序遍历求解)

动态规划一般采用递推的方式实现
也可以写成递归或搜索的形式，因为每个状态只遍历一次，也被称为记忆化搜索
动态规划三要素:阶段、状态、决策

在这里插入图片描述
一道动态规划题目的标准题解:
设opt[i]表示凑成金额 i 所需的最少硬币数
状态转移方程
在这里插入图片描述
边界
在这里插入图片描述

目标
在这里插入图片描述
时间复杂度
在这里插入图片描述
一道动态规划题目，写出状态转移方程，就已经完成了大半的工作
剩下的任务就是照着方程写几个循环递推实现就行了

实战

63.不同路径Ⅱ
https://leetcode.cn/problems/unique-paths-ii/

一个机器人位于一个m x n网格的左上角
机器人每次只能向下或者向右移动一步机
器人试图达到网格的右下角
现在考虑网格中有障碍物
那么从左上角到右下角将会有多少条不同的路径?
在这里插入图片描述

在这里插入图片描述
Bottom-up
f[i,j]表示从(i,j)到End的路径数
如果(i,j)是空地，fli,j]= f[i＋1,j+f Li,j＋1]
否则f[ti,j= 0
Top-down
f[,j]表示从Start到(i,j)的路径数
如果i,j)是空地，f Li,j]= f[i-1,j]+ f li,j-1]
否则ft,j]= 0

在这里插入图片描述

Bottom-up记忆化搜索（递归、分治思想)

int countPaths(boolean[][ ]grid，int row，int col) {
	if ( !validSquare(grid，row,col)) return 0;
	if (isAtEnd(grid，row，col)) return 1;
	return countPaths(grid，row + 1，col) + countPaths(grid，row，col + 1);
}

1143.最长公共子序列
https://leetcode.cn/problems/longest-common-subsequence/

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {

        int n=text1.size();
        int m=text2.size();

        vector<vector<int>> dp(n+1,vector<int>(m+1,0));

        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(text1[i-1]==text2[j-1])
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }else
                {
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[n][m];
    }
};

给两个字符串，求最长公共子序列(LCS)，例如:
text1 = “abcde”
text2 = “ace”

入手DP问题第一步:人工模拟的话怎么算?
拿一个小例子，画个表

在这里插入图片描述
确定“状态”的原则:
寻找变化信息

  • abcd, ac (ac)=>abcde, ace (ace)
  • 两个子串的长度是变化的，内容是固定的

确定“最优子结构”的原则: 寻找代表

  • 同样的两个子串，能组成很多公共子序列
  • 只关心最大长度，不关心具体长什么样

确定“阶段”的原则:线性增长的轮廓

  • “轮廓”是已计算区域与未计算区域的分界

确定“决策”的原则:人工模拟时考虑了哪些选项?

f[i, j] 表示text1的前i 个字符和text2 的前j个字符能组成的LCS的长度

如果text1[i]=text2[j]: f[i, j]= f[i-1,j-1]+1
如果text1[i]≠text2[j]: f[i, j]= max(f [i一1,j],f [i,j一1])

动规题目的边界处理技巧
方法一:
f[0,0]=0，然后递推时用if语句判断，目标f [n - 1,m -1]
方法二:
认为字符串下标从1开始，f[i,0]=0与f[0,j]=0均作为边界，目标f[n, m]

300.最长递增子序列
https://leetcode.cn/problems/longest-increasing-subsequence/

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int f[] = new int[n];
        int pre[] = new int[n];
        for(int i = 0; i < n; i++) {
            f[i] = 1;
            pre[i] = -1;
        }
        for(int i = 1; i < n; i++)
            for(int j = 0; j < i; j++)
                if(nums[j] < nums[i] && f[i] < f[j] + 1){
                    f[i] = f[j] + 1;
                    pre[i] = j;
                }
        int ans = 0;
        int end = -1;
        for(int i = 0; i < n; i++)
            if(f[i] > ans) {
                ans = f[i];
                end = i;
            }
        print(nums, pre, end);
        return ans;
    }

    void print(int[] nums, int[] pre, int i){
        if(pre[i] != -1) print(nums, pre, pre[i]);
        System.out.println(nums[i]);
    }
}

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {

        int n=nums.size();

        vector<int> dp(n,1);
        int max_k=1;
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(nums[i]>nums[j]){
                    dp[i]=max(dp[j]+1,dp[i]);
                    max_k=max(max_k,dp[i]);
                }
            }
        }



        return max_k;
    }        
};

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

动态规划解题步骤

在这里插入图片描述

动态规划“轮廓变化”

在这里插入图片描述

动态规划打印方案

动态规划题目打印方案的原则:记录转移路径＋递归输出
动态规划选取“代表”，维护了一个最优子结构
如果记录每个最优子结构的详细方案，时间复杂度会上升
以LCS为例，本来是0(len2)，每个opt[i,j]记录一个方案（字符串），就变成了0(len3)

正确做法:
记录每个f[i,j]是从哪里转移过来的(f[i-1,j]，fLi,j-1]还是f[i一1,j一1])
整个动规完成，求出f [n,m]后，再从(n,m)开始递归复原最优路径

53.最大子数组和
https://leetcode.cn/problems/maximum-subarray/

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // int pre = 0, maxAns = nums[0];
        // for (const auto &x: nums) {
        //     pre = max(pre + x, x);
        //     maxAns = max(maxAns, pre);
        // }
        // return maxAns;
        
        int n=nums.size();

        vector<int> dp(n+1,0);
        dp[0]=nums[0];
        int mmax=dp[0];

        for(int i=1;i<n;i++)
        {
            dp[i]=max(nums[i],dp[i-1]+nums[i]);
            mmax=max(mmax,dp[i]);
        }
        
        return mmax;
    }
};

f[i]表示以i为结尾的最大子序和
f[i]=max(f [i -1]+mums[i], nums[i])

在这里插入图片描述

状态中何时需要“包含结尾”?
–当结尾参与判定条件时，例如LIS中a[j]<a[i]，此处子序和要“连续”

152.乘积最大子数组
https://leetcode.cn/problems/maximum-product-subarray/

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        vector <int> maxF(nums), minF(nums);
        for (int i = 1; i < nums.size(); ++i) {
            maxF[i] = max(maxF[i - 1] * nums[i], max(nums[i], minF[i - 1] * nums[i]));
            minF[i] = min(minF[i - 1] * nums[i], min(nums[i], maxF[i - 1] * nums[i]));
        }
        return *max_element(maxF.begin(), maxF.end());
    }
};

在这里插入图片描述

70.爬楼梯
https://leetcode.cn/problems/climbing-stairs/description/

class Solution {
public:
    int climbStairs(int n) {
        int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }
};

120.三角形最小路径和
https://leetcode.cn/problems/triangle/description/

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<vector<int>> f(n, vector<int>(n));
        f[0][0] = triangle[0][0];
        for (int i = 1; i < n; ++i) {
            f[i][0] = f[i - 1][0] + triangle[i][0];
            for (int j = 1; j < i; ++j) {
                f[i][j] = min(f[i - 1][j - 1], f[i - 1][j]) + triangle[i][j];
            }
            f[i][i] = f[i - 1][i - 1] + triangle[i][i];
        }
        return *min_element(f[n - 1].begin(), f[n - 1].end());
    }
};

673.最长递增子序列的个数
https://leetcode.cn/problems/number-of-longest-increasing-subsequence/

class Solution {
    int binarySearch(int n, function<bool(int)> f) {
        int l = 0, r = n;
        while (l < r) {
            int mid = (l + r) / 2;
            if (f(mid)) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    }

public:
    int findNumberOfLIS(vector<int> &nums) {
        vector<vector<int>> d, cnt;
        for (int v : nums) {
            int i = binarySearch(d.size(), [&](int i) { return d[i].back() >= v; });
            int c = 1;
            if (i > 0) {
                int k = binarySearch(d[i - 1].size(), [&](int k) { return d[i - 1][k] < v; });
                c = cnt[i - 1].back() - cnt[i - 1][k];
            }
            if (i == d.size()) {
                d.push_back({v});
                cnt.push_back({0, c});
            } else {
                d[i].push_back(v);
                cnt[i].push_back(cnt[i].back() + c);
            }
        }
        return cnt.back().back();
    }
};

https://ke.qq.com/course/417774?flowToken=1041943

动态规划凑零钱问题
m0_51436734的博客
04-07 397
动态规划特点： 重复子问题 状态转移方程（最关键） 最优子结构 题型：求最值 核心： 穷举 解题套路： 明确状态 明确选择 明确dp函数/数组的定义 明确base case # 暴力求解(超时，通过不了) class Solution { // 状态：目标金额 amount // 选择：coins 数组中列出所有硬币面额 // 函数的定义：凑出总金额amount，至少需要coinChange(coins,amount)枚硬币 // base case： amount
动态规划1
08-08
在这个“动态规划1”的例子中，我们有两个不同的动态规划问题。 第一个问题涉及构建最小代价子母树。这是一个典型的动态规划问题，目标是找到一个分割点，将给定的树分成两部分，使得这两部分的代价之和最小。在这...
凑零钱（动态规划）
Shanhj的博客
07-06 506
题面：韩梅梅喜欢满宇宙到处逛街。现在她逛到了一家火星店里，发现这家店有个特别的规矩：你可以用任何星球的硬币付钱，但是绝不找零，当然也不能欠债。
动态规划---零钱兑换
最新发布
m0_65096633的博客
09-06 226
由于递推公式是在dp[j]与dp[j-coins[i]]+1中取最小值，那么初始化dp就应该是最大值Integer.MAX_VALUE。dp[0]代表总金额为0时最少的硬币数，应该为0。要加入一个coins[i]达到总金额j，那么加入后最少硬币个数为1+dp[j-coins[i]]本题属于完全背包问题，但所求方案可以是排列数也可以是组合数，都不影响最少硬币数。dp数组是一维数组，dp[j]代表凑成总金额j所需的最少硬币个数。因此遍历序列可以是先遍历物品再遍历背包容量，也可以反过来。1.确定dp数组及含义。
动态规划之凑零钱
weixin_44386939的博客
02-26 310
凑零钱 思路 dp(n): 凑出n元至少需要dp(n)枚硬币 状态转移方程：dp(n) = min(dp(n-1)+1, dp(n-2)+1, dp(n-5)+1) (假如零钱面额为1、2、5) dp(0) = 0 代码 /** * @param {number[]} coins * @param {number} amount * @return {number} */ var coinChange = function(coins, amount) { let dp = n
凑零钱问题 (动态规划）
qq_26139541的博客
04-23 1138
凑零钱问题 先看下题⽬ ： 给你 k 种⾯值的硬币， ⾯值分别为 c1, c2 … ck ， 每种硬 币的数量⽆限， 再给⼀个总⾦额 amount ， 问你最少需要⼏枚硬币凑出这个 ⾦额， 如果不可能凑出， 算法返回 -1 。 算法的函数签名如下： // coins 中是可选硬币⾯值， amount 是⽬标⾦额 int coinChange(int[] coins, int amount); 动态规划解题套路框架 33⽐如说 k = 3 ， ⾯值分别为 1， 2， 5， 总⾦额 amount = 11 。
动态规划：找凑零钱
hongshanqu的博客
04-01 421
问题：一个地区有三种钞票，币值分别为{1、5、11}，要凑够元，最少需要张钞票。按照贪心算法的策略，先凑出最大面值的11，剩下的4个分别对应四个1元的钞票，这总共需要5张钞票。实际上，的钞票也能凑够15元。这样就把原有的大问题转化为同类型的小问题。如果用用 f(n) 表示凑出 n 最少需要的钞票张数，从前面的分析可知：如果我们计算出f(1), f(2), ..., f(k)，就能计算出f(k+1)。从归纳计算的角度看，我们就解决了f(n)的计算问题。归纳计算的公式为。
3动态规划1
08-03
动态规划是一种强大的算法设计方法，尤其适用于解决具有重叠子问题和最优子结构的复杂问题。在这个“3动态规划1”的主题中，我们将探讨几种经典的应用，包括硬币收集问题、多段图最短路径、0/1背包问题、矩阵乘法链...
III-5.自适应动态规划1
08-04
自适应动态规划1 自适应动态规划是机器学习和控制理论中的一种重要方法，用于解决复杂系统的优化控制问题。它结合了动态规划和自适应控制的思想，能够在线处理不确定性和变化的环境。 自适应动态规划的问题描述...
实验二 动态规划1
08-08
动态规划实践 - 0/1背包问题 动态规划是一种常用的算法设计技术，用于解决复杂的问题。它通过将问题分解成多个小问题，然后解决每个小问题，最后将解决方案组合起来，得到原问题的解决方案。在这里，我们将讨论动态...
lee322 凑零钱问题 动态规划
mengmengkuaipao的博客
02-19 278
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 示例 1: 输入: coins = [1, 2, 5], amount = 11 输出: 3 解释: 11 = 5 + 5 + 1 示例 2: 输入: coins = [2], amount = 3 输出: -1 说明: 你可以认为每...
动态规划的漂亮打印 acm
05-30
动态规划的例子#include<iostream> using namespace std; int c[1000]; //状态数组 const int num=10; const int M=20 ; const int MaxValue=10000; int l[num]={6 , 7 , 1 ,4 ,6 ,3 ,1 , 5 , 3 , 4 };//存储每具单词的长度 int p[1000]; //保存记录用于重构最优解的数组 //lc函数用来分类，把边界情况考虑进去 int lc(int i,int j) { int temp=0; for(int k=i;k<=j;k++) temp+=l[k]; int s=M-j+i-temp; if(s<0) return MaxValue; //从i到j的单词不能放在一行 if(j==10) return 0; //最后一行 else return s*s*s; } void PrettyPainting() { c[0]=0; //base case; int min; for(int j=1;j<=num;j++) { c[j]=MaxValue; for(int i=1;i<=j;i++) if(c[i-1]+lc(i,j)<c[j]) {c[j]=c[i-1]+lc(i,j);p[j]=i;} } cout<<c[10]; } int main() { PrettyPainting(); return 0;
动态规划之找零钱问题
11-22
代码中包含有详细注释，另外还附加了一份报告，关于这个问题的具体分析，具有很好的参考价值
动态规划解决找零钱问题
11-03
数组b[J]代表要找零的总数。 初始化b[0]=0; b[J]=min{b[J-a[k]]};1<=k=0) 程序中面值有1,3,4,6 存于a数组中 时间复杂度O(M*N) 输出总硬币数
凑零钱动态规划java_LeetCode刷题分类之动态规划 322. 凑零钱
weixin_39632524的博客
03-02 334
1. 题目给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。你可以认为每种硬币的数量是无限的。示例 1：输入：coins = [1, 2, 5], amount = 11输出：3解释：11 = 5 + 5 + 1示例 2：输入：coins = [2], amount = 3输出：-1示...
02-动态规划-凑零钱问题
weixin_42289193的博客
12-10 917
数据结构-动态规划算法
从凑零钱问题理解动态规划
douyh的专栏
03-27 245
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。你可以认为每种硬币的数量是无限的。示例 1：输入：coins = [1, 2, 5], amount = 11输出：3解释：11 = 5 + 5 + 1示例 2：输入：coins = [2], amount = 3输出：-1示例 3：输入：coins = [1], amount = 0。
动态规划解决 - 【凑零钱问题】
qq_41266196的博客
07-02 296
动态规划解决凑零钱问题
动态规划--凑零钱.钱币的组合有多少种(java)
SP_1024的博客
06-07 844
例如：arr = {1,1,1}，aim = 2 第0个和第1个能组成2，我们有两种选择,一个是选一个是不选两种情况,两种情况都是不同的选择.动态规划就是对递归的改写.先观察递归里的变化的参数.1.如果钱币数组的里的钱币已经选择完了,就结束了,一.根据base case 来初始化动态规划表.即便是值相同的货币也认为每一张都是不同的，第0个和第2个能组成2 一共就3种方法，arr是货币数组，其中的值都是正数。剩下的是递归过程,每次到一个钱币时.三.返回递归调用的最初始的过程.第1个和第2个能组成2，
"计算机算法设计与分析：Chp15-动态规划1
在背包问题中，动态规划可以用来解决0-1背包和多重背包等问题。通过动态规划的算法设计与分析，我们能够有效地解决这些优化问题，得到最优的解决方案。 在总结上述内容时，我们发现，动态规划是一种重要的算法设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我也要当昏君

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

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

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

打赏作者

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

抵扣说明：

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

余额充值