【动态规划】算法例题

已于 2024-03-19 19:26:25 修改
阅读量1.1k 收藏 28
点赞数 24
文章标签： 动态规划 算法
于 2024-03-19 19:03:45 首次发布
QiAn
本文链接：https://blog.csdn.net/linping_wong/article/details/136852051
版权

目录

一维动态规划：

 137. 爬楼梯 ①

138. 打家劫舍 ② ×

139. 单词拆分 ② ×

140. 零钱兑换 ② ×

141. 最长递增子序列 ②

多维动态规划：

142. 三角形最小路径和 ②

143. 最小路径和 ②

144. 不同路径 II ②

145. 最长回文子串 ②

146. 交错字符串 ②

147. 编辑距离 ②

148. 买卖股票的最佳时机 III ③

149. 买卖股票的最佳时机 IV ③

150. 最大正方形 ②

二十二、一维动态规划：

 137. 爬楼梯 ①

 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

方法1：（用递归会超时）

    public int climbStairs(int n) {
        int[] ints = new int[46];
        ints[1] = 1;
        ints[2] = 2;
        for (int i = 3; i <= n; i++) {
            ints[i] = ints[i - 1] + ints[i - 2];
        }
        return ints[n];
    }

详细图解参见：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

138. 打家劫舍 ② ×

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

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

示例 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 。

提示：

  • 1 <= nums.length <= 100
  • 0 <= nums[i] <= 400

解题思路：. - 力扣（LeetCode）

方法2：（0ms）

public int rob(int[] nums) {
    int prev = 0;
    int curr = 0;

    // 每次循环，计算“偷到当前房子为止的最大金额”
    for (int i : nums) {
        // 循环开始时，curr 表示 dp[k-1]，prev 表示 dp[k-2]
        // dp[k] = max{ dp[k-1], dp[k-2] + i }
        int temp = Math.max(curr, prev + i);
        prev = curr;
        curr = temp;
        // 循环结束时，curr 表示 dp[k]，prev 表示 dp[k-1]
    }

    return curr;
}

139. 单词拆分 ② ×

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。注意，你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

