刷题：动态规划

已于 2024-03-18 21:47:28 修改
阅读量38 收藏
点赞数
分类专栏： 代码随想录 文章标签： 动态规划 算法
于 2024-03-15 09:35:07 首次发布
原文链接：https://programmercarl.com/0096.%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html#%E6%80%9D%E8%B7%AF
版权

0. 理论基础：

1. 动规五部曲：

  1. 确定dp数组（dp table）以及下标的含义
  2. 确定递推公式
  3. dp数组如何初始化
  4. 确定遍历顺序
  5. 举例推导dp数组

2. 如何debug：

  • 这道题目我举例推导状态转移公式了么？
  • 我打印dp数组的日志了么？
  • 打印出来了dp数组和我想的一样么？

1. 斐波那契数：

1. 代码：

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

尝试30天速成算法竞赛 - Name-eee的文章 - 知乎
https://zhuanlan.zhihu.com/p/687486067

大家都是如何刷 LeetCode 的？ - 草原上唱山歌的回答 - 知乎
https://www.zhihu.com/question/280279208/answer/3431849087

2. 爬楼梯：

1. 代码：

// 版本一
class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n; // 因为下面直接对dp[2]操作了，防止空指针
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

3. 使用最小花费爬楼梯：

 1. dp[i]：到第i阶最少花费；

2. 代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1);
        dp[0] = 0; // 默认第一步都是不花费体力的
        dp[1] = 0;
        for (int i = 2; i <= cost.size(); i++) {
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[cost.size()];
    }
};

4. 不同路径：

        dp[i][j]：到i，j格的路径数；

1. 代码：

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

5. 不同路径 II：

        如果vector[i][j]有障碍，dp[i][j]就为0；

        起点或终点有障碍，直接返回0；

1. 代码：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
	if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

6. 整数拆分：

1. 代码：

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

2. 代码（贪心）：

class Solution {
public:
    int integerBreak(int n) {
        if (n == 2) return 1;
        if (n == 3) return 2;
        if (n == 4) return 4;
        int result = 1;
        while (n > 4) {
            result *= 3;
            n -= 3;
        }
        result *= n;
        return result;
    }
};

        证明：

        拆分数里面只有2和3时乘积才能最大，且三要达到最多；

7.  不同的二叉搜索树：

1. 思路：

dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量

2. 代码：

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

8. 背包问题基础：

1. 0-1背包：

         1. 例子：

        

        2. 思路：

                dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

                递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

                初始化：

                

                先遍历谁就是先锁谁；

        3. 代码：

void test_2_wei_bag_problem1() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagweight = 4;

    // 二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
            if (j < weight[i]) dp[i][j] = dp[i - 1][j];
            else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

        }
    }

    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    test_2_wei_bag_problem1();
}

        4. 二维dp数组转一维dp数组：

                i-1行的数据可以拷贝到第i行；

                dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

                递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

        5. 遍历物品再遍历背包；遍历背包从后向前

                没搞懂为什么二维的没问题一维确有问题；

        6. 代码：

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    // 初始化
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}

2. 完全背包：

        1. 例子：

        

        2. 先背包再物品（无所谓）正序遍历；

        3. 代码：

// 先遍历物品，在遍历背包
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}

9. 分割等和子集：

1. 思路：

  • 背包的体积为sum / 2
  • 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
  • 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
  • 背包中每一个元素是不可重复放入。

        dp[j]：背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。

        判断当j=target时，装满了没有；

2. 代码：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;

        // dp[i]中的i表示背包内总和
        // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) {
            for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和target
        if (dp[target] == target) return true;
        return false;
    }
};

10. 最后一块石头的重量II：

1. 代码：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001, 0);
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) sum += stones[i];
        int target = sum / 2;
        for (int i = 0; i < stones.size(); i++) { // 遍历物品
            for (int j = target; j >= stones[i]; j--) { // 遍历背包
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
};

11. 目标和：

        1. 思路：

                分成两个集合，差值为3；

                a+b=sum；a-b=3；求出a就是target；

                dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法

                

        2. 代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(S) > sum) return 0; // 此时没有方案
        if ((S + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (S + sum) / 2;
        vector<int> dp(bagSize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};

12. 一和零：

1. 思路：

        二维0-1背包；

2. 代码：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0)); // 默认初始化0
        for (string str : strs) { // 遍历物品
            int oneNum = 0, zeroNum = 0;
            for (char c : str) {
                if (c == '0') zeroNum++;
                else oneNum++;
            }
            for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
};

13. 零钱兑换II：

1. 思路：

        完全背包+方法数搜集；

        如果求组合数就是外层for循环遍历物品，内层for遍历背包。

        如果求排列数就是外层for遍历背包，内层for循环遍历物品。

        先物品后背包：比如1,2；那么先把1放进来，遍历一遍背包，然后才放2，再遍历背包；

        先背包后物品：背包容量扩大，但是物品会遍历，有排列；

