LeetCode—动态规划

最新推荐文章于 2023-12-23 15:55:41 发布
最新推荐文章于 2023-12-23 15:55:41 发布
阅读量370 收藏
点赞数
分类专栏： leetcode刷题 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42589774/article/details/106872299
版权

LeetCode—动态规划

斐波那契数列
1、爬楼梯
T70. Climbing Stairs (Easy)
在这里插入图片描述

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return 1;
        vector<int> dp(n);
        dp[0] = 1; dp[1] = 2;
        for (int i = 2; i < n; ++i) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp.back();
        
    }
};

2、强盗抢劫
T198. House Robber (Easy)
在这里插入图片描述

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() <= 1) return nums.empty() ? 0 : nums[0];
        vector<int> dp = {nums[0], max(nums[0], nums[1])};
        for (int i = 2; i < nums.size(); ++i) {
            dp.push_back(max(nums[i] + dp[i - 2], dp[i - 1]));
        }
        return dp.back();

    }
};

3、强盗在环形街区抢劫
T213. House Robber II (Medium)
在这里插入图片描述

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() <= 1) return nums.empty() ? 0 : nums[0];
        return max(rob(nums, 0, nums.size() - 1), rob(nums, 1, nums.size()));
    }
    int rob(vector<int> &nums, int left, int right) {
        if (right - left <= 1) return nums[left];
        vector<int> dp(right, 0);
        dp[left] = nums[left];
        dp[left + 1] = max(nums[left], nums[left + 1]);
        for (int i = left + 2; i < right; ++i) {
            dp[i] = max(nums[i] + dp[i - 2], dp[i - 1]);
        }
        return dp.back();

    }
};

4、信件错排
在这里插入图片描述
5、母牛生产
程序员代码面试指南-P181

矩阵路径

1、矩阵的最小路径和
T64. Minimum Path Sum (Medium)
在这里插入图片描述

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

2、矩阵的总路径数
T62. Unique Paths (Medium)
在这里插入图片描述

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<int> dp(n, 1);
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                dp[j] += dp[j - 1]; 
            }
        }
        return dp[n - 1];
        
    }
};

数组区间

1、数组区间和
T303. Range Sum Query - Immutable (Easy)
在这里插入图片描述

class NumArray {
public:
    NumArray(vector<int> &nums) {
        dp = nums;
        for (int i = 1; i < nums.size(); ++i) {
            dp[i] += dp[i - 1];
        }
    }
    int sumRange(int i, int j) {
        return i == 0? dp[j] : dp[j] - dp[i - 1];
    }
private:
    vector<int> dp;
};

2、数组中等差递增子区间的个数
T413. Arithmetic Slices (Medium)
在这里插入图片描述

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) {
        int res = 0, len = 2, n = A.size();
        for (int i = 2; i < n; ++i) {
            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
                ++len;
            } else {
                if (len > 2) res += (len - 1) * (len - 2) * 0.5;
                len = 2;
            }
        }
        if (len > 2) res += (len - 1) * (len - 2) * 0.5;
        return res;

    }
};

分割整数

1、分割整数的最大乘积
T343. Integer Break (Medim)
在这里插入图片描述

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1, 1);
        for (int i = 3; i <= n; ++i) {
            for (int j = 1; j < i; ++j) {
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];

    }
};

2、按平方数来分割整数
T279. Perfect Squares(Medium)
在这里插入图片描述

class Solution {
public:
    int numSquares(int n) {
        vector<int> result(n+1, 0x7FFFFFFF); // 每个数的最优解都存在result数组里
    result[0] = 0;
    for (int i = 1; i <= n; i++){
        for(int j = 1; i-j*j >= 0 ; j++) {  // 观察比N小的数，且符合N = IxI + N'的数值
            result[i] = min(result[i], result[i-j*j] + 1); // 把最优解（最小值）+ 1 写入result
        }
    }
    return result[n];


    }
};

3、分割整数构成字母字符串
T91. Decode Ways (Medium)
在这里插入图片描述

class Solution {
public:
    int numDecodings(string s) {
        if (s.empty() || s[0] == '0') return 0;
        vector<int> dp(s.size() + 1, 0);
        dp[0] = 1;
        for (int i = 1; i < dp.size(); ++i) {
            dp[i] = (s[i - 1] == '0') ? 0 : dp[i - 1];
            if (i > 1 && (s[i - 2] == '1' || (s[i - 2] == '2' && s[i - 1] <= '6'))) {
                dp[i] += dp[i - 2];
            }
        }
        return dp.back();
        
    }
};