提示：

  • 1 <= s.length <= 300
  • 1 <= wordDict.length <= 1000
  • 1 <= wordDict[i].length <= 20
  • s 和 wordDict[i] 仅由小写英文字母组成
  • wordDict 中的所有字符串 互不相同

    // BFS
    public boolean wordBreak(String s, List<String> wordDict) {   // 2ms
        Queue<Integer> queue = new LinkedList<>();
        queue.add(0);

        int slength = s.length();
        boolean[] visited = new boolean[slength + 1];

        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int start = queue.poll().intValue();
                for (String word : wordDict) {
                    int nextStart = start + word.length();
                    if (nextStart > slength || visited[nextStart]) {
                        continue;
                    }

                    if (s.indexOf(word, start) == start) {
                        if (nextStart == slength) {
                            return true;
                        }

                        queue.add(nextStart);
                        visited[nextStart] = true;
                    }
                }
            }
        }

        return false;
    }

    // DFS
    public boolean wordBreak(String s, List<String> wordDict) {  // 1ms
        boolean[] visited = new boolean[s.length() + 1];
        return dfs(s, 0, wordDict, visited);
    }
    private boolean dfs(String s, int start, List<String> wordDict, boolean[] visited) {
        for (String word : wordDict) {
            int nextStart = start + word.length();
            if (nextStart > s.length() || visited[nextStart]) {
                continue;
            }

            if (s.indexOf(word, start) == start) {
                if (nextStart == s.length() || dfs(s, nextStart, wordDict, visited)) {
                    return true;
                }
                visited[nextStart] = true;
            }
        }
        return false;
    }

    // DP
    public boolean wordBreak(String s, List<String> wordDict) { // 1ms
        int maxWordLength = 0;
        Set<String> wordSet = new HashSet<>(wordDict.size());
        for (String word : wordDict) {
            wordSet.add(word);

            if (word.length() > maxWordLength) {
                maxWordLength = word.length();
            }
        }

        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 1; i < dp.length; i++) {
            for (int j = (i - maxWordLength < 0 ? 0 : i - maxWordLength); j < i; j++) {
                if (dp[j] && wordSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[dp.length - 1];
    }

140. 零钱兑换 ② ×

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3
 
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3

输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

提示：

  • 1 <= coins.length <= 12
  • 1 <= coins[i] <= 231 - 1
  • 0 <= amount <= 104

解题思路：

. - 力扣（LeetCode）

12ms:

class Solution {
    public int coinChange(int[] coins, int amount) {
        // 自底向上的动态规划
        if(coins.length == 0){
            return -1;
        }

        // memo[n]的值： 表示的凑成总金额为n所需的最少的硬币个数
        int[] memo = new int[amount+1];
        // 给memo赋初值，最多的硬币数就是全部使用面值1的硬币进行换
        // amount + 1 是不可能达到的换取数量，于是使用其进行填充
        Arrays.fill(memo,amount+1);
        memo[0] = 0;
        for(int i = 1; i <= amount;i++){
            for(int j = 0;j < coins.length;j++){
                if(i - coins[j] >= 0){
                    // memo[i]有两种实现的方式，
                    // 一种是包含当前的coins[i],那么剩余钱就是 i-coins[i],这种操作要兑换的硬币数是 memo[i-coins[j]] + 1
                    // 另一种就是不包含，要兑换的硬币数是memo[i]
                    memo[i] = Math.min(memo[i],memo[i-coins[j]] + 1);
                }
            }
        }

        return memo[amount] == (amount+1) ? -1 : memo[amount];
    }
}

作者：sugar
链接：https://leetcode.cn/problems/coin-change/solutions/137661/javadi-gui-ji-yi-hua-sou-suo-dong-tai-gui-hua-by-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

18ms:

class Solution {
    public int coinChange(int[] coins, int amount) {
        // 自底向上的动态规划
        if(coins.length == 0){
            return -1;
        }

        // memo[n]的值： 表示的凑成总金额为n所需的最少的硬币个数
        int[] memo = new int[amount+1];
        memo[0] = 0;
        for(int i = 1; i <= amount;i++){
            int min = Integer.MAX_VALUE;
            for(int j = 0;j < coins.length;j++){
                if(i - coins[j] >= 0 && memo[i-coins[j]] < min){
                    min = memo[i-coins[j]] + 1;
                }
            }
            // memo[i] = (min == Integer.MAX_VALUE ? Integer.MAX_VALUE : min);
            memo[i] = min;
        }

        return memo[amount] == Integer.MAX_VALUE ? -1 : memo[amount];
    }
}

作者：sugar
链接：https://leetcode.cn/problems/coin-change/solutions/137661/javadi-gui-ji-yi-hua-sou-suo-dong-tai-gui-hua-by-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

36ms:

class Solution {
    int[] memo;
    public int coinChange(int[] coins, int amount) {
        if(coins.length == 0){
            return -1;
        }
        memo = new int[amount];

        return findWay(coins,amount);
    }
    // memo[n] 表示钱币n可以被换取的最少的硬币数，不能换取就为-1
    // findWay函数的目的是为了找到 amount数量的零钱可以兑换的最少硬币数量，返回其值int
    public int findWay(int[] coins,int amount){
        if(amount < 0){
            return -1;
        }
        if(amount == 0){
            return 0;
        }
        // 记忆化的处理，memo[n]用赋予了值，就不用继续下面的循环
        // 直接的返回memo[n] 的最优值
        if(memo[amount-1] != 0){
            return memo[amount-1];
        }
        int min = Integer.MAX_VALUE;
        for(int i = 0;i < coins.length;i++){
            int res = findWay(coins,amount-coins[i]);
            if(res >= 0 && res < min){
                min = res + 1; // 加1，是为了加上得到res结果的那个步骤中，兑换的一个硬币
            }
        }
        memo[amount-1] = (min == Integer.MAX_VALUE ? -1 : min);
        return memo[amount-1];
    }
}

作者：sugar
链接：https://leetcode.cn/problems/coin-change/solutions/137661/javadi-gui-ji-yi-hua-sou-suo-dong-tai-gui-hua-by-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

141. 最长递增子序列 ②

 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

  • 1 <= nums.length <= 2500
  • -104 <= nums[i] <= 104

进阶：

  • 你能将算法的时间复杂度降低到 O(n log(n)) 吗?

方法1：

    public int lengthOfLIS(int[] nums) {
        int[] records = new int[nums.length];
        Arrays.fill(records, 1);
        int max = records[0];
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] > nums[i]){
                    records[j] = Math.max(records[i] + 1, records[j]);
                }
            }
            max = Math.max(records[i], max);
        }
        return max;
    }

 图解参见：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台 

