DP(Dynamic Programming)动态规划

最新推荐文章于 2021-03-08 15:16:58 发布
最新推荐文章于 2021-03-08 15:16:58 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： LeetCode 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42072280/article/details/104588720
版权

动态规划（英语：Dynamic programming，简称 DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。

动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解以得出原问题的解。动态规划往往用于优化递归问题，例如斐波那契数列，如果运用递归的方式来求解会重复计算很多相同的子问题，利用动态规划的思想可以减少计算量。

通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，具有天然剪枝的功能，从而减少计算量：一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

链接：https://leetcode-cn.com/tag/dynamic-programming/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

学习动态规划，这是一种解决棘手问题的方法，它将问题分解成小问题，并先着手解决这些小问题。
每个动态规划算法都从一个网格开始
动态规划可以帮助在给定约束条件下找到最优解
在这里插入图片描述
一个问题如果要用动态规划解的话，需要考虑下面的几个点：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

背包问题

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

旅游行程最优化

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

最长公共子串

在这里插入图片描述

疑问：如果答案不在最后一个格子的话，该怎么取值？

最长公共子序列

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

5.最长回文子串

在这里插入图片描述

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

//java    通过了
class Solution {
    public String longestPalindrome(String s) {
        String res = "";
        int n = s.length();
        boolean[][] dp = new boolean[n][n];

        for(int i = n; i >= 0; i--){
            for(int j = i; j < n; j++){
                if(j == i || j == i+1){
                    dp[i][j] = (s.charAt(i) == s.charAt(j));
                }else{
                    dp[i][j] = (dp[i+1][j-1] && s.charAt(i) == s.charAt(j));
                }

                if(dp[i][j] && (j-i+1 > res.length())){
                    res = s.substring(i, j+1);
                }
            }
        }
        return res;
    }
}
/*
输入："babad"
i\j  0  1  2  3  4
0	 1  0  1  0  0
1    0  1  0  1  0
2    0  0  1  0  0
3	 0  0  0  1  0
4	 0  0  0  0  1
*/

#和上面的java思路一样 但是一直超出时间限制
class Solution:
    def longestPalindrome(self, s: str) -> str:
        res = ""          #最长回文子串
        a=[[False for _ in range(len(s))]for _ in range(len(s))]  #生成二维数组并初始化

        for i in range(len(s)-1, -1, -1): #长度为5的话，输出：4，3，2，1，0           
            for j in range(i, len(s)):
                #print(i, j)
                if(j == i or j == i+1):
                    a[i][j] = (s[i] == s[j])
                else:
                    a[i][j] = (a[i+1][j-1] == 1 and s[i] == s[j])

                if(a[i][j] and (j-i+1 > len(res))):
                    res = s[i:j+1]

        return res

动态规划 空间优化
在这里插入图片描述

//java
class Solution {
    public String longestPalindrome(String s) {
        String res = "";
        int n = s.length();
        boolean[] dp = new boolean[n];

        for(int i = n-1; i >= 0; i--){
            for(int j = n-1; j >= i; j--){
                if(j == i || j == i+1){
                    dp[j] = (s.charAt(i) == s.charAt(j));
                }else{
                    dp[j] = (dp[j-1] && s.charAt(i) == s.charAt(j));
                }

                if(dp[j] && (j-i+1 > res.length())){
                    res = s.substring(i, j+1);
                }
            }
        }
        return res;
    }
}

62.不同路径

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

//java  anan  2020.3.2
class Solution {
    public int uniquePaths(int m, int n) {
        int dp[][] = new int[n][m];
        dp[0][0] = 1;

        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(i > 0 || j > 0){  //设置条件是为了除去初值
                    dp[i][j] = (i-1>=0 ? dp[i-1][j] : 0) + (j-1>=0 ? dp[i][j-1] : 0);
                }
            }
        }

        return dp[n-1][m-1];
    }
}

63.不同路径 II

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