2. 代码： 

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

14. 组合总和Ⅳ：

1. 代码：

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] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

 C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。

15. 最长回文子串：

1. 思路：

        dp[i][j]：i到j个字母组成的是回文串；

        转移方程：dp(i,j)=dp(i+1,j−1)∧(Si​==Sj​)

        边界条件：

        

2. 代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if(n < 2) return s;
        // 记录最大长度
        int maxLen = 1;
        // 记录取字符串的头index
        int begin = 0;
        vector<vector<bool>> dp(n, vector<bool> (n));

        for(int i = 0; i < n; i++){
            dp[i][i] = true;
        }

        for(int L = 2; L <= n; L++){
            for(int i = 0; i < n; i++){
                int j = L + (i - 1);
                if(j >= n) break;

                if(s[i] != s[j]){
                    dp[i][j] = false;
                }else{
                    if(j - i == 1){
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }
                if(dp[i][j] == true && j - i + 1 > maxLen){
                    maxLen = j - i + 1;
                    begin = i;
                }

            }
        }
        return s.substr(begin, maxLen);
    }
};

3. 思路：

        每一个dp都是由唯一的边界条件转移得到；

        边界条件：长度为1或2的子串；

4. 中心扩散：

class Solution {
public:
    pair<int, int> expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return {left + 1, right - 1};
    }

    string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.size(); ++i) {
            auto [left1, right1] = expandAroundCenter(s, i, i);
            auto [left2, right2] = expandAroundCenter(s, i, i + 1);
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
            }
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
            }
        }
        return s.substr(start, end - start + 1);
    }
};

class Solution {
public:
    pair<int, int> Expand(const string& s, int left, int right){
        while(left >= 0 && right < s.size() && s[left] == s[right]){
            left--;
            right++;
        }
        return {left + 1, right - 1};
    }
    string longestPalindrome(string s) {
        
        int start = 0;
        int end = 0;
        for(int i = 0; i < s.size(); i++){
            auto [left1, right1] = Expand(s, i, i);
            auto [left2, right2] = Expand(s, i, i + 1);
            if(right1 - left1 > end -start){
                start = left1;
                end = right1;
            }
            if(right2 - left2 > end -start){
                start = left2;
                end = right2;
            }            
        }
        return s.substr(start, end - start + 1);
    }
};

16. 爬楼梯（进阶版）：

1. 思路：

        完全背包问题：容量n，物品m；

2. 代码：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, m;
    while (cin >> n >> m) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) { // 遍历背包
            for (int j = 1; j <= m; j++) { // 遍历物品
                if (i - j >= 0) dp[i] += dp[i - j];
            }
        }
        cout << dp[n] << endl;
    }
}

17. 零钱兑换：

1. 思路：

        完全背包问题：顺序无所谓；

        dp[i]：amount为i时最少金币数；

2. 代码：

// 版本一
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]是初始值则跳过
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

        

18. 完全平方数：

1. 代码：

// 版本一
class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i <= n; i++) { // 遍历背包
            for (int j = 1; j * j <= i; j++) { // 遍历物品
                dp[i] = min(dp[i - j * j] + 1, dp[i]);
            }
        }
        return dp[n];
    }
};

19. 单词拆分：

1. 代码：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        int n = s.size();
        vector<bool> dp(n + 1, false);
        dp[0] = true;
        // 求组合数
        for(int i = 1; i <= n; i++){
            for(int j = 0; j <= i; j++){
                string s1 = s.substr(j, i - j);
                if(wordSet.find(s1) != wordSet.end() && dp[j]){
                    dp[i] = true;
                }
            }
        }
        return dp[n];
    }
};

 记得转成集合；

