dpdpdp

已于 2023-07-24 14:43:08 修改
阅读量232 收藏
点赞数
分类专栏： 动态规划 文章标签： 算法 数据结构 leetcode
于 2023-07-23 22:07:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51070956/article/details/131882700
版权

这里写目录标题

139. 单词拆分

class Solution {
public:
    const int N=305;
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> dp(N,false);
        set<string> S;
        S.clear();
        for(int i=0;i<wordDict.size();i++){
            S.insert(wordDict[i]);
        }
        dp[0]=true;
        int n=s.size();
        for(int i=1;i<=n;i++){//从头开始长度为i的子串
            for(int j=0;j<i;j++){
                if(dp[j]){
                    string str=s.substr(j,i-1-(j-1));//0123
                    if(S.find(str)!=S.end()){
                        dp[i]=true;
                    }
                }
            }
            
        }
        return dp[n];
    }
};

322. 零钱兑换

class Solution {
public:
    const int inf=0x3f3f3f3f;
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,inf);
        // dp[i]表示凑出金额i最少需要的硬币个数
        dp[0]=0;
        int n=coins.size();
        for(int i=1;i<=amount;i++){
            for(int j=0;j<n;j++){
                if(i>=coins[j]){
                    dp[i]=min(dp[i],dp[i-coins[j]]+1);
                }
            }
        }
        if(dp[amount]==inf)return -1;
        else return dp[amount];
    }
};

恰好装满型完全背包

class Solution {
public:
    const int inf=0x3f3f3f3f;
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,inf);
        // dp[i]表示凑出金额i最少需要的硬币个数
        dp[0]=0;
        int n=coins.size();
         for(int j=0;j<n;j++){
            for(int i=coins[j];i<=amount;i++){

                if(i>=coins[j]){
                    dp[i]=min(dp[i],dp[i-coins[j]]+1);
                }
            }
        }
        if(dp[amount]==inf)return -1;
        else return dp[amount];
    }
};

300. 最长递增子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        vector<int> dp(n+5,1);
        // dp[0]=0;
        int res=1;
        for(int i=0;i<n;i++){//i是上升子序列最后一个元素的下标
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    dp[i]=max(dp[i],dp[j]+1);
                    res=max(res,dp[i]);
                }
                
            }
        }
        return res;
    }
};

贪心思想，碰到小的元素，尽可能放在前面
最后得到的最长上升子序列，假设存储在d数组中，d数组的演变过程：
来了个更大的元素（大于d[len]), 直接插入在末尾
如果小，找到大于nums[i] 的第一个元素，替换掉

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        vector<int> d(n+5,1);
        int len=0;
        d[len]=nums[0];
        for(int i=1;i<n;i++){
            if(nums[i]>d[len]){
                d[++len]=nums[i];
            }
            else{//找到第一个大于nums[i]的d[k] 换掉
                int l=0,r=len;
                while(l<r){
                    int mid=(l+r)/2;
                    // if(d[mid]>nums[i])r=mid;
                    // else l=mid+1;找最大
                    // if(d[mid]<nums[i])r=mid;
                    // else l=mid+1;
                    if(d[mid]<nums[i])l=mid+1;
                    else r=mid;
                }
                d[l]=nums[i];
            }
        }
        return len+1;
    }
};

lower_bound,找到大于等于nums[i]的第一个元素

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        vector<int> d;

        for(int i=0;i<n;i++){
vector<int>::iterator it =lower_bound(d.begin() , d.end() ,nums[i]);
if(it==d.end())d.push_back(nums[i]);
else
 swap(*it,nums[i]);
        }
        return d.size();
    }
};

120. 三角形最小路径和

倒三角形，注意下标

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int m=triangle.size();
        // int n=triangle[0].size();
        vector<vector<int> > dp(m,vector<int>(m,0));
        dp[0][0]=triangle[0][0];
        // int res=0x3f3f3f3f;
       int res=2e6+10;
        for(int i=1;i<m;i++){
           
            for(int j=0;j<=i;j++){
                 if(j==0)dp[i][j]=dp[i-1][j]+triangle[i][j];
                 else if(j==i)dp[i][j]=dp[i-1][j-1]+triangle[i][j];
                else dp[i][j]=min(dp[i-1][j-1],dp[i-1][j])+triangle[i][j];
                // if(i==m-1)res=min(res,dp[i][j]);怎么放在这儿就不行了why not？？？？？？
            }
            
        }
        //  res=*min_element(dp[m-1].begin(),dp[m-1].end());
    //    res=min(2000010,-10);
    for(int i=0;i<m;i++)res=min(res,dp[m-1][i]);
    return res;
    }
};