方法2：（0ms）

    public int lengthOfLIS(int[] nums) {
        if(nums.length == 1) return 1;
        
        int n = nums.length;
        int[] dp = new int[n];
        
        int len = 0;
        for(int i: nums){
            int index = Arrays.binarySearch(dp, 0, len, i);
            if(index < 0) index = -(index+1);
            dp[index] = i;
            if(index == len) len++;
        }
        return len;
    }

方法3：（2ms）

    public int lengthOfLIS(int[] nums) {
        int ans = 0;
        int[] end = new int[nums.length];
        for(int num : nums){
            int l = 0, r = ans; // ans就是现在的个数
            while(l < r){
                int mid = l + (r - l)/2;
                if(end[mid] < num) l = mid + 1;
                else r = mid;
            }
            end[l] = num;
            if(l == ans) ans++; // 刚好处在边界
        }
        return ans;
    }

二十三、多维动态规划：

142. 三角形最小路径和 ②

 给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

示例 1：

输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出：11
解释：如下面简图所示：
   2
  3 4
 6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

示例 2：

输入：triangle = [[-10]]
输出：-10

提示：

  • 1 <= triangle.length <= 200
  • triangle[0].length == 1
  • triangle[i].length == triangle[i - 1].length + 1
  • -104 <= triangle[i][j] <= 104

进阶：

  • 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？

方法2：动态规划（3ms）
定义二维 dp 数组，将解法二中「自顶向下的递归」改为「自底向上的递推」。

1、状态定义：

2、状态转移：

3、代码实现：

    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        // dp[i][j] 表示从点 (i, j) 到底边的最小路径和。
        int[][] dp = new int[n + 1][n + 1];
        // 从三角形的最后一行开始递推。
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] = Math.min(dp[i + 1][j], dp[i + 1][j + 1]) + triangle.get(i).get(j);
            }
        }
        return dp[0][0];
    }

作者：Sweetiee 🍬
链接：https://leetcode.cn/problems/triangle/solutions/329394/di-gui-ji-yi-hua-dp-bi-xu-miao-dong-by-sweetiee/

时间复杂度：O(N^2)，N 为三角形的行数。
空间复杂度：O(N^2)，N 为三角形的行数。

方法3：空间优化

作者：Sweetiee 🍬
链接：https://leetcode.cn/problems/triangle/solutions/329394/di-gui-ji-yi-hua-dp-bi-xu-miao-dong-by-sweetiee/
 

    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[] dp = new int[n + 1];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
            }
        }
        return dp[0];
    }

作者：Sweetiee 🍬
链接：https://leetcode.cn/problems/triangle/solutions/329394/di-gui-ji-yi-hua-dp-bi-xu-miao-dong-by-sweetiee/

时间复杂度：O(N^2)，N 为三角形的行数。
空间复杂度：O(N)，N 为三角形的行数。

递归见：. - 力扣（LeetCode）

0ms答案：

    public int minimumTotal(List<List<Integer>> triangle) {
        int[] a = new int[triangle.size()];
        for (int i = 0; i < triangle.size(); ++i) minimumTotal(triangle, a, i);
        int min = Integer.MAX_VALUE;
        for (int i : a) if (i < min) min = i;
        return min;
    }

    private static void minimumTotal(List<List<Integer>> triangle, int[] last, int i) {
        List<Integer> line = triangle.get(i);
        if (i == 0) {
            last[0] = line.get(0);
            return;
        }
        last[i] = last[i - 1] + line.get(i);
        last[i - 1] += line.get(i - 1);
        for (int j = i - 2; j > -1; --j) {
            int sum = last[j] + line.get(j + 1);
            if (sum < last[j + 1]) last[j + 1] = sum;
            last[j] += line.get(j);
        }
    }