LiBeraIism
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python：刷题笔记：动态规划专题一
TEDxPY
05-19 432
今天翻看了关于时间复杂度、空间复杂度的文章和视频，对其认知加深了些，之后也要养成分析复杂度的习惯，顺手添加，大家如果看到我写错的还望予以纠正。 同时，今儿还遇到句值得反思的话：“珍惜你所遇见的每一道题”。目前刷题 41 天，LeetCode 上题目刷了 80 道。但如果让我重新再做，应该有不少题目还是搞不定，甚至会出现之前做出来、现在看却没思路的情况。此外，之前有些简单题目是利用 Python 取巧通关，绕开了题目本身关联的算法设计，使得做题纯粹变成了做任务，白白浪费练习算法、加深理解的机会。 所以，认真对
leetcode刷题之动态规划
11-13
leetcode刷题之动态规划 动态规划是leetcode刷题中的一种常见的算法思想，它通过将问题分解成小问题，解决小问题，然后将小问题的答案组合起来，解决原来的问题。动态规划的核心思想是将问题分解成小问题，然后将小...
leetcode刷题：动态规划
weixin_50835854的博客
03-27 735
系列文章目录 leetcode刷题：第一周 leetcode刷题：第二周 leetcode刷题：二分查找 leetcode刷题：双指针 leetcode刷题：广度/深度优先搜索 leetcode刷题：递归 / 回溯 leetcode刷题：动态规划 文章目录系列文章目录前言动态规划1.打家劫舍 II2.跳跃游戏3.跳跃游戏 II4.不同路径5.最长回文子串6.等差数列划分7.解码方法8.单词拆分9.最长递增子序列10.最长递增子序列的个数11.最长公共子序列12.两个字符串的删除操作13.编辑距离14.零钱
leetcode刷题：动态规划：最大子序和
大神带带我的博客
02-09 151
leetcode刷题：动态规划：最大子序和 最大子序和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [0] 输出：0 示例 4： 输入：nums = [-1] 输出：-1 示例 5： 输入：nums = [-10000
leetcode刷题：动态规划01（斐波那契数列）
niTaoTaoa的博客
07-20 160
斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。F(n)=F(n-1)+F(n-2)，其中n>1。这一已经是动态规划思想了，再整理整理。效果一般般，尝试加入数组，以空间换时间。给你n，请计算F(n)。先试试最熟悉的递归方式。...
力扣刷题：动态规划之第10题正则表达式匹配最通透解法（3）
岩浆李的游鱼
03-11 353
之前突然发了2篇关于算法的博客，其实就是为了学习动态规划，并解决他，所以这篇加个后缀（3）。不是很了解的朋友可以去看看 算法学习之一篇文章带你通透递归（1） 算法学习之一篇文章带你通透dijkstra迪杰斯特拉最短路径算法（2） 题目是这样的： 给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘*’ 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。 示例 1： 输入：s =
LeetCode刷题笔记：动态规划与贪心
MegumiCyan的博客
01-29 145
动态规划，贪心算法
【算法刷题】动态规划算法题型及方法归纳
STAR GAME
02-25 2076
动态规划中每一个状态一定是由上一个出来，根据这个特点，可以在过程中，存储某一条件下的数据，当再次遍历该条件时，直接取该条件对应的数据即可，可以避免重复计算，减少时间。
力扣刷题：62. 不同路径 中等 动态规划
long_wang_qing的博客
11-14 287
题目： 一个机器人位于一个 m x n网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ 算法：动态规划 class Solution { public int uniquePaths(int m, int n) { int[][] f = new int[m][n]; for (int i =..
C语言刷题之动态规划入门(一)
忆梦初心的博客
12-11 2356
动态规划入门(一)
小黑刷题:Z变换
qq_37418807的博客
06-08 110
刷题
leetcode:leetcode刷题:pencil:
05-02
字符串 | 动态规划 7 反转整数 C++ Note Easy 数学 | 鲁棒性 8 字符串转整数(atoi) C++ Note Medium 字符串 | 数学 | 鲁棒性 10 正则表达式匹配 C++ Note Hard 字符串 | 动态规划 11 盛最多水的容器 C++ Note Medium...
动态规划刷题笔记，面试必须必知必备
03-30
动态规划是一种解决问题的有效算法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。它是通过将问题分解成更小的子问题，并利用这些子问题的解来构建原问题的解。在这个过程中，重要的是理解动态规划的三个关键...
算法刷题指南：如何有效提升解题技巧.rar
07-06
动态规划 贪心算法 分治算法 回溯算法 图算法 算法刷题的意义和方法 为什么要刷题 如何选择刷题平台 刷题步骤与方法 刷题实战案例 排序算法实战 查找算法实战 动态规划实战 贪心算法实战 分治算法实战 回溯算法实战 ...
常见算法介绍、算法刷题解析及代码 简介 本文档详细介绍了常见算法，包括排序算法、搜索算法、动态规划、回溯算法等 每个算法部分提
07-03
斐波那契数列是一种经典的动态规划问题，其递推公式为：F(n) = F(n-1) + F(n-2)，初始条件为F(0) = 0, F(1) = 1 四、回溯算法 4.1 全排列 全排列（Permutations）问题是生成给定数组的所有可能排列组合，其基本...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 496
开始，
排序算法之桶排序
rd_w_csdn的博客
08-12 815
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
备战秋招60天算法挑战，Day17
最新发布
溜达虎的博客
08-13 365
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
算法：魔法字典
Garson的博客
08-12 547
设计一个使用单词列表进行初始化的数据结构，单词列表中的单词。如果给出一个单词，请判定能否只将这个单词中字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。实现dictionarydictionarysearchWordtruefalse// 返回 False// 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True// 返回 False// 返回 FalsedictionarybuildDictsearch100search。
力扣刷题笔记：动态规划与链表操作
"力扣500题刷题笔记2，包含C++代码实现，涉及动态规划、链表操作和双指针技术" 本资源主要涵盖了LeetCode中的三道经典问题，分别是力扣500题中的某一部分，包括杨辉三角II、移除链表元素和反转字符串中的单词III。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值