动态规划（dp）（二）

最新推荐文章于 2024-07-04 16:16:29 发布
置顶 最新推荐文章于 2024-07-04 16:16:29 发布
阅读量1.3k 收藏 15
点赞数 52
文章标签： dp 动态规划 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79108642/article/details/138323754
版权

按摩师

 按摩师

1.状态表示

dp【i】表示：到i位置时，此时最长时长

继续细化：在i位置选预约，或不选预约

f【i】：到i位置时，nums【i】必选的，最长时长

g【i】：到i位置时，nums【i】不选的，最长时长

2状态转移方程

f【i】=g【i-1】+nums【i】

g【i】=max(f【i-1】，g【i-1】）

3初始化

f【0】=nums【0】

g【0】=0

4.填表顺序

左往右

5.返回值

max（f【n-1】，g【n-1】）

class Solution {
public:
    int massage(vector<int>& nums) {
        int n=nums.size();
        if(n==0)
            return 0;
        vector<int>f(n);
        vector<int>g(n);
        f[0]=nums[0];
        for(int i=1;i<n;i++)
        {
            f[i]=g[i-1]+nums[i];
            g[i]=max(f[i-1],g[i-1]);
        }
        return max(f[n-1],g[n-1]);

    }
};

打家劫舍

198. 打家劫舍

 1.dp表示：

f【i】：表示到i位置时，必偷i位置房屋，获得的最大金额

g【i】：表示到i位置时，不偷i位置房屋，获得的最大金额

f【i】=g【i-1】+nums【i】

g【i】=max（f【i-1】,g【i-1】）

f【0】=nums【0】

返回值

max（f【n-1】，g【n-1】）

class Solution {
public:
    int rob(vector<int>& nums) {
        int n =nums.size();
        vector<int>f(n);
        vector<int>g(n);
        f[0]=nums[0];

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

打家劫舍 II

213. 打家劫舍 II

环形问题转化

分情况偷0下标的和不偷0下标的

当偷【0】时，转化为打家劫舍一：从【2，n-2】的打家劫舍

不偷【0】，转化为从【1，n-1】的打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        if(n==1)
            return nums[0];
        else if(n==2)
            return max(nums[0],nums[1]);
        else if(n==3)
            return max(max(nums[0],nums[1]),nums[2]);
        int a=nums[0]+_rob(nums,2,n-2);
        int b=_rob(nums,1,n-1);
        return max(a,b);
    }
    int _rob(vector<int>&nums,int left,int right)
    {
        int n=nums.size();
        vector<int>f(n);
        vector<int>g(n);

        f[left]=nums[left];
        for(int i=left+1;i<=right;i++)
        {
            f[i]=g[i-1]+nums[i];
            g[i]=max(g[i-1],f[i-1]);
        }
        return max(f[right],g[right]);
    }
};

删除并获得点数

740. 删除并获得点数

 转换为打家劫舍问题

用一个arr数组：arr【i】表示i出现的总和


class Solution {
public:
    const int N=10001;
    int deleteAndEarn(vector<int>& nums) 
    {
        int n=nums.size();
        vector<int>arr(N);
        for(int v:nums)
        {
            arr[v]+=v;
        }
        vector<int>f(N);
        vector<int>g(N);

        for(int i=1;i<N;i++)
        {
            f[i]=g[i-1]+arr[i];
            g[i]=max(g[i-1],f[i-1]);
        }
        return max(f[N-1],g[N-1]);
    }
};

粉刷房子

LCR 091. 粉刷房子

dp【i】位置分三种状态，

分别时刷红，蓝，绿

用dp【i】【0，1，2】分别表示到第i位置时，刷红蓝绿的成本

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n=costs.size();
        vector<vector<int>>dp(n,vector<int>(3));
        dp[0][0]=costs[0][0];
        dp[0][1]=costs[0][1];
        dp[0][2]=costs[0][2];
        for(int i=1;i<n;i++)
        {
            dp[i][0]=min(dp[i-1][1],dp[i-1][2])+costs[i][0];
            dp[i][1]=min(dp[i-1][0],dp[i-1][2])+costs[i][1];
            dp[i][2]=min(dp[i-1][1],dp[i-1][0])+costs[i][2];
        }
        return min(dp[n-1][2],min(dp[n-1][0],dp[n-1][1]));
    }
};

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

买卖股票的最佳时机含冷冻期

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

​

状态转移：

状态机：可买（可交易）dp【0】，可卖（买入）dp【1】，冷冻期dp【2】

dp【i】【0】=max（dp【i-1】【0】，dp【i-1】【2】）