64. 最小路径和

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        dp[0][0]=grid[0][0];
        for(int j=1;j<n;j++)dp[0][j]=dp[0][j-1]+grid[0][j];
        for(int i=1;i<m;i++){
            for(int j=0;j<n;j++){
                if(j==0)dp[i][j]=dp[i-1][j]+grid[i][j];
                else dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

63. 不同路径 II

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        if(!obstacleGrid[0][0])dp[0][0]=1;
        for(int i=1;i<n;i++)if(!obstacleGrid[0][i])dp[0][i]=dp[0][i-1];
        for(int i=1;i<m;i++){
            for(int j=0;j<n;j++){
                if(!obstacleGrid[i][j])
                {
                    if(j==0)dp[i][j]=dp[i-1][j];
                    else dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
};

5. 最长回文子串（回文dp）⭐

class Solution {
public:
    string longestPalindrome(string s) {
        int L=s.size();
        vector<vector<bool> > dp(L+1,vector<bool>(L+1,false));
        int maxlen=1;
        int pos=0;
        for(int len=1;len<=L;len++){
            for(int i=0;i+len-1<L;i++){
                int j=i+len-1;
                // dp[i][j]这段是否为回文串
                if(len==1)dp[i][j]=true;
                else{
                    if(s[i]==s[j]){
                        if(len==2||len==3){
                        dp[i][j]=true;
                        }
                        else {
                        dp[i][j]=dp[i+1][j-1];
                        }
                    }
                }
               if(dp[i][j]){
                   if(len>maxlen){
                       maxlen=len;
                       pos=i;
                   }
               } 
            }
        }
        // return s.substr(pos,maxlen);
        string res;
        for(int len=1;len<=L;len++){
            for(int i=0;i+len-1<L;i++){
                int j=i+len-1;
                if(dp[i][j])res=s.substr(i,len);
            }
        }
        return res;
    }
};

class Solution {
public:
    string longestPalindrome(string s) {
        int L=s.size();
        vector<vector<bool> > dp(L+1,vector<bool>(L+1,false));
        for(int i=0;i<L;i++)dp[i][i]=true;
        int pos=0;
        int maxlen=1;
        for(int len=2;len<=L;len++){
            for(int i=0;i+len-1<L;i++){
                int j=i+len-1;
                // dp[i][j]这段是否为回文串
                
               
                    if(s[i]==s[j]){
                        if(len==2||len==3){
                        dp[i][j]=true;
                        }
                        else {
                        dp[i][j]=dp[i+1][j-1];
                        }
                    }
               
               if(dp[i][j]){
                   maxlen=len;
                   pos=i;
               } 
            }
        }
        return s.substr(pos,maxlen);
        // string res;
        // for(int len=1;len<=L;len++){
        //     for(int i=0;i<L;i++){
        //         int j=i+len-1;
        //         if(dp[i][j])res=s.substr(i,len);
        //     }
        // }
        // return res;
    }
};

97. 交错字符串⭐（抽象成路径问题）

s1s2交错组成s3，把s1s2抽象为横纵坐标，s3抽象为向右向下的路径

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int m=s1.size();
        int n=s2.size();
        if(m+n!=s3.size())return false;// "" ,"" ,"a"
        vector <vector<bool> > dp(m+1,vector<bool>(n+1,false));
        // 一些最基础的子问题的初始化处理
        dp[0][0]=true;
        for(int len=1;len<=m;len++){
            if(s1[len-1]==s3[len-1])dp[len][0]=true;
            else break;
        }
        for(int len=1;len<=n;len++){
            if(s2[len-1]==s3[len-1])dp[0][len]=true;
            else break;
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                // dp[len1][len2] 
                // dp[len1-1][len2] s1[len1-1]==s3[len1+len2-1]
                if(s1[i-1]==s3[i+j-1])dp[i][j]=dp[i-1][j];
                if(s2[j-1]==s3[i+j-1])dp[i][j]=dp[i][j]||dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

221. 最大正方形⭐

本来应该用三维dp表示（正方形右下角的横纵坐标，第三维为 以该坐标为右下角的所有全1正方形边长），即dp[i][j][k]表示 以 （i,j）为右下角，边长为k的正方形是否存在
dp思想，是否存在由子问题的解递推而来，如果dp[i-1][j][k-1]，dp[i][j-1][k-1]，dp[i-1][j-1][k-1]三者都为true，则dp[i][j][k]为true

思路来呀
在这里插入图片描述

可以优化为两维，dp[i][j]的值为int型，表示 以该坐标为右下角的所有全1正方形之中最大的边长
比如 边长为3的全1正方形区域，那么它一定包含了一个边长为2和边长为1的全1正方形区域。所以，我们只需记录以(i, j)为右下角的区域包含的最大全1正方形边长即可，这个最大边长也即以(i , j)为右下角的全1正方形的个数

class Solution {
public:
const int N=305;
    int maximalSquare(vector<vector<char>>& matrix) {
        int m=matrix.size();
        int n=matrix[0].size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        // vector<vector<vector<bool>>> dp(N,vector<vector<bool>>(N,vector<bool>(N,false)));
        int mx=0;
        for(int i=0;i<m;i++)if(matrix[i][0]=='1')dp[i][0]=1,mx=1;
        for(int i=0;i<n;i++)if(matrix[0][i]=='1')dp[0][i]=1,mx=1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(matrix[i][j]=='1'){
                    dp[i][j]=min(min(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1])+1;
                mx=max(mx,dp[i][j]);

                }
            }
        }
        return mx*mx;
    }
};
Selvaggia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划解法汇总
qq_43556545的博客
04-10 271
1.最长子串 自己一开始想的建一个int[] res;res[i]代表以第i个字符开头的字符串的最长字串长度，但是写起来其实就是暴力搜索，最后超时了。 题解： 状态定义： 设动态规划列表 dp ，dp[j] 代表以字符 s[j]为结尾的 “最长不重复子字符串” 的长度。 转移方程： 固定右边界 j ，即字符串一定包含字符s[j]，设字符 s[j] 左边距离最近的相同字符为 s[i] ，即 s[i] = s[j]。 当 i < 0 ，即 s[j] 左边无相同字符，则 dp[j] = dp[j-1]
java动态规划
weixin_40540942的博客
05-15 2097
存在若干步骤，并且每个步骤都面临若干选择。如果要求列出所有解就是回溯法。如果是求最优解（通常是最大值最小值）就用动态规划。1.波契那亚数列和爬楼梯2.背包问题3.打家劫舍4.股票问题5.子序列问题。
vue考试DPDPDP
qq_55970659的博客
04-23 179
小组链接：http://groupweb.chaoxing.com/pc/topic/topiclist/index?模拟测试：product.html。实验五：ai_one.html。模拟测试：input.html。实验五：two.html。
饭卡 HDU - 2546 DPDPDP背包
云乐
10-24 321
电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。 Input 多组数据。对于每组数据： 第一行为正整数n，表示...
hdu2059 dpdpdp玄学5555~~
all00747的博客
03-25 145
龟兔赛跑 Time Limit: 1000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 18501Accepted Submission(s): 6882 Problem Description 据说在很久很久以前，可怜的兔子经历了人生中最大...
Codeforces 1072B Curiosity Has No Limits【dpdpdp】
Yucohny
10-24 184
f[i][j]f[i][j]f[i][j]表示已讨论完[1,i][1,i][1,i]内的数并且第iii位为jjj是否有合法的情况。 转移枚举一下第iii维与第i−1i-1i−1维的jjj就好了。 最后输出路径就转移的时候记录一下然后递归输出： #include &lt;cmath&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #inclu...
W
weixin_43823476的博客
07-26 170
题目 题目描述 题目描述 给定正整数n,将其表示为n=a_1+a_2+...+a_m,其中a_i的绝对值为2的非负整数幂(即a_i=1,-1,2,-2,4,-4or so) 求最小的m 输入格式 输入 一个正整数n,以二进制形式给出 输出格式 输出 一个正整数m 样例 样例输入 1000111011 样例输出 4 数据范围与提示 数据范围 对于10%的数据,n的长度&lt...
【运筹学】对偶理论 : 总结 ( 对偶理论 | 原问题与对偶问题对应关系 | 对偶理论的相关结论 ) ★★★
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-02 4万+
一、对偶理论 、 1、对称性定理 、 2、弱对偶定理 、 3、最优性定理 、 4、强对偶性 、 5、互补松弛定理 、 二、原问题与对偶问题对应关系 、 二、对偶理论的相关结论 、 1、对偶问题存在 、 2、对偶问题转化 、 3、对偶问题的解 、 4、互补松弛定理
动态规划（Dynamic Programming，DP）
sosososoon的博客
08-24 562
动态规划 动态规划适用于有重叠子问题和最优子结构性质的问题，动态规划方法所消耗的时间往往远少于朴素解法。 主要思想 动态规划算法通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。 动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题，按顺序求解子问题，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解
CodeCraft-20 (Div. 2) E.Team Building
01-03
思路：考虑状压dpdpdp，f[i][j]f[i][j]f[i][j]表示到第iii个人时的第jjj个状态的最大能力,状态表示每个位置被选与否。 那么转移时只需要考虑两个地方： 1.前i−1i-1i−1个人是否选满了kkk个观众 2.在jjj状态下还有...
「AHOI / HNOI2018」毒瘤 （DDP）（链分治）
01-07
题解：首先考虑一棵树怎么做，就是树形 dpdpdp，然后我们可以枚举每一条边怎么选，显然有 3 种情况 进一步发现只需要枚举两种，即强制 uuu 选 vvv 不选，和强制 uuu 不选 vvv 随意 那么现在的问题就是每次 banbanban...
36. Adam 算法详解
最新发布
qq_41238579的博客
07-10 645
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
D1.排序
2302_79232710的博客
07-07 177
快速排序和归并排序
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 296
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【排序 - 堆排序】
2302_80393814的博客
07-10 261
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1234
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 1022
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 672
单调队列（自定义一种队列规则）使用场景1.
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 904
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值