//java    anan  2020.3.2
class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;

        if(obstacleGrid[n-1][m-1] == 1){  //[[0,1]]
            return 0;
        }

        int dp[][] = new int[n][m];
        dp[0][0] = (obstacleGrid[0][0] == 0) ? 1:0;  //[[0]]    [[1]]

        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(i > 0 || j > 0){  //设置条件是为了除去初值
                    dp[i][j] = (i-1>=0 && obstacleGrid[i-1][j]==0 ? dp[i-1][j] : 0) + (j-1>=0  && obstacleGrid[i][j-1]==0? dp[i][j-1] : 0);    //加了一些判定条件
                }
            }
        }

        return dp[n-1][m-1];
    }
}

64.最小路径和

在这里插入图片描述

//java  anan 2020.3.2
class Solution {
    public int minPathSum(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;

        int[][] dp = new int[n][m];   //dp中存的是到当前位置的最短路径
        dp[0][0] = grid[0][0];

        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(i > 0 || j > 0){
                    dp[i][j] = Math.min((i-1>=0? dp[i-1][j] : Integer.MAX_VALUE), (j-1>=0? dp[i][j-1] : Integer.MAX_VALUE)) + grid[i][j];
                }
            }
        }
        return dp[n-1][m-1];
    }
}

空间优化，用一维数组

//java  anan 2020.3.2
class Solution {
    public int minPathSum(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;

        int[] dp = new int[m];   //dp中存的是到当前位置的最短路径
        dp[0] = grid[0][0];

        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(i > 0 || j > 0){
                    dp[j] = Math.min((i-1>=0? dp[j] : Integer.MAX_VALUE), (j-1>=0? dp[j-1] : Integer.MAX_VALUE)) + grid[i][j];
                }
            }
        }
        return dp[m-1];
    }
}

53.最大子序和

在这里插入图片描述

//java
class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        int max = nums[0];

        dp[0] = nums[0];
        for(int i = 1; i < n; i++){
            if(dp[i-1] < 0){
                dp[i] = nums[i];
            }else{
                dp[i] = dp[i-1]+nums[i];
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }
}

70.爬楼梯

在这里插入图片描述

//C
int climbStairs(int n){
/*
f(1) = 1
f(2) = 2
f(3) = f(1)+ f(2)
f(4) = f(2) + f(3)
f(n) = f(n-2) + f(n-1)
*/

    int num[n+1];

    for(int i = 0; i < n+1; i++){
        if(i <= 2){
            num[i] = i;
        }else{
            num[i] = num[i-1]+num[i-2];
        }
        printf("%d ", num[i]);
    }

    return num[n];
}

//C  代码优化
int climbStairs(int n){
    int num[n+1];

    for(int i = 0; i < n+1; i++){
        num[i] = (i <= 2) ? i : num[i-1]+num[i-2];
    }

    return num[n];
}

139.单词拆分

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

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

#python  anan 根据题解思想写的

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        n = len(s)
        dp = [False for _ in range(n+1)]  #dp[i]表示s[0:i]可以由字典中的词构成
        dp[0] = True

        for i in range(n):
            for j in range(i+1, n+1):              
                if(s[i:j] in wordDict and (dp[i])):
                    dp[j] = True
                #print(i, j, s[i:j], dp)
        return dp[-1]

//java
public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordDictSet=new HashSet(wordDict);
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 0; j < i; j++) {
                if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/word-break/solution/dan-ci-chai-fen-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

91.解码方法

在这里插入图片描述

#python anan 2020.3.2
class Solution:
    def numDecodings(self, s: str) -> int:
        n = len(s)
        dp = [1 for _ in range(n+1)]
        
        for i in range(1,n+1):
            dp[i] = (dp[i-1] if (i >= 1 and 0 < int(s[i-1]) <= 26) else 0)  + (dp[i-2] if (i >= 2 and 0 < int(s[i-2:i]) <= 26 and int(s[i-2])!=0) else 0)
            # 加上int(s[i-2])!=0   是因为："01"
        #print(dp)
        dp[0] = 0  #   ""空串时结果应该是0，上面设置成1是为了好迭代

        return dp[-1]

96.不同的二叉搜索树

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

#python
class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= i; j++){
                dp[i] += dp[j-1]*dp[i-j];
            }
        }

        return dp[n];
    }
}

322.零钱兑换

官方解答
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