dp【i】【1】=max（dp【i-1】【0】-costs【i】，dp【i-1】【1】）

dp【i】【2】=dp【i-1】【1】+costs【i】

初始化

dp【0】【0】=0

dp【0】【1】=-cost【0】

dp【0】【2】=0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        vector<vector<int>>dp(n,vector<int>(3));
        dp[0][1]=-prices[0];
        for(int i=1;i<n;i++)
        {
            dp[i][0]=max(dp[i-1][0],dp[i-1][2]);
            dp[i][1]=max(dp[i-1][0]-prices[i],dp[i-1][1]);
            dp[i][2]=dp[i-1][1]+prices[i];
        }
        return max(dp[n-1][0],dp[n-1][2]);
    }
};

买卖股票的最佳时机含手续费

714. 买卖股票的最佳时机含手续费

dp【i】【0】可买

dp【i】【1】可卖

dp【i】【0】=max（dp【i-1】【0】，dp【i-1】【1】+prices【i】-fee）

dp【i】【1】=max（dp【i-1】【1】，dp【i-1】【0】-prices【i】）

dp【0】【0】=0

dp【0】【1】=-prices【0】

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) 
    {
        int n=prices.size();
        vector<vector<int>>dp(n,vector<int>(3));
        dp[0][1]=-prices[0];
        for(int i=1;i<n;i++)
        {
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]-fee);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);
        }
        return dp[n-1][0];
    }
};

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

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

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

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

dp【i】【0】可买

dp【i】【1】可卖

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】）

dp【0】【0】=0

dp【0】【1】=-prices【0】

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n=prices.size();
        vector<vector<int>>dp(n,vector<int>(2));
        dp[0][1]=-prices[0];
        for(int i=1;i<n;i++)
        {
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
            dp[i][1]=max(dp[i-1][0]-prices[i],dp[i-1][1]);
        }
        return dp[n-1][0];
    }
};

121. 买卖股票的最佳时机

53. 最大子数组和

53. 最大子数组和

dp【i】：以i位置为结尾的所有子数组最大和

fen为长度为1和不为1的

dp【i】=max（dp【i-1】+nums【i】，nums【i】）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        vector<int>dp(n);
        dp[0]=nums[0];
        for(int i=1;i<n;i++)
        {
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
        }
        int ret=INT_MIN;
        for(int i=0;i<n;i++)
        {
            ret=max(ret,dp[i]);
        }
        return ret;
    }
};

918. 环形子数组的最大和

918. 环形子数组的最大和

借鉴环形打家劫舍

转化为非环形

f【i】：以i位置为结尾的所有子数组最大和

g【i】：以i位置为结尾的所有子数组最小和

返回 f【i】和sum-g【i】中最大的

注意：当全为负数时 f【i】为负

sum-g【i】为0，会返回0 这是错误的结果

class Solution {
public:
    int maxSubarraySumCircular(vector<int>& nums) {
        int n=nums.size();
        vector<int>f(n);
        vector<int>g(n);
        f[0]=nums[0];
        g[0]=nums[0];
        int sum=0;
        for(int i=1;i<n;i++)
        {
            f[i]=max(f[i-1]+nums[i],nums[i]);
            g[i]=min(g[i-1]+nums[i],nums[i]);
        }
        for(auto v:nums)
        {
            sum+=v;
        }
        int Max=f[0];
        
        for(int i=1;i<n;i++)
        {
            if(i==n-1&&sum-g[i]==0)
            {
                if(Max<f[i])
                    Max=f[i];
                break;
            }
            if(Max<f[i])
                Max=f[i];
            if(Max<(sum-g[i]))
                Max=sum-g[i];
        }
        return Max;
    }
};

乘积最大子数组

乘积最大子数组

f【i】以i为结尾的乘积最大的子数组

g【i】以i为结尾的乘积最小的子数组

f【i】=

1.nums【i】

2.

乘积要分类 nums【i】》0，要与f【i-1】相乘

nums【i】《0，要与g【i-1】相乘

f【i】=max（nums【i】，f【i-1】*nums【i】，g【i-1】*nums【i】）

g【i】=min（nums【i】，f【i-1】*nums【i】，g【i-1】*nums【i】）

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n=nums.size();
        vector<vector<int>>dp(n,vector<int>(2));
        dp[0][0]=nums[0];
        dp[0][1]=nums[0];
        int Max=INT_MIN;
        for(int i=1;i<n;i++)
        {
            dp[i][0]=max(dp[i-1][0]*nums[i],max(nums[i],dp[i-1][1]*nums[i]));
            dp[i][1]=min(dp[i-1][1]*nums[i],min(nums[i],dp[i-1][0]*nums[i]));
            
        }
        for(int i=0;i<n;i++)
        {
            Max=Max>dp[i][0]?Max:dp[i][0];
        }
        return Max;
    }
};