最长递增子序列

1、最长递增子序列
T300. Longest Increasing Subsequence (Medium)
在这里插入图片描述

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int res = 0;
        for (int i = 0; i < nums.size(); ++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;

    }
};

2、一组整数对能够构成的最长链
T646. Maximum Length of Pair Chain (Medium)
在这里插入图片描述

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        stack<vector<int>> st;
        sort(pairs.begin(), pairs.end(), [](vector<int>& a, vector<int>& b) {
            return a[1] < b[1];
        });
        for (auto pair : pairs) {
            if (st.empty()) st.push(pair);
            else {
                auto t = st.top();
                if (pair[0] > t[1]) st.push(pair);
            }
        }
        return st.size();

    }
};

3、最长摆动子序列
T376. Wiggle Subsequence (Medium)
在这里插入图片描述

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.empty()) return 0;
        vector<int> p(nums.size(), 1);
        vector<int> q(nums.size(), 1);
        for (int i = 1; i < nums.size(); ++i) {
            for (int j = 0; j < i; ++j) {
                if (nums[i] > nums[j]) p[i] = max(p[i], q[j] + 1);
                else if (nums[i] < nums[j]) q[i] = max(q[i], p[j] + 1);
            }
        }
        return max(p.back(), q.back());

    }
};

最长公共子序列

1、最长公共子序列
T1143. Longest Common Subsequence
在这里插入图片描述

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n=text1.size(),m=text2.size();
	int dp[m+1],last=0,temp;
	fill(dp,dp+m+1,0);
        for(int i=1;i<=n;++i,last=0){
		for(int j=1;j<=m;++j){
            	   temp=dp[j];
		   if(text1[i-1]==text2[j-1])	dp[j]=last+1; 
		   else	 dp[j]=max(dp[j],dp[j-1]);
        	   last=temp;
		}
        }
	return dp[m];

    }
};

0-1 背包

1、划分数组为和相等的两部分
T416. Partition Equal Subset Sum (Medium)
在这里插入图片描述

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0), target = sum >> 1;
        if (sum & 1) return false;
        vector<bool> dp(target + 1, false);
        dp[0] = true;
        for (int num : nums) {
            for (int i = target; i >= num; --i) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[target];

    }
};

2、改变一组数的正负号使得它们的和为一给定数
T494. Target Sum (Medium)
在这里插入图片描述

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int res = 0;
        helper(nums, S, 0, res);
        return res;
    }
    void helper(vector<int>& nums, long S, int start, int& res) {
        if (start >= nums.size()) {
            if (S == 0) ++res;
            return;
        }
        helper(nums, S - nums[start], start + 1, res);
        helper(nums, S + nums[start], start + 1, res);

    }
};

3、01 字符构成最多的字符串
T474. Ones and Zeroes (Medium)
在这里插入图片描述

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (string str : strs) {
            int zeros = 0, ones = 0;
            for (char c : str) (c == '0') ? ++zeros : ++ones;
            for (int i = m; i >= zeros; --i) {
                for (int j = n; j >= ones; --j) {
                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1);
                }
            }
        }
        return dp[m][n];

    }
};

4、找零钱的最少硬币数
T322. Coin Change (Medium)
在这里插入图片描述

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
         vector<int> dp(amount + 1, amount + 1);
        dp[0] = 0;
        for (int i = 1; i <= amount; ++i) {
            for (int j = 0; j < coins.size(); ++j) {
                if (coins[j] <= i) {
                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        return (dp[amount] > amount) ? -1 : dp[amount];

    }
};

5、找零钱的硬币数组合
T518. Coin Change 2 (Medium)
在这里插入图片描述

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<vector<int>> dp(coins.size() + 1, vector<int>(amount + 1, 0));
        dp[0][0] = 1;
        for (int i = 1; i <= coins.size(); ++i) {
            dp[i][0] = 1;
            for (int j = 1; j <= amount; ++j) {
                dp[i][j] = dp[i - 1][j] + (j >= coins[i - 1] ? dp[i][j - coins[i - 1]] : 0);
            }
        }
        return dp[coins.size()][amount];

    }
};