1ms答案：

    public int minimumTotal(List<List<Integer>> triangle) {
        memo = new Integer[triangle.size()][triangle.size()];
        return  dfs(triangle, 0, 0);
    }
    Integer[][] memo;
    private int dfs(List<List<Integer>> triangle, int i, int j) {
        if (i == triangle.size()) {
            return 0;
        }
        if (memo[i][j] != null) {  //计算过的最小路径就无需再计算，直接返回
            return memo[i][j];
        }
        return memo[i][j] = Math.min(dfs(triangle, i + 1, j), dfs(triangle, i + 1, j + 1)) + triangle.get(i).get(j); //当前元素加下层中最短的路径和
    }

2ms答案：

    public int minimumTotal(List<List<Integer>> triangle) {
        int[] minSum = new int[triangle.size()];
        // for(int i = 0; i < minSum.length; ++i) minSum[i] = Integer.MAX_VALUE-1444;
        minSum[0] = triangle.get(0).get(0);
        for(int i = 1; i < minSum.length; ++i){
            List<Integer> p = triangle.get(i);
            int last = minSum[0], pum = 0;
            for(int j = 0; j < i+1; ++j){
                if(j == 0) pum = last+p.get(j);
                else if(j == i) pum = last+p.get(j);
                else pum = Math.min(last, minSum[j])+p.get(j);
                last = minSum[j];
                minSum[j] = pum;
            }
        }
        int min = Integer.MAX_VALUE;
        for(int i: minSum){
            if (i < min) min=i;
        }
        return min;

    }

143. 最小路径和 ②

144. 不同路径 II ②

145. 最长回文子串 ②

146. 交错字符串 ②

147. 编辑距离 ②

148. 买卖股票的最佳时机 III ③

149. 买卖股票的最佳时机 IV ③

150. 最大正方形 ②