乘积为正数的最长子数组长度

乘积为正数的最长子数组长度

f【i】以i为结尾乘积为正数的最长子数组长度

g【i】以i为结尾乘积为负数数的最长子数组长度

分类

1.nums【i】==0 f【i】==0

2.nums【i】<0

f【i】=g【i-1】+1   

要单独判断f【i-1】=0

g【i】=f【i-1】+1

2.nums【i】>0

要单独判断g【i-1】=0

 f【i】=f【i-1】+1   

g【i】=g【i-1】+1

class Solution {
public:
    int getMaxLen(vector<int>& nums) {
        int n=nums.size();
        vector<vector<int>>dp(n+1,vector<int>(2));
        dp[0][0]=0;
        dp[0][1]=-1;
        int Max=0;
        for(int i=1;i<=n;i++)
            if(nums[i-1]==0)
                dp[i][0]=dp[i][1]=0;
            else if(nums[i-1]<0)
            {
                if(dp[i-1][1]==0)
                    dp[i][0]=0;
                else
                    dp[i][0]=dp[i-1][1]+1;
                dp[i][1]=dp[i-1][0]+1;
            }
            else
            {
                dp[i][0]=dp[i-1][0]+1;
                if(dp[i-1][1]==0)
                    dp[i][1]=0;
                else
                    dp[i][1]= dp[i-1][1]+1;
            }
        for(int i=1;i<=n;i++)
            Max=Max>dp[i][0]?Max:dp[i][0];
        return Max;
    }
};

等差数列划分

等差数列划分

dp【i】以i位置为结尾的能构成等差数列的个数

dp【i】

1.nums【i】+nums【i-2】=nums【i-1】*2

dp【i】=1+dp【i-1】

2

dp【i】=0

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n=nums.size();
        vector<int>dp(n);
        if(n==1||n==2)
            return 0;
        dp[0]=dp[1]=0;
        for(int i=2;i<n;i++)
        {
            if(nums[i]+nums[i-2]==2*nums[i-1])
                dp[i]=1+dp[i-1];
            else
                dp[i]=0;
        }
        int sum=0;
        for(int i=0;i<n;i++)
        {
            sum+=dp[i];
        }
        return sum;
    }
};

最长湍流子数组

最长湍流子数组

f【i】表示以i为结尾的最长湍流子数组 且i位置为小

g【i】表示以i为结尾的最长湍流子数组 且i位置为大

f【i】=g【i】=1

if（nums【i-1】> nums【i】）

        f【i】=1+g【i-1】

else if （nums【i-1】<nums【i】）

        g【i】=1+f【i-1】

else 

        f【i】=g【i】=1

class Solution {
public:
    int maxTurbulenceSize(vector<int>& arr) {
        int n=arr.size();
        vector<int>f(n);
        vector<int>g(n);
        f[0]=g[0]=1;
        int Max=INT_MIN;
        for(int i=1;i<n;i++)
        {
            if(arr[i-1]>arr[i])
            {
                f[i]=g[i-1]+1;
                g[i]=1;
            }
            else if(arr[i-1]<arr[i])
            {
                g[i]=f[i-1]+1;
                f[i]=1;
            }
            else
            {
                f[i]=g[i]=1;
            }
            
        }
        for(int i=0;i<n;i++)
        {
            Max=Max>f[i]?Max:f[i];
            Max=Max>g[i]?Max:g[i];
        }
        return Max;
    }
};

