动态规划：基本概念以及面试常见题型

分类：算法作者：BudingCode

动态规划入门

动态规划问题详解：
一篇文章带你解决最常见的动态规划 --> 01背包

动态规划 Dynamic Programming 简称动规或者DP
是一种算法思想，而不是一种具体的算法

动态规划基本概念

动态规划的算法思想
大规模问题的依赖于小规模问题的计算结果，类似思想算法的还有:递归，分治法。

使用前提
无后效性，当前的决策不会影响后面的决策。

动态规划 DP与贪心算法Greedy的区别

动态规划 贪心算法
为了长远的利益会损失当前利益 永远追求当前利益最大化

动态规划的两种实现方法

  1. 记忆化搜索 (使用递归实现)
  2. 多重循环 (使用for循环实现)

按惯例，先来一道例题带大家了解动态规划的两种实现方法：

数字三角形

描述
给定一个数字三角形，找到从顶部到底部的最小路径和。每一步可以移动到下面一行的相邻数字上。

在这里插入图片描述

1.记忆化搜索

//Version 1 : Memorize Search
public class Solution {
    private int n;
    private int[][] minSum;
    private int[][] triangle;

    private int search(int x, int y) {
        if (x >= n) {
            return 0;
        }

        if (minSum[x][y] != Integer.MAX_VALUE) {
            return minSum[x][y];
        }

        minSum[x][y] = Math.min(search(x + 1, y), search(x + 1, y + 1))
            + triangle[x][y];
        return minSum[x][y];
    }

    public int minimumTotal(int[][] triangle) {
        if (triangle == null || triangle.length == 0) {
            return -1;
        }
        if (triangle[0] == null || triangle[0].length == 0) {
            return -1;
        }
        
        this.n = triangle.length;
        this.triangle = triangle;
        this.minSum = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                minSum[i][j] = Integer.MAX_VALUE;
            }
        }

        return search(0, 0);
    }
}

2.for循环

//Version 1: Bottom-Up 自底向上
public class Solution {
    /**
     * @param triangle: a list of lists of integers.
     * @return: An integer,minimum path sum.
     */
    public int minimumTotal(int[][] triangle) {
        if (triangle == null || triangle.length == 0) {
            return -1;
        }
        if (triangle[0] == null || triangle[0].length == 0) {
            return -1;
        }
        
        // state: f[x][y] 代表从i,j 走到最底层的最短路径值
        int n = triangle.length;
        int[][] f = new int[n][n];
        
        // initialize： 初始化重点 -最后一层
        for (int i = 0; i < n; i++) {
            f[n - 1][i] = triangle[n - 1][i];
        }
        
        // bottom up
        //function: 从下往上倒过来推导，计算每个坐标到哪
        for (int i = n - 2; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                f[i][j] = Math.min(f[i + 1][j], f[i + 1][j + 1]) + triangle[i][j];
            }
        }
        
        // answer 起点就是答案
        return f[0][0];
    }
}

// version 2: top-down 自顶向下
public class Solution {
    /**
     * @param triangle: a list of lists of integers.
     * @return: An integer,minimum path sum.
     */
    public int minimumTotal(int[][] triangle) {
        if (triangle == null || triangle.length == 0) {
            return -1;
        }
        if (triangle[0] == null || triangle[0].length == 0) {
            return -1;
        }
        
        // state: f[x][y] 代表从0，0 走到 i,j的最短路径值
        int n = triangle.length;
        int[][] f = new int[n][n];
        
        // initialize: 三角形的左边和右边要初始化
        // 因为他们分别没有左上角和右上角的点
        f[0][0] = triangle[0][0];
        for (int i = 1; i < n; i++) {
            f[i][0] = f[i - 1][0] + triangle[i][0];
            f[i][i] = f[i - 1][i - 1] + triangle[i][i];
        }
        
        // function: f[i][j] = Math.min(f[i - 1][j],f[i - 1][j - 1]) + triangle[i][j];
        //i,j 这个位置是从 i - 1， 或者 i - 1,j - 1走过来的 
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < i; j++) {
                f[i][j] = Math.min(f[i - 1][j], f[i - 1][j - 1]) + triangle[i][j];
            }
        }
        
        // answer: 最后一层的任意位置都可以是路径的终点
        int best = f[n - 1][0];
        for (int i = 1; i < n; i++) {
            best = Math.min(best, f[n - 1][i]);
        }
        return best;
    }
}

