动态规划之--------基本时间序列型dp

最新推荐文章于 2022-09-12 13:55:32 发布
最新推荐文章于 2022-09-12 13:55:32 发布
阅读量436 收藏 1
点赞数
分类专栏： 算法 leetcode刷题之旅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ahelloyou/article/details/117815839
版权

基本时间序列型

文章目录

动态规划的特点

  • 无后效性
1.一旦dp(i,j)确定，就不用关心“我们如何计算出dp(i,j)”。
想要确定dp(i,j)，只需要知道dp(i-1,j)和f(i,j-1)的值，而至于它们
是如何算出来的，对当前或之后的任何子问题都没有影响。
“过去不依赖将来，将来不影响过去” ——智巅语录

关键就是过去不依赖将来，将来不影响过去

  • 最优子结构

dp(i,j)的定义就已经蕴含了“最优”。
大问题的最优解可以由若干个小问题的最优解推出。(max,min, sum…)

那么什么是基本时间序列型

特点

给出一个序列(数组/字符串)，其中每一个元素认为是“一天”，并且“今天的状态”只取决于昨天的状态

也就是可以用0代表操作后的一个状态，1代表另一个操作后的状态，…以此类推

重点在于归纳出这些状态的表达

套路

● 定义dp[i][j]：表示第i-th轮的第j种状态 (j=1,2,...,K)
● 千方百计将dp[i][j]与前一轮的状态dp[i-1][j]产生关系(j=1,2,...,K)
● 最终的结果是dp[last][j]中的某种aggregation (sum, max, min …)

状态的设计，有关于的词语就是有行使某种权利的能力

198. 打家劫舍

难度中等1488

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

class Solution {
public:
    int rob(vector<int>& nums) {
        // 时间序列型dp问题
        // 特点就是，只和上一轮有关系。
        // 选择 0：不偷  1： 偷
        // 所以定义dp就是 dp[i][j]就是第i轮选择为j的时候偷取到的最高的金额

        /* 
            定义状态转移方式
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]);
            dp[i][1] = max(dp[i-1][0]+nums[i])

            初始化
            dp[0][0]=0;
            dp[0][1] = nums[0]

         */

         vector<vector<int>> dp(nums.size(),vector<int>(2,0));
         dp[0][1] = nums[0];

         for(int i=1;i<nums.size();i++) {
           dp[i][0] = max(dp[i-1][0],dp[i-1][1]);
           dp[i][1] = dp[i-1][0]+nums[i];
         }


         return max(dp[nums.size()-1][0],dp[nums.size()-1][1]);



    }
};
213. 打家劫舍 II

难度中等691

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [0]
输出：0

class Solution {
public:
    int rob(vector<int>& nums) {
     
        if(nums.size()<2) {
            return nums[0];
        }
        // 第一间房子不抢
        vector<vector<int>> dp1(nums.size(),vector<int>(2,0));

        for(int i=1;i<nums.size();i++) {
            dp1[i][0]=max(dp1[i-1][0],dp1[i-1][1]);
            dp1[i][1]=dp1[i-1][0]+nums[i];
        }

        // 最后一间房子不抢
         vector<vector<int>> dp2(nums.size(),vector<int>(2,0));

         for(int i=1;i<nums.size();i++) {
            dp2[i][0]=max(dp2[i-1][0],dp2[i-1][1]);
            dp2[i][1]=dp2[i-1][0]+nums[i-1];
        }

        return max(dp1[nums.size()-1][0],max(dp1[nums.size()-1][1],max(dp2[nums.size()-1][0],dp2[nums.size()-1][1])));



    }
};
122. 买卖股票的最佳时机 II