6、字符串按单词列表分割
T139. Word Break (Medium)
在这里插入图片描述

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size() + 1);
        dp[0] = true;
        for (int i = 0; i < dp.size(); ++i) {
            for (int j = 0; j < i; ++j) {
                if (dp[j] && wordSet.count(s.substr(j, i - j))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp.back();

    }
};

7、组合总和
T377. Combination Sum IV (Medium)
在这里插入图片描述

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1, 0);
    dp[0] = 1;
    for (int i = 0; i <= target; i++) {
        for (int j = 0; j < nums.size(); j++) {
            if (i < nums[j]) continue;
            dp[i] = (dp[i] >= INT_MAX - dp[i - nums[j]]) ? INT_MAX : dp[i] + dp[i - nums[j]];
        }
    }
    return dp[target];

    }
};

股票交易

1、需要冷却期的股票交易
T309. Best Time to Buy and Sell Stock with Cooldown(Medium)
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int buy = INT_MIN, pre_buy = 0, sell = 0, pre_sell = 0;
        for (int price : prices) {
            pre_buy = buy;
            buy = max(pre_sell - price, pre_buy);
            pre_sell = sell;
            sell = max(pre_buy + price, pre_sell);
        }
        return sell;

    }
};

2、需要交易费用的股票交易
T714. Best Time to Buy and Sell Stock with Transaction Fee (Medium)
在这里插入图片描述

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

    }
};

3、只能进行两次的股票交易
T123. Best Time to Buy and Sell Stock III (Hard)
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
                if(prices.size()==0) return 0;
        int *dp=new int[prices.size()];
        int *dp_2=new int[prices.size()];
        int ans=0;
        left(prices,dp);
        right(prices,dp_2);
        for(int i=0;i<prices.size();i++)
            ans=max(ans,dp[i]+dp_2[i]);
        return ans;

    }

    void left( vector<int> prices, int *&dp)
    {
        int ans=0;
        int low=prices[0];
        for(int i=0;i<prices.size();i++)
        {
            ans=max(ans,prices[i]-low);
            dp[i]=ans;
            low=min(low,prices[i]);
        }
    }
    void right(vector<int> prices,int *&dp)
    {
        int ans=0;
        int high=prices[prices.size()-1];
        for(int i=prices.size()-1;i>=0;i--)
        {
            ans=max(ans,high-prices[i]);
            dp[i]=ans;
            high=max(high,prices[i]);
        }
    }

};

4、只能进行 k 次的股票交易
T188. Best Time to Buy and Sell Stock IV (Hard)
在这里插入图片描述

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        //std::vector<std::pair<int, int>> dp(k+1, {-prices[0], 0});
        // 这里有一个隐藏很深的 bug, 就如果 k 的值很大, 就会直接把栈爆掉!!
        // 所以应该按照 k 值做优化, 将 vector 声明在 if 语句内部
        if (k < prices.size() / 2)  {
                std::vector<std::pair<int, int>> dp(k+1, {-prices[0], 0});
                for(int i=1;i<prices.size();i++)
                {
                    for(int j=1; j < k+1; j++)
                    {
                        int hold = std::max(dp[j].first, dp[j-1].second-prices[i]);
                        int not_hold = std::max(dp[j].second, dp[j].first+prices[i]);
                        dp[j].first = hold; dp[j].second = not_hold;
                    }
                }
            return dp[k].second; //max(dp[k].first, dp[k].second);
        } else  {
            std::pair<int, int> dp = {-prices[0], 0};
            for (int i=1; i<prices.size(); i++) {
                int hold = std::max(dp.first, dp.second-prices[i]);
                int not_hold = std::max(dp.second, dp.first+prices[i]);
                dp.first = hold; dp.second = not_hold;
            }
            return dp.second;
        }
    }

    
};

字符串编辑

1、删除两个字符串的字符使它们相等
T583. Delete Operation for Two Strings (Medium)
在这里插入图片描述