动规四要素

动规的状态 State —— 递归的定义

  • 用 f[i] 或者 f[i][j] 代表在某些特定条件下某个规模更小的问题的答案
  • 规模更小用参数 i,j 之类的来划定

动规的方程 Function —— 递归的拆解

  • 大问题如何拆解为小问题
  • f[i][j] = 通过规模更小的一些状态求 max / min / sum / or 来进行推导

动规的初始化 Initialize —— 递归的出口

  • 设定无法再拆解的极限小的状态下的值
  • 如 f[i][0] 或者 f[0][i]

动规的答案 Answer —— 递归的调用 - 最后要求的答案是什么

  • 如 f[n][m] 或者 max(f[n][0],f[n][1] … f[n][m])

动态规划的使用场景与题型分类

使用场景

在这里插入图片描述


三种适用动规的场景
• 求最值
• dp[] 的值的类型是最优值的类型
• dp[大问题] = max{dp[小问题1],dp[小问题2],…}
• dp[大问题] = min{dp[小问题1],…}

• 求方案数
• dp[] 的值的类型是方案数(整数)
• dp[大问题] = ∑(dp[小问题1],…)
• ∑=sum

• 求可行性
• dp[] 的值是 true / false
• dp[大问题] = dp[小问题1] or dp[小问题2] or …
• 代码通常用 for 小问题 if dp[小问题] == true then break 的形式实现

不适用动态规划的场景：

  1. 求出所有具体的方案
    只求出一个具体方案可以动态规划
    该判断标准成功率 99 %

  2. 输入的数据是无序的
    除了背包问题

  3. 暴力算法的复杂度已经是多项式级别
    动态规划擅长与优化指数复杂度（2n,n!) 到多项式级别 （n 2,n3) ，不擅长优化n3到n2

动态规划的题型

在这里插入图片描述

动态规划的题型分类有什么用?

不同题型的动态规划对一个的状态表示方法是不同的，因此如果成功的找对了题型，就能够解决 DP 最难的状态表示问题。

  1. 坐标型动态规划
    dp[i] 表示从起点到坐标 i 的最优值/方案数/可行性
    dp[i][j] 表示从起点到坐标 i,j 的最优值/方案数/可行性
    代表题: Triangle,Unique Paths
  2. 前缀型之划分型
    dp[i] 表示前 i 个字符的最优值/方案数/可行性
    dp[i][j] 表示前 i 个字符划分为 j 个部分的最值/方案数/可行性
    代表题: Word Break,Word Break III
  3. 前缀型之匹配型
    dp[i][j] 表示第一个字符串的前 i 个字符匹配上第二个字符串 的前 j 个字符的最优值/方案数/可行性
    代表题: Longest Common Subsequence,Wildcard Matching
  4. 区间型
    dp[i][j] 表示区间 i~j 的最优值/方案数/可行性
    代表题: Stone Game,Burst Balloons
  5. 背包型
    dp[i][j] 表示前 i 个物品里选出一些物品组成和为 j 的大小的最优 值/方案数/可行性
    代表题: Backpack 系列

简单例题

LeetCode 62.不同路径

LeetCode 62.不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

class Solution {
    public int uniquePaths(int m, int n) {
        //state:    d[i][j] 代表 0,0 走到 i,j 的方案数
        int[][] dp = new int[m][n];

        //initalize:
        for(int i = 0; i < m; i++){
            dp[i][0] = 1;
        }
        for(int j = 0; j < n; j++){
            dp[0][j] = 1;
        }

        //function:
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }

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

LeetCode 63.不同路径ll

LeetCode 63.不同路径ll

题目说明：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

public class Solution {
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        // write your code here
        if(obstacleGrid == null || obstacleGrid.length == 0){
            return 0;
        }
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        
        //
        for(int i = 0; i < m; i++){
            if(obstacleGrid[i][0] == 1){
                break;
            }
            dp[i][0] = 1;
        }
        