难度简单1244

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution {
public:
   int maxProfit(vector<int>& prices) {
       /* 
           分析： 首先看看能不能满足最优子结构和无后效性
           最优子结构: dp[i][0]: 代表第i轮手里还有股票的时候最优的解
           dp[i][1]: 代表的是手里没有股票时候的最优解，所以满足最优子结构

           而且
           第i轮的营收值取决于i-1轮不影响后面的。 这也就是，现在取决于过去但不影响将来
        */

        vector<vector<int>> dp(prices.size(),vector<int>(2,0));
        // 初始化

        dp[0][0]=0;
        dp[0][1]=-prices[0];
       
       for(int i=1;i<prices.size();i++) {
           dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]);
           dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]);
       }

       return dp[prices.size()-1][0];


   }
};
123. 买卖股票的最佳时机 III

难度困难793

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

输入：prices = [7,6,4,3,1] 
输出：0 
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        /* 
            分析和买卖股票II是一样的就不多累赘了
            唯一的区别就是状态
            0: 手上有第一支股票获得的最大利润
            1： 手上卖完第一支股票无股票状态的最大利润
            2： 手上有股票状态，买入第二支股票最大利润
            3 ： 手上无股票，卖了第二只股票后获得的最大利润
         */


        vector<vector<int>> dp(prices.size(),vector<int>(4,INT_MIN));

        // 初始化
        dp[0][0]=-prices[0];
        dp[0][1] = 0;
        
        for(int i=1 ; i<prices.size();i++) {
            dp[i][0] = max(dp[i-1][0],-prices[i]);
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            dp[i][2] = max(dp[i-1][1]-prices[i],dp[i-1][2]);
            dp[i][3] = max(dp[i-1][2]+prices[i],dp[i-1][3]);
        }
        // for(auto a : dp) {
        //     for(auto b :a) {
        //         cout<<b<<" ";
        //     }
        //     cout<<endl;

        // }

        return max(dp[prices.size()-1][1],dp[prices.size()-1][3]);
 


    }
};
188. 买卖股票的最佳时机 IV

难度困难523

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        // 定义了一系列的状态
        // 0: 有股票,第1轮交易
        // 1: 无股票，第一轮交易后
        // 2: 有股票，第2轮交易
        // 3: 无股票,第二轮交易后
        // .......
        if(prices.empty()) {
            return 0;
        }

        vector<vector<int>> dp(prices.size(),vector<int>(k*2,0));

        // 初始化
        for(int i=0;i<k;i++) {
            dp[0][i*2]=-prices[0];
        }
        // cout<<"start"<<endl;

        for(int i=1;i<prices.size();i++) {
            for(int j=0;j<2*k;j++) {
                if(j%2==0) { // 这时候这一轮手上是有股票的
                    if(j==0) {
                        dp[i][j]=max(dp[i-1][j],-prices[i]);
                    } else {
                        dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]-prices[i]);
                    }
                } else {  // 这时候手里是没有股票的
                    dp[i][j]= max(dp[i-1][j],dp[i-1][j-1]+prices[i]);
                }
            }
        }

        // for(auto a: dp) {
        //     for(auto b : a) {
        //         cout<<b<<" ";
        //     }

        //     cout<<endl;
        // }
        // // cout<<"a"<<endl;
        int res=0;
        for(int i=0;i<k;i++) {
            res= max(res,dp[prices.size()-1][i*2+1]);
        }
        return res;



    }
};
309. 最佳买卖股票时机含冷冻期

难度中等791

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

  • 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
  • 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:

输入: [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // 这也是一个基本时间序列型号dp
        /* 
            最优子结构: dp[i][j] 代表第i天，状态为j的最大收益
            无后效性  ： 现在只依赖过去的i-1天而且还不会影响将来

            所以关键就在与寻找到这几种状态
            0: 手里有股票的准柜台
            1: 手里没有股票在冷冻期的状态
            2： 手里没有股票不在冷冻期的状态

         */


         vector<vector<int>> dp(prices.size(),vector<int>(3,0));
         

         // 初始化
         dp[0][0] = -prices[0];
         
         for(int i=1;i<prices.size();i++) {
            dp[i][0] = max(dp[i-1][0],dp[i-1][2]-prices[i]);
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            dp[i][2]=dp[i-1][1];
         }

        //  for(auto a : dp) {
        //      for(auto b:a) {
        //          cout<<b<<" ";
        //      }
        //      cout<<endl;
        //  }

         return max(dp[prices.size()-1][1],dp[prices.size()-1][2]);

    }
};
黑猫爱小鹿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
为什么时序差分是动态规划和蒙特卡罗的结合
海晨威
06-11 2693
动态规划的优势：在已知状态转换概率和回报函数的情况下，不需要与环境的交互，直接通过策略迭代或值迭代方法得到最优策略。 动态规划的劣势：但实际情况下，环境的状态转换概率通常是未知的，因此该方法并不实际可行。 动态规划分析：虽然动态规划并不实际可行，但重要的是它的思想：用空间换时间，存储每个状态的值函数（也就是Q表），并利用后继状态的值函数估计当前值函数，这样就实现了单步更新，提升了更新的效率，也...
【LeetCode256】粉刷房子
u011646912的博客
10-14 1213
1.题目描述 假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。 当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个n x 3的矩阵来表示的。 例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[...
动态规划-时间规整算法
guomutian911的专栏
01-22 6405
DTW(Dynamic Time Warping,动态时间归整)算法,该算法基于动态规划(DP)的思想,解决了发音长短不一的模板匹配问题,是语音识别中出现较早、较为经典的一种算法。
动态时间归整/规整/弯曲(Dynamic time warping,DTW)
热门推荐
Hencoff的专栏
06-12 1万+
http://blog.sina.com.cn/s/blog_4b700c4c0102e1gz.html 动态时间规整DTW   在日常的生活中我们最经常使用的距离毫无疑问应该是欧式距离，但是对于一些特殊情况，欧氏距离存在着其很明显的缺陷，比如说时间序列，举个比较简单的例子，序列A：1,1,1,10,2,3，序列B：1,1,1,2,10,3，如果用欧氏距离，也就是
时间分配（dp）
_Alexander的博客
11-24 626
一共有n个房子，每个房子里面住着一个人，分别是库特鸽鸽的n个迷妹。每天只有k的空闲时间。 特别地，对于迷妹i（1<=i<=n），库特鸽鸽花费的时间必须在0到a[i]（包括0和a[i]）之间。 求恰好花费k时间陪n个迷妹的方案数是多少。 （答案对1e9 + 7取余） 第一行两个整数n，k (1<=n<=100, 0<=k<=100000) 第二行n个整数 a[i...
leetcode-problem-solution:你好 ！ 在这里，您可以找到使用cpp或java语言的Leetcode Judge问题的解决方案代码。 您还可以在此处找到比赛时间解决方案代码。 快乐编码
04-09
8. **动态规划（Dynamic Programming）**：DP是解决问题的一种策略，通过将问题分解成子问题来求解，常用于最长公共子序列、背包问题等。 9. **数据结构（Data Structure）**：除了链表，还有树、栈、队列、哈希表...
算法-BOJ：白ek算法
02-18
3. **动态规划（DP）**：通过构建状态转移方程来解决最优化问题，如斐波那契数列、背包问题、最长公共子序列等。 4. **贪心算法**：局部最优解可以导出全局最优解的问题，例如霍夫曼编码、Prim's最小生成树算法等。...
0-1-knapsack-problem-master (35)c.zip
最新发布
01-07
代码结构一般包括初始化dp表、输入物品信息、执行动态规划算法以及输出结果等部分。 通过这样的实现，我们可以对机械臂的轨迹规划进行优化，例如，可以将每个动作视为一个物品，动作的价值可能是完成任务所需的时间...
大小写金额转换-源码
02-23
{-------------------------------------------------------------------- 货币数字转为为中文大写的组件 Version 1.31 by SNAKEJIAO 2003.4.13简介: 可以转化整数，浮点数，及时间日期型数据 配合别名列表可以进行...
DP.rar_againstriy
09-19
1. 序列型动态规划：如最长递增子序列、最长公共子序列等，问题与序列元素的顺序紧密相关。 2. 平面型动态规划：如二维背包问题，问题涉及二维区域的决策。 3. 树形动态规划：如树的直径问题，问题涉及树结构的最优...
序列类型动态规划——打家劫舍
sinat_40875078的博客
02-03 147
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。 示例1: 输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。 1、题目分析 根据题目的提
Displayport 连接、握手时序
ColorFilter
07-06 9515
一、连接时序 （1）HPD 当Sink准备好之后，HPD会给到Source，指示有Sink插入 （2）读取EDID EDID用来表示Sink能够显示的画面的能力、参数等等，通过Aux通道进行读取 如图所示，其中包含显示器的制造商、EDID版本、显示器的尺寸、支持的色彩空间、分辨率等 （3）Link Training（DPCD） 确认链路的参数，如lane的数目、链接速...
序列型动规模板
aquz77529的博客
04-22 84
最长上升子序列(lis) 1.O(n^2) 1 #include<cstdio> 2 #include<algorithm> 3 using std :: max; 4 5 const int maxn=100005; 6 int a[maxn],dp[maxn],pre[maxn]; 7 int n; 8 ...
动态规划——投资问题
Xiongcanne的博客
04-01 571
问题描述： 有m元钱，n项投资，f[i][x]代表将x元投入到第i个项目中的收益，求最大的收益 输入：第一行为总钱数m和总项目数n；接下来为n行输入，每行m+1个，第i行第j个代表f[i][j] 分析： 我们假设一个二维函数F[i][j]代表j元钱投资前i个项目所获得的最大收益，那么F[i][j]=max{F[i-1][j-xk]+f[i][xk]}//xk取值从0到j。 所以我们就得到了动态规划...
RQNOJ 140 分配时间：dp
a1392136的博客
09-01 334
题目链接：https://www.rqnoj.cn/problem/140 题意： 　　小王参加的考试是几门科目的试卷放在一起考，一共给t分钟来做。 　　他现在已经知道第i门科目花k分钟可以拿到w[i][k]分。 　　写名字需要的时间为name（他写自己的名字很慢） 　　如果放弃某一门的考试（花的时间为0），那么名字也就不用写了。 　　问他最高能得几分。 题解： 　...
经典的序列dp问题
ComingLiu的博客
09-12 153
序列dp
双序列型动态规划例题讲解
Mitsuily的博客
02-24 424
顾名思义，有两个序列/字符串，需要进行一些操作。   Longest Common Subsequence，最长公共子序列，求长度。最后一步，观察A[m-1]和B[n-1]最后这两个字符是否作为一个对子在最优策略中，（都不作为对子出现的情况包含在情况一和情况二中了）由此便可以很好的得到子问题的分解，状态和转移方程如下 ：                    初始条件和边界...
【DP入门】动态规划初步-几类子序列问题
Chen_yuazzy的博客
08-06 1060
动态规划初步—子序列问题，本文包括：最大连续子序列和，最大(长)上升子序列，最大(长)公共子序列1.最大连续子序列和找出一维数组中和最大的连续子序列，状态转移方程如下： sum=max(a[i]+sum,a[i]);sum = max(a[i]+sum , a[i] );例题：HDU 1003-Max Sum(最大连续子序列和)注：此题由于要输出和最大序列的起始位置和终止位置，形式与上列公式有所出
动态规划二丶坐标型，序列型
weixin_42030357的博客
09-29 385
文章目录1.坐标型动态规划：2.序列型动态规划： 1.坐标型动态规划： public int uniquePathsWithObstacles(int[][] A){ int m = A.length; //表示行数 if(m==0){ return 0; } int n =A[0].length;//...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值