class Solution {
public:
    int minDistance(string word1, string word2) {
         int n1 = word1.size(), n2 = word2.size();
        vector<vector<int>> dp(n1 + 1, vector<int>(n2 + 1, 0));
        for (int i = 1; i <= n1; ++i) {
            for (int j = 1; j <= n2; ++j) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return n1 + n2 - 2 * dp[n1][n2];

    }
};

2、编辑距离
T72. Edit Distance (Hard)
在这里插入图片描述

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

3、复制粘贴字符
T650. 2 Keys Keyboard (Medium)
在这里插入图片描述

class Solution {
public:
    int minSteps(int n) {
        if (n == 1) return 0;
        int res = n;
        for (int i = n - 1; i > 1; --i) {
            if (n % i == 0) {
                res = min(res, minSteps(n / i) + i);
            }
        }
        return res;

    }
};
purple 桐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode之动态规划
weixin_47414034的博客
06-23 1845
以爬楼梯问题为例，总结动态规划的步骤：第一步：定义dp数组（可能时一维数组，也可能是二维数组），这一步需要确定两个问题：（1）dp[i]或者dp[i][j]是什么含义（比如在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法）（2）到底开多大的空间，你搞懂了第一个问题dp[i]或者dp[i][j]是什么含义，就知道到底要开多大的空间了，由于在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法，你最后求的是到达第n层所需要的爬法数，所以最后要返回的是dp[n]，所以显然要开n+1大小的数组，这样才能有dp[n
leetcode动态规划
qq_43283527的博客
04-16 654
最优子结构 子问题最优问题可导出原问题最优决策 无后效性 重叠子问题 去冗余 空间换时间 基本步骤： 设计暴力算法，找到冗余 设计并储存状态 递归式（状态转移方程） 自底向上计算最优解（编程方式） 例题： 983. 最低票价 在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 ...
leetcode系列-动态规划
dafeng_xiaobai的博客
06-01 400
动态规划 509-斐波那契数 斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给你n ，请计算 F(n) 。 动规五部曲： 这里我们要用一个一维dp数组来保存递归的结果 确定dp数组以及下标的含义 dp[i]的定义为：第i个数的斐波那契数值是dp[i] 确定递推公式 为什么这是一道非常简单的入
动态规划之第一日
MrZhuangzhipeng的博客
03-19 365
动态规划题目满足下面三个条件之一： 求最优值，即最大值，最小值 判断是否可行 dp[i][j]=true/false; 统计方案 dp[i][j]=状态数 则极有可能性用到动态规划 而如果是要求具体的方案，而不可能使用动态规划。 题目1：三角形最小路径和 https://leetcode-cn.com/problems/triangle/ 1.DFS做法 2.分治做...
Leetcode 64.最小路径和（动态规划）（动态数组解决）
2302_76866243的博客
04-23 359
在？进来看看这道题会不会
leetcode动态规划总结-leetcode-summary-c-plus-plus:LeetCode问题总结
07-01
leetcode动态规划总结Leetcode 总结 C++ 用 C++ 编写的 LeetCode 问题摘要。 请查看更多信息。 对于 Python 版本，请检查 . 对于 Java 版本，请检查 . 带*号的题号，表示本题与原题不同。 基本数据结构 - 广度优先...
leetcode dp-1
02-09
本资源摘要信息是关于leetcode动态规划算法-1的知识点总结，该算法解决的问题是寻找一个长度为N的数字串，使用K个乘号将其分成K+1个部分，使得这K+1个部分的乘积能够为最大。 动态规划算法是通过将问题拆分成多个子...
asshead123#my-leetcode#动态规划-53. 最大子序和1
07-25
示例 2：输出：1示例 3：输出：0示例 4：输出：-1示例 5：输出：-100000提示：进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的
linzeliang1222#LeetCode#Day34-动态规划系列1
07-25
70. 爬楼梯思路1（数学公式）利用斐波那契数列的公式即可代码public int climbStairs(int n) {复杂度分析时间复杂度：$O(logN
mio4#Leetcode#646-【动态规划】最长数链对1
07-25
① 首先按照pairs[i][0] 升序排列② 从前往后寻找，dp[i] 表示以i个元素结束的最长子串的大小。
【LeetCode刷题笔记】动态规划（一）
最新发布
川峰的博客
12-23 1179
LeetCode刷题笔记之动态规划篇（一）。
【蓝桥杯】最难算法没有之一· 动态规划真的这么好理解？（引入）
热门推荐
安然无虞的博客
12-19 3万+
【前言】 在学习动态规划之前，我们必须要先掌握记忆化搜索和递推，这两块东西搞好了之后，面对动态规划那就容易多啦！好，接下来向铁汁们详细介绍这两块内容，走着。 一、记忆化搜索 提问： 何为记忆化搜索？ 回答： 顾名思义，记忆化搜索肯定也就和“搜索”脱不了关系了，前面的DFS和BFS想必大家都已经掌握的差不多了，它们有个最大的弊病就是：低效！原因在于没有很好地处理重叠子问题。那么对于记忆化搜索呢，它虽然采用搜索的形式，但是它还有动态规划里面递推的思想，巧就巧在它将这两种方法很好的综合在了.
leetcode学习 动态规划
weixin_44133327的博客
08-24 155
动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解 法。 主要思想 若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解以得出原问题的解。动 态规划往往用于优化递归问题，例如斐波那契数列，如果运用递归的方式来求解会重复计算很多相同的 子问题，利用动态规划的思想可以减少计算量。 动态规划法仅仅解决每个子问题一次，具有天然剪枝的功能，从而减少计算量， 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 动态规划模板
leetcode动态规划系列
风源-
11-16 422
斐波那契数列 1. 爬楼梯 2. 强盗抢劫 3. 强盗在环形街区抢劫 4. 信件错排 5. 母牛生产 矩阵路径 1. 矩阵的最小路径和 2. 矩阵的总路径数 数组区间 1. 数组区间和 2. 数组中等差递增子区间的个数 分割整数 1. 分割整数的最大乘积 2. 按平方数来分割整数 3. 分割整数构成字母字符串 最长递增子序列 1. 最长递增子序列 2. 一组整数对能够构成的最长链 3. 最长摆动子序列 最长公共子序列 1. 最长公共子序列 0-1 背包 1. 划分数组.
LeetCode总结，动态规划问题小结
EbowTang的练习场
03-04 9533
一，参考一般书籍中的“动态规划”讲解 1、基本概念 动态规划（Dynamic Programming）对于子问题重叠的情况特别有效，因为它将子问题的解保存在表格中，当需要某个子问题的解时，直接取值即可，从而避免重复计算！ 动态规划是一种灵活的方法，不存在一种万能的动态规划算法可以解决各类最优化问题（每种算法都有它的缺陷）。所以除了要对基本概念和方法正确理解外，必须具体问题具体分析处理，用
Leetcode-动态规划
thxiong1234的博客
09-04 523
leetcode5-最长回文子串 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。 算法设计： 遍历字符串s，以当前点i为中点向两端遍历；记录中心点i的回文字符串左右标记l，r；计算长度更新长度大于以前遍历的l，r端点；遍历完后返回s[l:r]. 源代码： def longestPalindrome(self, s):         """    ...
Leetcode动态规划练习
li123_123_的博客
12-08 663
动态规划算法的设计步骤： 刻画最优解的结构特征（寻找最优子结构） 递归地定义最优解的值（确定递归公式，动态规划法的重点就是这个） 计算最优解的值（有两种方法：带备忘录自顶向下法、自底向上法） 利用计算出的信息构造一个最优解（通常是将具体的最优解输出） 动态规划进阶——————&amp;gt; 文章目录动态规划算法的设计步骤：Best Time to Buy and Sell StockBest T...
Leetcode：动态规划学习
平凡
05-01 714
记录最近在Leetcode上做DP题目时碰到的感觉让我学到东西的题。 1、Shortest Path Visiting All Nodes(847) 题目描述： An undirected, connected graph of N nodes (labeled0, 1, 2, ..., N-1) is given as graph. graph.length = N, and j...
Leetcode——字符构成最多的字符串
caisongcheng_good的博客
07-22 835
题目描述：在计算机界中，我们总是追求用有限的资源获取最大的收益。现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。 解题思路： 这相当于是一个多维费用背包，也就是不仅要考虑背包所能容纳的重量，还要考虑背包的体积 ...
深度解析LeetCode动态规划题目
【资源摘要信息】: "本文主要介绍在LeetCode上通过动态规划解题的方法，包括基础概念、经典问题以及空间优化策略。" 动态规划是一种解决复杂问题的有效算法，它通过将问题分解为更小的子问题，并存储子问题的解来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值