玖柒_lin
关注
  • 24
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划算法经典例题
05-16
以下将详细阐述动态规划的基本概念、核心思想以及在标题中提到的经典例题。 **1. 动态规划基础** 动态规划（Dynamic Programming）由美国数学家Richard Bellman提出，主要用于解决具有重叠子问题和最优子结构的问题...
动态规划经典例题asdfghjkl
08-16
动态规划经典例题asdfghjkl 动态规划是一种最优化方法，它可以解决许多复杂的问题。在本节中，我们将学习动态规划的基本模型、递推关系和经典题目。 动态规划的基本模型 动态规划是一种方法，它可以将最优化问题...
LeetCode64. 最小路径和(c++)
visual568的博客
08-16 308
最小路径和 题目描述 给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：每次只能向下或者向右移动一步。 示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。 解题思路 这个题是一个典型的动态规划 dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + arr[i][j] dp数组可以直接用原数组 然后就是注意初始化，第一行和第一列的每一项
最小转弯问题【BFS】
在人间贩卖声音
12-14 1410
Description 给出一张地图，这张地图被分为n×m（n,m<=100)n×m（n,m<=100)n×m（n,m<=100)个方块，任何一个方块不是平地就是高山。平地可以通过，高山则不能。现在你处在地图的（x1,y1）（x1,y1）（x1,y1）这块平地，问：你至少需要拐几个弯才能到达目的地（x2,y2）（x2,y2）（x2,y2）？你只能沿着水平和垂直方向的平地上行进，拐...
【bfs】A015_最短最少拐弯路径（bfs）
无敌兔0x01
03-17 1077
一、题目描述 二、题解 方法一：bfs 复杂度分析 时间复杂度：O()O()O()， 空间复杂度：O()O()O()， 方法二： 复杂度分析 时间复杂度：O()O()O()， 空间复杂度：O()O()O()， ...
51nod 1444 破坏道路(任意两点最短路径)
weixin_30834019的博客
09-10 69
链接：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1444 分析：相当于说，求s1到t1和s2到t2的路径之和最小值，若两条路径有重复部分，只计算一次。考虑重合部分，相当于重合部分算一次，其它部分各算一次，可以O(n^2)枚举重合部分(u,v)，然后重合部分同向时用dis[s1][u]+dis[s2][u]+dis[...
追梦算法----最小拐弯路径
今天会营业的博客
04-14 2005
说明 农夫约翰在农场工作了一天，感觉比较累，准备开车回家。约翰在比较累的时候，喜欢走直路，不喜欢拐弯，哪怕走少拐弯的路回家更远，约翰也想走直路（好任性的约翰!）。请你从约翰的出发地到目的地找一条路，使得约翰回家拐弯数量最少。 输入格式 第一行两个整数n和m（n和m都是1000以内的整数），代表地图的大小。 接下来的n行，每行有m个数，其中能够同行的点用0表示，不能通行的点用1表示。 再接下来1行，有4个整数，s1、s2、e1、e2，s1和s2表示出发点的坐标，e1和e2表示目的地的坐标。 输出格式
动态规划经典例题详解
weixin_45633353的博客
12-28 4208
最长回文子序列 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。 子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。 解题思路 运用的是动态规划的思想，由于是求最长回文字符串。 dp数组定义为：在子串s[i…j]中，最长回文子序列的长度为dp[i][j]; 子问题： 所以其子问题可以看作是求短一点长度，例如求dp[i][j],可 以由求其子问题dp[i+1][j-1]的结果算出。所以其子问题即是长度 减去左右两端的字符串的长度。 递推公式: dp
动态规划算法的例子
极客园地
05-28 4133
如果是计算及科班出身的话，动态规划可能已经听过，研究生的课程和本科生的课程的区别在于采用的教材难度更加大一些。更强调一些经典问题和在此基础上升级的问题。动态规划和分治算法有很多地方是相像的。 一、引子 1、最短路径问题 问题： 输入：起点集合S1,S2,...,Sn，终点集合T1,T2,...,Tm，起点集合 { S_1, S_2, ..., S_n } ， 终点集合{T_1, T_2, ... , T_m}， 起点集合S1​,S2​,...,Sn​，终点集合T1​,T2​,...
动态规划算法与典型例题
weixin_50431732的博客
05-13 1万+
动态规划算法设计思路与一些典型例题，如长江游艇问题，0-1背包问题，跳台阶问题，强盗抢劫问题等
动态规划算法典型例题
热门推荐
can_chen的博客
05-02 1万+
1. 动态规划之选数问题 题目要求： 假设给定一串数字{1, 2, 4, 1, 7, 8, 3}，我们要从中选择若干个数，使最后的和达到最大。选择的规则是，不能选相邻的数字。比如：如果我们选了第一个数字1，那么我们就不能选2，如果我们选择了数字4，那么我们就不能选择与它相邻的2和1。 动态规划的思想：将整个问题划分成一个个子问题，也就是说要求整个数列的最大和，可以先求出前面若干个数的和，一直划分...
【数据结构与算法-动态规划系列经典例题汇总】
是小武呀
03-23 9614
【数据结构与算法-动态规划系列经典例题汇总】典例1、爬楼梯（easy）典例2、打劫（easy）典例3、最大字段和（easy）典例4、找零钱（medium）典例5、三角形（medium）典例6、最长上升子序列（medium）典例7、最小路径和（medium）典例8、地下城游戏（hard） 典例1、爬楼梯（easy） 题目描述： 思路： LeetCode提交OJ测试链接: OJ测试代码实现： 可本地运行测试的完整代码： 典例2、打劫（easy） 题目描述： 思路：
五大常用算法——动态规划算法详解及经典例题，算法数据结构
04-07
动态规划算法是一种强大的算法设计技术，主要用于解决多阶段决策过程中的最优化问题。它的核心思想是通过将复杂问题分解为相互关联的子问题，并利用子问题的最优解来构建原问题的最优解。动态规划强调的是“空间换...
五大常用算法——动态规划算法详解及经典例题 (1)，算法数据结构
04-07
动态规划是一种重要的算法设计技术，源自运筹学，主要用于解决多阶段决策过程中的最优化问题。它的核心思想是将复杂问题分解成多个相互关联的子问题，并通过存储和重用子问题的解来避免重复计算，从而提高效率。动态...
贪心算法和动态规划算法题解.7z
04-19
贪心算法和动态规划是两种在计算机科学中广泛使用的算法设计策略，特别是在解决优化问题时。这两种方法在处理复杂问题时各有特点，但都致力于找到全局最优解。 贪心算法是一种局部最优解策略，它每次选择当前状态下...
【18】输出字符菱形
2301_78786609的博客
07-19 190
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 103
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 166
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 469
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
动态规划算法 例题 c++
06-07
这是一个使用动态规划算法解决 0/1 背包问题的例题： ```cpp #include #include using namespace std; const int MAXN = 100; int n, m; // 物品数量和背包容量 int w[MAXN], v[MAXN]; // 物品的重量和价值 int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值