//java 2020.3.9   自己结合官解思路自己写的
class Solution {
    public int coinChange(int[] coins, int amount) {
        if(amount == 0){   //特殊例子：  [1]   0
            return 0;
        }

        int[] dp = new int[amount+1];
        int min;
        Arrays.sort(coins);   //在原数组上进行排序
        Arrays.fill(dp, amount+1);
        dp[0] = 0;

        for(int i = 1; i < amount+1; i++){
            for(int j = 0; j < coins.length; j++){
                if(i-coins[j] >= 0){
                    dp[i] = Math.min(dp[i], dp[i-coins[j]]+1);
                }      
            }      
        }

        // for(int d: dp){
        //     System.out.print(d + " ");
        // }

        return dp[amount]!=amount+1 ? dp[amount] : -1;
    }
}
安安csdn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动态规划DP【持续更新】
NIRVANA REBIRTH
11-24 548
动态规划   动态规划（英语：Dynamic programming，简称DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。   动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。   动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题...
动态规划(Dynamic Planning) Summary
锦瑟年华,逐梦之人
11-11 1617
动态规划思想中包含了贪心思想、和记忆化思想。 其中，记忆化思想是主体思想（同一件事情不做两次，保证每一个状态最多只处理一次），这样保证了动态规划的高效性。动态规划的特点是： 大问题可以划分若干个子问题（子问题与大问题性质相同但是规模变小） 计算子问题中存在重叠的部分 处理动态规划的要点： 要会用问题的特征参数描述当前问题 状态转移方程（状态值之间的关系）（最重要的一点，找到状态转移方程，问题也就基
动态规划翻译自维基百科
alittlewhitea的博客
08-16 1284
动态规划 维基百科，自由的百科全书 动态规划（英语：Dynamic programming，简称DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题[1]和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个
动态规划（Dynamic Programming）
suotanyu1595的博客
03-08 538
动态规划（Dynamic Programming） 一 定义 动态规划，Dynamic Programming（此处“Programming”为“规划”，而非指“程序”、“编程”），是指研究多步决策过程最优化问题的一种数学方法，英文缩写DP。在动态规划中，为了寻找一个问题的最优解（即最优决策过程），将整个问题划分成若干个相应的阶段，并在每个阶段都根据先前所作出的决策作出当前阶段最优决策，进而得出整个问题的最优解。通过将问题的分解为和子问题的相关性，依次迭代解决子问题，来解决最终问题。 运用动态规划的来解决的
动态规划（DP dynamic programming)
bdss58的专栏
10-13 566
>>>>>>>
什么是动态规划（Dynamic Programming）？动态规划的意义是什么？ - 知乎1
08-03
引入这两个概念之后，我们如何判断一个问题能否使用DP解决呢？能将大问题拆成几个小问题，且满足无后效性、最优子结构性质。3. DP的典型应用：DAG最短路问题很简
java实现动态规划（Dynamic Programming）
06-14
示例代码展示了如何使用动态规划来计算斐波那契数列的第 n 项。 在代码中，我们定义了一个 fibonacci 方法，它接受一个整数 n 作为输入，并返回斐波那契数列的第 n 项。我们创建了一个大小为 n+1 的数组 dp 来保存...
动态规划dynamic programming
04-19
动态规划（Dynamic Programming，简称DP）是计算机科学中一种强大的问题解决方法，广泛应用于算法设计与分析中。它主要处理具有重叠子问题和最优子结构的问题，通过将复杂问题分解为更小的子问题来求解全局最优解。...
动态规划（Dynamic Programming）详解：算法优化之道
最新发布
05-11
动态规划（Dynamic Programming，DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学等领域中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划经常在各种最优化问题中发挥...
dp.rar_dynamic programming_towerbyj
09-21
动态规划（Dynamic Programming，简称DP）是一种在计算机科学和数学中广泛应用的算法设计技术，用于解决最优化问题。它通过将复杂问题分解成更小的子问题，然后存储子问题的解，避免重复计算，从而达到高效求解的...
动态规划混合动力汽车能量管理matlab程序（包括速度mat）
02-01
动态规划混合动力汽车能量管理matlab程序（包括速度mat）
DP 动态规划Dynamic programming
bjtu_dubing的博客
01-02 398
DP   （DP（动态规划Dynamic programming）） 动态规划（dynamic programming）背后的思想非常简单：通常为了解决一个问题，我们需要把它分解成很多类似的但更小的子问题，然后解决这些子问题，最终把这些子问题结果联系起来就解决了原先的那个问题。但是在上面这个过程中，如果使用的是比较“原始”的方法，它会碰到多次产生相同的子问题（比如子问题的子问
动态规划算法（DP,Dynamic Programming）
Star_tears的博客
01-27 484
动态规划算法（DP,Dynamic Programming） 文章目录动态规划算法（DP,Dynamic Programming）前言一、递归到DP的一般转化方法二、DP解题的一般思路1.将原问题分解为子问题2.*确定状态3. 确定一些初始状态（边界状态）的值4. 确定状态转移方程能用DP解决的问题的特点 前言 它针对满足特定条件的一类问题，对各状态维度进行分阶段、有顺序、无重复、决策性的遍历求解。 一、递归到DP的一般转化方法 递归函数有n个参数，就定义一个n维的数组，数组 的下标是递归函数参数的
机器翻译(动态规划)
amdkk的博客
05-20 314
开始填补今年清北的坑，，，定义a[i][j]是给前i个公司分配j台机器产生的最大收益根据mzx老(da)师(lao)所讲，动规题先写爆搜int dfs(int i,int j)//给前i个公司分配j台机器的最收益 { if(i==0||j==0) return 0; int ans=0; if(f[i[[j]!=-1) return f[i][j]; for(int...
动态规划之基本概念和术语
12-22 1255
动态规划之基本概念和术语动态规划引言1 动态规划原理1.1 最短路问题及其解法1.2 动态规划的基本概念和术语1.2.1 多阶段决策问题1.2.2 阶段变量1.2.3 状态变量1.2.4 决策变量1.2.5 整体策略1.2.6 状态转移方程1.2.7 指标函数 动态规划 引言   1951年，美国数学家贝尔曼（R.Bellman）等根据一类所谓多阶段决策问题的特性，提出了解决这类问题的“最优化原理”，并研究了许多实际问题，从而创立了最优化的一个新分支----动态规划。   动态规划没有统一的数学模型，对不同
DP（动态规划）个人学习-初步
PiKa__Qiu的博客
01-30 428
动态规划是一种重要算法，其思想，在我个人理解来看，就是把问题逐步地进行简化，从一个看似复杂的问题，将问题化小，简化到可以用某条公式（状态转移方程）逐步求出每种状态的解，直到最后求出所要的答案。 比如01背包问题，背包容量有限，要尽可能装入价值大的物品，我们可以假设一个dp数组，其中dp[j]表示在容量为j的情况下最多能装入多少价值的物品，这样就把问题简化到求一个个状态了，但是明显还是不够用来解决
动态规划算法（一）
Coulnaut的博客
09-14 940
最近遇到动态规划算法的频率有点大，所以借此机会好好的来了解和学习一下动态规划。当然也记录下来，一起交流。 1. 了解概念 动态规划，英文名：Dynamic Programming ，简称DP，小名动规。 动态规划思想就是，大事化小，小事化了。它把大问题化解为小问题，再保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。 于是就可以了解其的特点，把大问题先分解...
动态规划 Dynamic programming
Jeff_的博客
09-13 1667
文章目录一、前言二、优点三、引申1. [coin-change](https://leetcode.com/problems/coin-change/solution/) 换零钱问题2. [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/) 最小路径问题3. [Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum
信息学竞赛DP专题(一)BNU8207舞蹈家怀特先生
° ﹎.- 看淡1.苆х.
04-23 1178
//题目大意: 初始时候怀特双脚都在0的位置.之后每次出现一个1-4中的一个数.1=UP.2=right.3=down.4=left. // 0到其他位置消耗2体力.其他时候.在原地跳消耗1体力..跳到相邻位置消耗3体力.跳到相对位置消耗4体力. // 给定一个跳舞的序列步伐.问最后消耗的体力最少是多少. //解题思路: 用DP[i][j][k] 表示在第i次的
DP总结.pdf 来自Tsinghua University
08-18
动态规划（Dynamic Programming，简称DP）是一种用于解决最优化问题的算法，通常用于处理具有重叠子问题和最优子结构的复杂问题。这份讲义主要分为三个部分：状态类型、转移方式和DP优化。 1. **状态类型**： - **...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

安安csdn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值