momomh1
关注
  • 52
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划——区间dp [石子合并]
小天狼星_布莱克 的博客
07-06 2347
动态规划（dp）是一种通过将问题分解为子问题，并利用已解决的子问题的解来求解原问题的方法。适用于具有重叠子问题和最优子结构性质的优化问题。通过定义状态和状态转移方程，动态规划可以在避免重复计算的同时找到问题的最优解，是一种高效的求解方法，常用于解决各种问题，如最短路径、背包问题、序列比对等。区间dp是一种dp的应用，用于解决涉及区间的问题。它将问题划分为若干个子区间，并通过定义状态和状态转移方程来求解每个子区间的最优解，最终得到整个区间的最优解。
动态规划DP资料
09-25
动态规划（Dynamic Programming，简称DP）是计算机科学中一种强大的算法思想，主要应用于解决最优化问题，通过将复杂问题分解成子问题来求解。它在编程竞赛（如ACM/ICPC）和实际工程中都有广泛的应用。下面将详细...
动态规划DP算法理解
m0_55369183的博客
01-05 2172
每次决策依赖于当前状态，又随即引起状态的转移，多阶段最优化决策解决问题的过程就称为动态规划。
动态规划入门（九） 区间DP
热门推荐
Hello World!
05-03 5万+
顾名思义，区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。
算法套路十三——动态规划DP入门
Pistachiout的学习博客
04-27 1265
动态规划和递归都是通过将大问题分解为较小的子问题来解决问题。它们都可以用来解决具有重叠子问题和最优子结构特性的问题。在很多情况下，。
动态规划（DP）算法
smilejiasmile的博客
09-16 1298
动态规划是求解决策过程最优化的数学方法。利用各个阶段之间的关系，逐个求解，最终求得全局最优解，需要确认原问题与子问题、动态规划状态、边界状态、边界状态结值、状态转移方程。 以下每个例题，注意分析迭代关系是怎么找到的。 一、爬楼梯leetcode70: You are climbing a stair case. It takesnsteps to reach to the top. Each time you can either climb 1 or 2 steps. In how ma...
动态规划（DP）小结
qq_51165184的博客
03-14 1925
动态规划（DP）小结： 例题一：数字三角形 例题二：最长上升子序列 例题三：最长公共子序列 例题四：合唱队形 例题五：数塔问题
动态规划-二维dp数组和滚动数组
ZiYueShengXian的博客
08-31 2392
二维数组 如上图,一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ 看到这道题,查找从A点到B点的路径,如果对图论比较熟悉的话,可能第一印象是用图论的深度优先搜索来实现. func dfs(i int, j int, m int, n int) int { if i > m || j > n { return 0
★动态规划（DP算法）详解
qq_17807067的博客
04-25 2万+
动态规划（DP算法）详解
动态规划——数位dp
qq_57150526的博客
01-05 4067
数位是指把一个数字按照个、十、百、千等等一位一位地拆开，关注它每一位上的数字。如果拆的是十进制数，那么每一位数字都是 0~9，其他进制可类比十进制。
动态规划之线性DP详解
晨的博客
09-08 1754
动态规划之线性DP
dp.rar_动态规划
09-23
LCS问题可以通过二维数组进行动态规划求解。 3. 最短路径问题：例如Dijkstra算法和Floyd-Warshall算法，它们可以用于求解图中两点之间的最短路径或所有对最短路径，通过动态规划的思想避免了回溯。 4. 编辑距离：...
DP_立体匹配_动态规划算法_dp算法_
09-30
在本场景中，我们关注的是使用动态规划算法（DP算法）实现的立体匹配方法。动态规划是一种优化技术，常用于解决具有重叠子问题和最优子结构的问题，它通过构建一个表格来存储中间结果，避免了重复计算。 立体匹配的...
DP_practise_动态规划_
10-01
这个名为“DP_practise”的压缩包文件显然包含了动态规划算法的一些实践案例，包括钢条切割问题和图像变位压缩问题。让我们深入探讨这两个问题及其解决方案。 首先，我们来看钢条切割问题。这是一个经典的动态规划...
动态规划算法 DP
08-05
基本动态规划算法总结 最长子序列探索 （最长非降子序列 + 最长公共子序列 最优路径搜索 （ 点数值三角形的最优路径搜索 +边数值矩形的最优路径搜索） 装载问题 0−1背包问题 二维0−1背包问题 插入乘号问题
c++习题08-计算星期几
码到成龚的博客
07-03 574
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 614
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c语言----队列
最新发布
2302_80318761的博客
07-04 1025
好了，上面就是关于队列的大部分使用方法了。当然还有很多对于这个的延伸，这就可能会用在后面的题目上。后面的面试题之类的。那可以多尝试一下练题，然后就能加深一下对队列的一些的相关知识的巩固。那么接下来来我就这样所有的代码给大家看一下。}QueueNode;}Queue;assert(pq);assert(pq);free(cur);cur = next;assert(pq);exit(-1);else。
关键路径——C语言（理论）
2302_80790488的博客
06-28 846
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
动态规划创建dp数组大小
07-25
动态规划中创建dp数组的大小取决于问题的特性和所需的状态数量。一般来说，dp数组的大小取决于问题的输入规模。 例如，对于一个长度为n的数组，如果我们只需要存储每个位置的最大值，那么dp数组的大小可以设为n。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值