        for(int j = 0; j < n; j++){
            if(obstacleGrid[0][j] == 1){
                break;
            }
            dp[0][j] = 1;
        }
        
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(obstacleGrid[i][j] == 1){
                    continue;
                }
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
    
}

LeetCode 55. 跳跃游戏

LeetCode 55. 跳跃游戏

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

class Solution {
    public boolean canJump(int[] nums) {
        if(nums == null || nums.length == 0){
            return false;
        }
        //state: dp[i] 代表是否能够跳到坐标i
        boolean[] dp = new boolean[nums.length];

        //initialization: 0 是初始站位
        dp[0] = true;

        //function:
        for(int i = 1; i < nums.length; i++){
            for(int j = 0; j < i; j++){
                if(dp[j] && nums[j] + j >= i){
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[nums.length - 1];
    }
}

骑士的最短路径II
描述
在一个 n * m 的棋盘中(二维矩阵中 0 表示空 1 表示有障碍物)，骑士的初始位置是 (0,0) ，他想要达到 (n - 1,m - 1) 这个位置，骑士只能从左边走到右边。找出骑士到目标位置所需要走的最短路径并返回其长度，如果骑士无法达到则返回 -1.

public class Solution {
    /**
     * @param grid: a chessboard included 0 and 1
     * @return: the shortest path
     */
    public static int[] deltaX = {1, -1, 2, -2};
    public static int[] deltaY = {-2, -2, -1};
    
    public int shortestPath2(boolean[][] grid) {
        // write your code here
        if(grid == null || grid.length == 0){
            return -1;
        }
        
        int n = grid.length, m = grid[0].length;
        
        //state: dp[i][j] 表示从0,0 到 i,j 的最短距离
        int[][] dp = new int[n][m];
        
        //initialization: 0,0
        //其他点用Max_VALUE代表暂时无法达到
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                dp[i][j] = Integer.MAX_VALUE;
            }
        }
        dp[0][0] = 0;
        
        for(int j = 0; j < m; j++){
            for(int i = 0; i < n; i++){
                if(grid[i][j]){
                    continue;
                }
                
                for(int direction = 0; direction < 4; direction++){
                    int x = i + deltaX[direction];
                    int y = j + deltaY[direction];
                    if(x < 0 || x >= n || y < 0 || y >= m){
                        continue;
                    }
                    if(dp[x][y] == Integer.MAX_VALUE){
                        continue;
                    }
                    dp[i][j] = Math.min(dp[i][j], dp[x][y] + 1);
                }
            }
        }
        if(dp[n-1][m-1] == Integer.MAX_VALUE){
            return -1;
        }
        return dp[n-1][m-1];
    }
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

负数原码与补码之间相互转换
背景：计算机内部用补码表示二进制数。符号位1表示负数，0表示正数。正数：无区别，正数 的原码= 反码 = 补码重点讨论负数若已知 负数 -8，则其原码为：1000 1000，（1为符号位，为1代表负数，为0代表正数）反码为：1111 0111，（符号位保持不变，其他位置按位取反）补码为：1111 1000，（反码 + 1）即在计算机中 用 1111 1000表示 -8若已知补码为 1111 1000，如何求其原码呢？（1）方法1：求负数 原码---&gt;补...
MD5 加密算法介绍
大家好,我们现在来讲解关于加密方面的知识,说到加密我认为不得不提MD5,因为这是一种特殊的加密方式,它到底特殊在哪,现在我们就开始学习它全称:message-digest algorithm 5翻译过来就是:信息 摘要 算法 5加密和摘要，是不一样的加密后的消息是完整的；具有解密算法，得到原始数据；摘要得到的消息是不完整的；通过摘要的数据，不能得到原始数据；所以，当看到很多人说，md5，加密，解密的时候，呵呵一笑就好了。MD5长度有人说md5,128位，32位，16位，到
新的快速排序算法: 《Dual-Pivot QuickSort》阅读笔记
相信大家在大学的《算法与数据结构》里面都学过快速排序(QuickSort), 知道这种排序的性能很好，JDK里面直到JDK6用的都是这种经典快排的算法。但是到了JDK7的时候JDK内置的排序算法已经由经典快排变成了Dual-Pivot排序算法。那么Dual-Pivot到底是何方圣神，能比我们学过的经典快排还要快呢？我们一起来看看。经典快排在学习新的快排之前，我们首先来复习一下经典快排，它的核心思想是:接受一个数组，挑一个数(pivot)，然后把比它小的那一摊数放在它的左边，把比它大的那一摊数放
对称加密与非对称加密
加密在编程中的应用的是非常广泛的，尤其是在各种网络协议之中，对称/非对称加密则是经常被提及的两种加密方式。对称加密我们平时碰到的绝大多数加密就是对称加密，比如：指纹解锁，PIN 码锁，保险箱密码锁，账号密码等都是使用了对称加密。对称加密：加密和解密用的是同一个密码或者同一套逻辑的加密方式。这个密码也叫对称秘钥，其实这个对称和不对称指的就是加密和解密用的秘钥是不是同一个。我在上大学的时候做过一个命令行版的图书馆管理系统作为 C 语言课设。登入系统时需要输入账号密码，当然，校验用户输入的密码
详解vue的diff算法
前言我的目标是写一个非常详细的关于diff的干货，所以本文有点长。也会用到大量的图片以及代码举例，目的让看这篇文章的朋友一定弄明白diff的边边角角。先来了解几个点...1. 当数据发生变化时，vue是怎么更新节点的？要知道渲染真实DOM的开销是很大的，比如有时候我们修改了某个数据，如果直接渲染到真实dom上会引起整个dom树的重绘和重排，有没有可能我们只更新我们修改的那一小块dom而不要更新整个dom呢？diff算法能够帮助我们。我们先根据真实DOM生成一颗virtual DOM，当v
对称加密算法
对称加密算法 所有的对称加密都有一个共同的特点：加密和解密所用的密钥是相同的。现代对称密码可以分为序列密码和分组密码两类：序列密码将明文中的每个字符单独加密后再组合成密文；而分组密码将原文分为若干个组，每个组进行整体加密，其最终加密结果依赖于同组的各位字符的具体内容。也就是说，分组加密的结果不仅受密钥影响，也会受到同组其他字符的影响。序列密码分组密码序列密码的安全性看上去要更弱一些，但是由于序列密码只需要对单个位进行操作，因此运行速度比分组加密要快...
RSA密钥长度、明文长度和密文长度
本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题，对第一次接触RSA的开发人员来讲，RSA算是比较复杂的算法，RSA算法自己其实也很简单，RSA的复杂度是由于数学家把效率和安全也考虑进去的缘故。html本文先只谈密钥长度、明文长度和密文长度的概念知识，RSA的理论及示例等之后再谈。提到密钥，咱们不得不提到RSA的三个重要大数：公钥指数e、私钥指数d和模值n。这三个大数是咱们使用RSA时须要直接接触的，理解了本文的基础概念，即便未接触过RSA的开发人员也能应对自如的使用RSA相关函数库，
布隆过滤器(Bloom Filter)详解
直观的说，bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。算法：1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为03. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为14. 判断某个key是否在集合时
如何防范密码被破解
你会用什么样的算法来为你的用户保存密码？如果你还在用明码的话，那么一旦你的网站被hack了，那么你所有的用户口令都会被泄露了，这意味着，你的系统或是网站就此完蛋了。所以，我们需要通过一些不可逆的算法来保存用户的密码。比如：MD5, SHA1, SHA256, SHA512, SHA-3,等Hash算法。这些算法都是不可逆的。系统在验证用户的口令时，需要把Hash加密过后的口令与后面存放口令的数据库中的口令做比较，如果一致才算验证通过。但你觉得这些算法好吗？我说的是：MD5, SHA1, SHA256,
Excel表格如何筛选重复内容筛选重复数据的方法
在日常工作中经常会使用excel，有时在表格中需要筛选出重复的数据，该怎么操作呢？1、以下图中的表格数据为例，筛选出列中重复的内容；2、打开文件，选中需要筛选的数据列，依次点击菜单项【开始】-【条件格式】-【突出显示单元格规则】-【重复值】；3、将重复的值突出颜色显示；4、选中数据列，点击【数据】-【筛选】；5、点击列标题的的下拉小三角，点击【按颜色筛选】，即可看到重复的数据；...
第三方接口联调加解密与签名验签
工作中经常有和第三方机构联调接口的事情，顾将用到过的做以记录。 在和第三方联调时，主要步骤为：网络、加解密/签名验签、接口数据等，其中接口数据没啥好说的。 在联调前就需要先将两边的网络连通，一般公司的生产环境都加了防火墙，测试环境有的是有防火墙，有的则没有防火墙，这个需要和第三方人员沟通，如果有防火墙的就需要将我们的出口ip或域名发送给第三方做配置，配置了之后网络一般都是通的。加解密与签名验签： 一般第三方公司都会有加解密或签名验签的，毕竟为了数据安全。一般就是三...
Spring Security安全框架中BCrypt强哈希加密算法使用
此文章不包含认证机制。任何应用考虑到安全，绝不能明文的方式保存密码。密码应该通过某种方式进行加密。如今已有很多标准的算法比如SHA或者MD5再结合salt(盐)使用是一个不错的选择。废话不多说！直接开始SpringBoot 中提供了Spring Security：BCryptPasswordEncoder类,实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码。第一步：pom导入依赖：&lt;dependency&gt; &lt;groupId...
哈希加密详解和md5、sha1、sha256、Java 工具类
前言在所有的加密算法中使用最多的就是哈希加密了，很多人第一次接触的加密算法如MD5、SHA1都是典型的哈希加密算法，而哈希加密除了用在密码加密上，它还有很多的用途，如提取内容摘要、生成签名、文件对比、区块链等等。这篇文章就是想详细的讲解一下哈希加密，并分享一个哈希加密的工具类。概述哈希函数（Hash Function），也称为散列函数或杂凑函数。哈希函数是一个公开函数，可以将任意长度的消息M映射成为一个长度较短且长度固定的值H（M），称H（M）为哈希值、散列值（Hash Value）、杂凑值或者消息
[排序算法] 快速排序 (C++) (含三种写法)
#快速排序解释 快速排序 Quick Sort 与归并排序一样，也是典型的分治法的应用。 (如果有对 归并排序还不了解的童鞋，可以看看这里哟~ 归并排序)❤❤❤ ###快速排序的分治模式 1、选取基准
[排序算法] 堆排序 (C++)
#堆排序解释 ##什么是堆 堆 heap 是一种近似完全二叉树的数据结构，其满足一下两个性质 1. 堆中某个结点的值总是不大于(或不小于)其父结点的值； 2. 堆总是一棵完全二叉树 将根结点最大的堆叫
[排序算法] 希尔排序 (C++)
#前言 本文章是建立在插入排序的基础上写的喔，如果有对插入排序还有不懂的童鞋，可以看看这里。 ❤❤❤ 直接/折半插入排序 2路插入排序 ❤❤❤ #希尔排序解释 希尔排序 Shell Sort 又名&q
[排序算法] 归并排序 (C++)
#归并排序解释 归并排序 Merge Sort 是典型的分治法的应用，其算法步骤完全遵循分治模式。 ##分治法思想 分治法 思想: 将原问题分解为几个规模较小但又保持原问题性质的子问题，递归求解这些子
[排序算法] 双向冒泡排序 (C++)
#前言 本文章是建立在冒泡排序的基础上写的，如还有对 冒泡排序 不了解的童鞋，可以看看这里哦~ 冒泡排序 C++ #双向冒泡排序原理 双向冒泡排序 的基本思想与 冒泡排序还是一样的。冒泡排序 每次将相
[排序算法] 直接/折半插入排序 (C++)
#插入排序解释 插入排序很好理解，其步骤是 ：先将第一个数据元素看作是一个有序序列，后面的 n-1 个数据元素看作是未排序序列。对后面未排序序列中的第一个数据元素在这个有序序列中进行从后往前扫描，找到
[排序算法] 桶排序 (C++)
#桶排序解释 ##桶排序思想 桶排序 是一种空间换取时间的排序方式，是非基于比较的。 桶排序 顾名思义，就是构建多个映射数据的桶，将数据放入桶内，对每个桶内元素进行单独排序。假设我们有 n 个待排序的
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot