动态规划(三)-序列型动态规划

最新推荐文章于 2023-05-30 09:12:00 发布
最新推荐文章于 2023-05-30 09:12:00 发布
阅读量883 收藏 4
点赞数 4
分类专栏： 面试必备 算法 ACM-dp(动态规划) 文章标签： 动态规划 算法
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_33248299/article/details/110818784
版权

一.序列型动态规划概述

1.序列型动态规划特点

  • 给定一个序列
  • 动态规划方程f[i]中的下标i表示前i个元素a[0]、a[1]、…a[i-1]的某种性质
    • 坐标型的f[i]表示以ai为结尾的某种性质
  • 初始化中，f[0]表示空序列的性质
    • 坐标型动态规划的初始条件f[0]就是指以a0为结尾的子序列的性质

2.例1(LintCode 516 Paint House I)

  • 题意
    有一排N栋房子，每栋房子要漆成3种颜色中的一种：红、蓝、绿,任何两栋相邻的房子不能漆成同样的颜色,第i栋房子染成红色、蓝色、绿色的花费分别是cost[i][0]，cost[i][1]，cost[i][2],问最少需要花多少钱油漆这些房子

  • 例子

    • 输入：N=3，Cost=[[14,2,11],[11,14,5],[14,3,10]]
    • 输出：10(第0栋房子蓝色，第1栋房子绿色，第2栋房子蓝色，2+5+3=10)

  • 可以直接上暴力…不过暴力的时间复杂度是3的n次方,数据量大的话多半凉凉,所以我们还是来考虑下用dp思想怎么做这道题吧

A.确定状态
  • 最优策略就是花费最小的策略
    • 最后一步：最优策略中房子N-1一定是染成了红、蓝、绿中的一种,我们先不管是哪一种,但是相邻两栋房子不能漆成一样颜色
    • 如果最优策略房子N-1是红，房子N-2只能是蓝或绿
    • 所以如果最优策略房子N-1是蓝，房子N-2只能是红或绿
    • 所以如果最优策略房子N-1是绿，房子N-2只能是红或蓝
    • 貌似有点复杂了…
    • 如果直接套用以前思路，记录油漆前N栋房子的最小花费,根据以前的套路，也需要记录油漆前N-1栋房子的最小花费,但是，前N-1栋房子的最小花费的最优策略中，不知道房子N-2是什么颜色，所以有可能和房子N-1撞色…
    • 我们知道N-1房子最少花100，但是不知道房子N-1是什么颜色，如果是蓝色，N-2也是蓝色。。。那么答案就是错的…简单的来说就是以前的套路是不管颜色,仅仅是求的最少的花费而已
      在这里插入图片描述
  • 尽然如此,那么就只有记录下颜色了,不知道房子N-2是什么颜色,就把它记录下来！
  • 分别记录油漆前N-1栋房子并且房子N-2是红色、蓝色、绿色的最小花费

在这里插入图片描述

  • 求油漆前N栋房子并且房子N-1是红色、蓝色、绿色的最小花费
  • 需要知道油漆前N-1栋房子并且房子N-2是红色、蓝色、绿色的最小花费
  • 子问题
  • 状态：设油漆前i栋房子并且房子i-1是红色、蓝色、绿色的最小花费分别是f[i][0],f[i][1],f[i][2] (从0开始的)
B.转移方程
  • 设油漆前i栋房子并且房子i-1是红色、蓝色、绿色的最小花费分别为f[i][0],f[i][1],f[i][2]
    在这里插入图片描述
C.初始条件和边界情况
  • 设油漆前i栋房子并且房子i-1是红色、蓝色、绿色的最小花费分别为f[i][0],f[i][1],f[i][2]
  • 初始条件：f[0][0]=f[0][1]=f[0][2]=0(即不油漆任何房子的花费)
  • 无边界情况
D.计算顺序

在这里插入图片描述

E.代码
public int minCost(int[][] costs) {
        if(costs==null||costs.length==0){
            return 0;
        }
        int result = 0x7fffffff;
        int n=costs.length;
        int m=costs[0].length;
        int [][] dp = new int[n+1][m];
        dp[0][0]=0;
        dp[0][1]=0;
        dp[0][2]=0;
        for(int i=1;i<=n;i++){
            dp[i][0]=Math.min(dp[i-1][1],dp[i-1][2])+costs[i-1][0];
            dp[i][1]=Math.min(dp[i-1][0],dp[i-1][2])+costs[i-1][1];
            dp[i][2]=Math.min(dp[i-1][1],dp[i-1][0])+costs[i-1][2];
        }
        
        for(int i=0;i<m;i++){
            result=Math.min(dp[n][i],result);
        }
        return result;
    }
  • 这里数组dp又是只和上一行有关…所以我们可以用滚动数组优化
 public int minCost(int[][] costs) {
        if(costs==null||costs.length==0){
            return 0;
        }
        int result = 0x7fffffff;
        int n=costs.length;
        int m=costs[0].length;
        int [][] dp = new int[2][m];
        int news,olds;
        dp[0][0]=0;
        dp[0][1]=0;
        dp[0][2]=0;
        news=1;
        olds=0;
        for(int i=1;i<=n;i++){
            dp[news][0]=Math.min(dp[olds][1],dp[olds][2])+costs[i-1][0];
            dp[news][1]=Math.min(dp[olds][0],dp[olds][2])+costs[i-1][1];
            dp[news][2]=Math.min(dp[olds][1],dp[olds][0])+costs[i-1][2];
            news = news^olds;
            olds = news^olds;
            news = news^olds;
        }
        
        for(int i=0;i<m;i++){
            result=Math.min(dp[olds][i],result);
        }
        return result;
    }

3.例2(LintCode 516 Paint House II)

  • 题意：
    有一排N栋房子，每栋房子要漆成K种颜色中的一种,任何两栋相邻的房子不能漆成同样的颜色,房子i染成第j种颜色的花费是cost[i][j],问最少需要花多少钱油漆这些房子
  • 例子
    • 输入：N=3，K=3，cost=[[14,2,11],[11,14,5],[14,3,10]]
    • 输出：10(房子0蓝色，房子1绿色，房子2蓝色，2+5+3=10)
A.确定状态
  • 这题和Paint House类似，只是颜色种类变成了K种
  • 动态规划思路和Paint House一样，需要记录油漆前i栋房子并且房子i-1是颜色1，颜色2，…，颜色K的最小花费：f[i][1]、f[i][2]、…、f[i][k]
B.转移方程

  • 设油漆前i栋房子并且房子i-1是颜色1，颜色2，…颜色K的最小花费分别为f[i][1]、f[i][2]、…、f[i][K]

  • f[i][1]=min{f[i-1][2]+cost[i-1][1],f[i-1][3]+cost[i-1][1],…,f[i-1][K]+cost[i-1][1]}

  • f[i][2]=min{f[i-1][1]+cost[i-1][2],f[i-1][3]+cost[i-1][2],…,f[i-1][K]+cost[i-1][2]}

  • …

  • f[i][K]=min{f[i-1][1]+cost[i-1][K],f[i-1][2]+cost[i-1][K],…,f[i-1][K-1]+cost[i-1][K]}

  • 设油漆前i栋房子并且房子i-1是颜色1，颜色2，…颜色K的最小花费分别为f[i][1]、f[i][2]、…、f[i][K]

在这里插入图片描述

  • 设油漆前i栋房子并且房子i-1是颜色1，颜色2，…颜色K的最小花费分别为f[i][1]、f[i][2]、…、f[i][K]

  • f[i][j]=min(k!=j){f[i-1][k]}+cost[i-1][j]

  • 直接计算的时间复杂度(计算步数):i从0到N，j从1到K，k从1到K，O(NK²)

C.代码
public int minCostII(int[][] costs) {
        if(costs==null||costs.length==0){
            return 0;
        }
        int n = costs.length;
        int m = costs[0].length;
        int [] [] dp = new int[n+1][m];
        int result = Integer.MAX_VALUE;
        for(int i=1;i<=n;i++){
            for(int j=0;j<m;j++){
                dp[i][j]=Integer.MAX_VALUE;
                for(int k=0;k<m;k++){
                    if(j!=k){
                       dp[i][j]=Math.min(dp[i-1][k]+costs[i-1][j],dp[i][j]);
                    }    
                }
            }
        }
        
        for(int i=0;i<m;i++){
            result = Math.min(dp[n][i],result);
        }
        
        return result;
    }
  • 能不能再快点？上面代码在LIntcode上提交时间才超越百分之8的人
D.动态规划常见优化
  • f[i][j]=[min(k!=j){f[i-1][k]}]+cost[i-1][j]
  • 每次需要求f[i-1][1]，…，f[i-1][K]中除了一个元素之外其他元素的最小值，会产生很多重复
    在这里插入图片描述
  • 只要不是除开的是最低值，最低值永远都是它，除开它的最低值就是次小值

在这里插入图片描述

  • f[i][j]=min(k!=j){f[i-1][k]}+cost[i-1][j]
  • 记录下f[i-1][1]，…，f[i-1][K]中的最小值和次小值分别是哪个
  • 加入最小值时f[i-1][a]，次小值是f[i-1][b],则对于j=1,2,3,…,a-1,a+1,…,K,f[i][j]=f[i-1][a]+cost[i-1][j],f[i][a]=f[i-1][b]+cost[i-1][a]
  • 时间复杂度降为O(NK)
E.优化后代码
public int minCostII(int[][] costs) {
        if(costs==null||costs.length==0){
            return 0;
        }
        int n = costs.length;
        int m = costs[0].length;
        int [] [] dp = new int[n][m];
        int result = Integer.MAX_VALUE;
        int min1,min2,j1,j2;
        //我这里dp代表表的是涂第0栋房屋,第0栋涂颜色i所花费最少的价格,从0就开始了
        for(int i=0;i<m;i++){
            dp[0][i]=costs[0][i];
        }
        j1=0;
        j2=0;
        for(int i=1;i<n;i++){
            min1 = Integer.MAX_VALUE;
            min2 = Integer.MAX_VALUE;
            for(int j=0;j<m;j++){
               //更新最小值和最小值下标
               if(dp[i-1][j]<min1){
                   min2=min1;
                   j2=j1;
                   min1=dp[i-1][j];
                   j1=j;
               }else{
                   //更新次小值和次小值下标
                   if(dp[i-1][j]<min2){
                       min2=dp[i-1][j];
                       j2=j;
                   }
               }
            }
            for(int j=0;j<m;j++){
                //当前颜色和上个颜色不一样,直接取最小值;一样就取次小值
                if(j!=j1){
                    dp[i][j]=dp[i-1][j1]+costs[i][j];
                }else{
                    dp[i][j]=dp[i-1][j2]+costs[i][j];
                }
            }
        }
        
        for(int i=0;i<m;i++){
            result = Math.min(dp[n-1][i],result);
        }
        
        return result;
    }

4.例3(LintCode 392 House Robber)

  • 题意
  • 有一排N栋房子(0-N-1)，房子i里有A[i]个金币,一个窃贼想选择一些房子偷金币,但是不能偷任何挨着的两家邻居，否则会被警察逮住,问最多能偷多少金币
  • 例子
    • 输入A={3,8,4}
    • 输出:8(只能偷第二家的金币)
A.确定状态
  • 最后一步：窃贼的最优策略中，有可能偷或者不偷最后一栋房子N-1
  • 情况1：不偷房子N-1(简单，最优策略就是前N-1栋房子的最优策略)
  • 情况2：偷房子N-1(仍然需要知道在前N-1栋房子中最多能偷多少金币，但是，需要保证不偷第N-2栋房子)
  • 如何知道在不偷房子N-2的前提下，在前N-1栋房子中最多能偷多少金币呢？
    • 用f[i][0]表示不偷房子i-1前提下，前i栋房子中最多能偷多少金币
    • 用f[i][1]表示偷房子i-1前提下，前i栋房子中最多能偷多少金币
B.转移方程
  • 设f[i][0]表示不偷房子i-1前提下，前i栋房子中最多能偷多少金币
  • 设f[i][1]表示偷房子i-1前提下，前i栋房子中最多能偷多少金币
  • f[i][0]=max(f[i-1][0],f[i-1][1]),因为不偷房子i-1，所以房子i-2可以选择偷或不偷
  • f[i][1]=f[i-1][0]+A[i-1],偷房子i-1，房子i-2必须不偷
  • 简化
  • 在不偷房子i-1前提下，前i栋房子中最多能偷多少金币
    • 其实这就是前i-1栋房子最多能偷多少金币
  • 所以我们可以简化前面的表示
  • 设f[i]为窃贼在前i栋房子最多偷多少金币
C.初始条件和边界情况
  • 设f[i]为窃贼在前i栋房子最多偷多少金币
  • f[i]=max{f[i-1],f[i-2]+A[i-1]}
  • 初始条件
    • f[0]=0(没有房子，偷0枚金币)
    • f[1]=A[0]
    • f[2]=max{A[0],A[1]}
  • 序列型动态规划好处…初始条件简单
D.计算顺序
  • 初始化f[0]
  • 计算f[1]、f[2]、…、f[n]
  • 答案f[n]
  • 时间复杂度O(N)，空间复杂度O(1)[可以开个长度为2的数组]
  • 可以用递归解，但是需要记忆化，开个数组
E.代码
 public long houseRobber(int[] A) {
         if(A==null||A.length==0){
              return 0;
          }
          long [] dp = new long[A.length+1];
          dp[0]=0;
          dp[1]=A[0];
          for(int i=2;i<=A.length;i++){
              dp[i]=Math.max(dp[i-1],dp[i-2]+A[i-1]);
          }
          return dp[A.length];
    }

5.例4(LintCode 534 House Robber II)

  • 题意
    有一圈N栋房子，房子i-1里有A[i]个金币，一个窃贼想选择一些房子偷金币，但是不能偷任何挨着的两家邻居，否则会被警察逮住，最多偷多少金币
  • 例子
    • 输入：A={3,8,4}
    • 输出:8(只偷房子1的金币)
A.思考
  • 这题和House Robber非常类似，只是房子现在排成一个圈
  • 于是房子0和房子N-1成了邻居，不能同时偷(用上道题做法，房子0偷没偷没有记录)
  • 要么没偷房子0,要么没偷房子N-1,我们可以枚举窃贼是没有偷房子0还是没有偷房子N-1
  • 情况1：没偷房子0(删掉0),最优策略就是窃贼对于房子1-N-1的最优策略->化为House Robber
  • 情况2：没偷房子N-1,最优策略就是窃贼对于房子0-N-2的最优策略->化为House Robber
  • 圈情况比序列复杂,但是，通过对于房子0和房子N-1不能同时偷原理，进行分情况处理,经过处理，变成序列情况,问题迎刃而解
一个爱浪费时间的人
关注
专栏目录
第二章、动态规划算法(2.5.1-2.5.2.3)------公共序列问题(上)
Python基础详解教程，让编程变得简单！
12-11 1117
文中主要讲述动态规划算法在公共序列问题的应用，主要包括最长公共子序列问题、不相交的线问题、最长公共连续子序列(最长公共子串)问题。
动态规划(Dynamic Programming)模式(4. 双序列型)
wangpu_baggio的博客
08-22 449
双序列型，顾名思义，就是有两个序列/字符串，需要进行一些操作。 每个序列是一维的。 可以转化成二维的动态规划。 经典题1： https://leetcode.com/problems/longest-common-subsequence/ 这样我们从最后一步考虑起，最后一个字符，它是否在最长公共子串中。 代码如下： public int longestCommonSubsequence(String text1, String text2) { int l
序列问题动态规划
09-16
序列问题的动态规划，包含最经典的最长上升序列的问题，非常好用哦！
【LeetCode256】粉刷房子
u011646912的博客
10-14 1253
1.题目描述 假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。 当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个n x 3的矩阵来表示的。 例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[...
序列类动态规划
qq_43109978的博客
01-26 167
相比矩阵类动态规划，序列类动态规划最大的不同在于，对于第 i 个位置的状态分析，它不仅仅需要考虑当前位置的状态，还需要考虑前面 i – 1 个位置的状态 最长上升子序列 解题思路： 问题拆解：求前n个数的最长子序列，可以先求前n-1个数的最长子序列的长度，但是这样不具有后效性（n用不上n-1的答案），可以求以n为终点的最长上升子序列的长度，这样n-1的问题解决了，n的问题也就解决了 ...
序列型动态规划
D_HSCheng的博客
07-28 470
序列型动态规划 1044 拦截导弹 1576 最长严格上升子序列 3027 线段覆盖
动态规划算法的c++实现 能实现两序列的比对
06-24
动态规划是一种重要的算法思想，广泛应用于计算机科学，特别是在序列比对这样的生物信息学问题中。在本项目中，我们关注的是使用C++编程语言实现动态规划算法，来比对两个蛋白质序列。C++是一种强大的、面向对象的...
动态规划(二)-坐标型动态规划
上千主上-贝库塔
10-29 1160
例1 给定m行n列的网格，有一个机器人从左上角(0,0)出发，每一步可以向下或者向右走一步 网格中有些地方有障碍，机器人不能通过障碍格 问有多少种不同的方式走到右下角 动态规划组成部分一：确定状态 这题和上章某题很像，只是网格中可能有障碍 最后一步一定是从左边(i,j-1)或上边(i-1,j)过来,这点是没有变的,变的只是多了障碍而已 状态f[i][j]表示从左上角有多少种方式走到格子(i,j)(坐标型动态规划基本都是：数组下标[i][j]即坐标(i,j)) 动态规划组成部分二：转移方程 f[i
LeetCode-[动态规划]-最小编辑距离
jswrcsdn1的博客
01-18 1102
并没有动态规划的基础，所以这里要补充自己理解的动态规划。分为三步： 什么是动态规划 理解这道题目，什么是最小编辑距离的算法 代码怎么写 1. 什么是动态规划 动态规划和递归关系密切，都是大问题转化成小问题。 但是有区别：递归有大量重复的步骤，而动态规划则将重复的步骤的结果记录下来，以后遇到重复的步骤就直接用结果而不重复执行步骤，这样就大量减少了时间复杂度。 1. 动态规划状态方程经常长这样 ...
动态规划解题模版：序列型
0xac001d09
01-17 467
序列型dp就是序列+状态，直接看几个例子。 1、LintCode 515 Paint House 【问题】这里有n个房子在一列直线上，现在我们需要给房屋染色，分别有红色蓝色和绿色。每个房屋染不同的颜色费用也不同，你需要设计一种染色方案使得相邻的房屋颜色不同，并且费用最小，返回最小的费用。费用通过一个nx3 的矩阵给出，比如cost[0][0]表示房屋0染红色的费用，cost[1][2]表示房屋1染...
动态规划-序列型动态规划
最新发布
Rory的博客
05-30 66
【代码】动态规划-回文串。
动态规划3 序列型动态规划
dipinrong5221的博客
09-14 209
序列型动态规划 动态规划dp[i]中的下标i表示前i个元素a[0],a[1],...,a[i-1]的某种性质 初始化中，dp[0]表示空序列的性质 坐标型动态规划的初始条件dp[0]就是指以a[0]为结尾的自子序列的性质 题目1：LintCode 516 Paint House II dp[i][1]....dp[i][k] ：尤其前i栋房子 并且i-1是颜...
动态规划 序列
weixin_44172372的博客
08-21 196
300 最长上升子序列 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 def lengthOfLIS(self, nums: List[int]) -> int: if not nums: return 0 n = len(nums) dp = [1 for i in range(n)] #dp[i] 所有元素置 1，含义是每个元素都至少可以单独成为子
序列类型动态规划——打家劫舍
sinat_40875078的博客
02-03 156
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。 示例1: 输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。 1、题目分析 根据题目的提
动态规划之--------基本时间序列型dp
ahelloyou的博客
06-11 456
基本时间序列型 文章目录基本时间序列型动态规划的特点那么什么是基本时间序列型特点套路[198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/)[213. 打家劫舍 II](https://leetcode-cn.com/problems/house-robber-ii/)[122. 买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)[
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值