动态规划DP

已于 2022-02-22 10:39:19 修改
阅读量1.6w 收藏 4
点赞数
分类专栏： 数据结构与算法+leetcode刷题记录（JAVA） 文章标签： 动态规划 算法 leetcode java
于 2022-01-16 14:42:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54884881/article/details/122466892
版权

动态规划

基础类DP

leetcode70. 爬楼梯

在这里插入图片描述
在这里插入图片描述

  • 经典动态规划
class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n + 2];
        dp[n + 1] = 1;
        dp[n] = 1;
        for (int i = n - 1; i >= 1; i--) {
            dp[i] = dp[i + 1] + dp[i + 2];
        }
        return dp[1];
    }
}

在这里插入图片描述

  • 空间压缩（测试的有问题。。。。）
class Solution {
    public int climbStairs(int n) {
        int a = 1, b = 1;
        int res = 0;
        for (int i = n - 1; i >= 0; i--) {
            res = a + b;
            a = b;
            b = res;
        }
        return res;
    }
}

leetcode746. 使用最小花费爬楼梯

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length + 1];
        dp[cost.length] = 0;
        dp[cost.length - 1] = cost[cost.length - 1];
        for (int i = cost.length - 2; i >= 0; i--) {
            dp[i] = Math.min(dp[i + 1], dp[i + 2]) + cost[i];
        }
        return Math.min(dp[0], dp[1]);
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int a = 0, b = cost[cost.length - 1], res = 0;
        for (int i = cost.length - 2; i >= 0; i--) {
            res = Math.min(a, b) + cost[i];
            a = b;
            b = res;
        }
        return Math.min(a,b);
    }
}

leetcode62. 不同路径

在这里插入图片描述
在这里插入图片描述

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

在这里插入图片描述

  • 空间压缩
class Solution {
    public int uniquePaths(int m, int n) {
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        for (int i = m - 2; i >= 0; i--) {
            for (int j = n - 2; j >= 0; j--) {
                dp[j] = dp[j] + dp[j + 1];
            }
        }
        return dp[0];
    }
}

leetcode63. 不同路径 II

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int M = obstacleGrid.length;
        int N = obstacleGrid[0].length;
        int[][] dp = new int[M][N];
        for (int i = M - 1; i >= 0; i--) {
            if (obstacleGrid[i][N - 1] == 1) break;
            dp[i][N - 1] = 1;
        }
        for (int i = N - 1; i >= 0; i--) {
            if (obstacleGrid[M - 1][i] == 1) break;
            dp[M - 1][i] = 1;
        }
        for (int i = M - 2; i >= 0; i--) {
            for (int j = N - 2; j >= 0; j--) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                    continue;
                }
                dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
            }
        }
        return dp[0][0];
    }
}

leetcode96. 不同的二叉搜索树

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int thisN = 2; thisN <= n; thisN++) {
            for (int i = 0; i < thisN; i++) {
                dp[thisN] += dp[i] * dp[thisN - i - 1];
            }
        }
        return dp[n];
    }
}

leetcode64最小路径和

在这里插入图片描述

在这里插入图片描述


class Solution {
    public int minPathSum(int[][] grid) {
        int M = grid.length;
        if (M == 0) return 0;
        int N = grid[0].length;
        if (N == 0) return 0;
        for (int i = M - 2; i >= 0; i--) grid[i][N - 1] += grid[i + 1][N - 1];
        for (int i = N - 2; i >= 0; i--) grid[M - 1][i] += grid[M - 1][i + 1];
        for (int i = M - 2; i >= 0; i--) {
            for (int j = N - 2; j >= 0; j--) {
                grid[i][j] = Math.min(grid[i + 1][j], grid[i][j + 1]) + grid[i][j];
            }
        }
        return grid[0][0];
    }
}

leetcode329. 矩阵中的最长递增路径

在这里插入图片描述
在这里插入图片描述

class Solution {
    int maxLen = 0;

    public int longestIncreasingPath(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] visited = new int[m][n];//计算以每个节点开头的递增序列的长度
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                maxLen = Math.max(maxLen, dfs(matrix, i, j, m, n, visited, Integer.MIN_VALUE));
            }
        }
        return maxLen;
    }

    public int dfs(int[][] matrix, int i, int j, int m, int n, int[][] visited, int pre) {
        if (i < 0 || i >= m || j < 0 || j >= n || matrix[i][j] <= pre) return 0;
        if (visited[i][j] > 0) return visited[i][j];//如果之前已经计算过，直接返回即可
        int l = dfs(matrix, i - 1, j, m, n, visited, matrix[i][j]);
        int r = dfs(matrix, i + 1, j, m, n, visited, matrix[i][j]);
        int up = dfs(matrix, i, j - 1, m, n, visited, matrix[i][j]);
        int down = dfs(matrix, i, j + 1, m, n, visited, matrix[i][j]);
        visited[i][j] = 1 + Math.max(Math.max(l, r), Math.max(up, down));
        return visited[i][j];
    }
}

01背包类DP

  • 01背包问题本身不难，但是最重要的是如何识别出来题是否为01背包，一般是有一个目标堆，对于数组的留和舍两种选择，通过数组值的取舍进行达到目标堆效果
  • 背包问题DP进行空间压缩时，weight循环要从大到小遍历，否则会造成前段值覆盖引起答案错误

leetcode416. 分割等和子集

在这里插入图片描述
在这里插入图片描述

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0, max = 0;
        for (int val : nums) {
            sum += val;
            max = Math.max(max, val);
        }
        int target = sum / 2;
        if ((sum & 1) == 1 || max > target) return false;
        boolean[][] dp = new boolean[nums.length][target + 1];
        dp[0][nums[0]] = true;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 1; j <= target; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= nums[i]) dp[i][j] |= dp[i - 1][j - nums[i]];
            }
        }
        return dp[nums.length - 1][target];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0, max = 0;
        for (int val : nums) {
            sum += val;
            max = Math.max(max, val);
        }
        int target = sum / 2;
        if ((sum & 1) == 1 || max > target) return false;
        boolean[] dp = new boolean[target + 1];
        dp[nums[0]] = true;
        for (int i = 1; i < nums.length; i++)
            for (int j = target; j > 0; j--)
                if (j >= nums[i])
                    dp[j] |= dp[j - nums[i]];// 依赖上一层i-1的行，所以j要从大到小
        return dp[target];
    }
}

leetcode1049. 最后一块石头的重量 II🔐

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int val : stones) sum += val;
        int size = sum / 2 + 1;
        int[][] dp = new int[stones.length][size];
        for (int i = stones[0]; i < size; i++) dp[0][i] = stones[0];
        for (int i = 1; i < stones.length; i++) {
            for (int j = 1; j < size; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= stones[i])
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[stones.length - 1][size - 1] * 2;
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int val : stones) sum += val;
        int size = sum / 2 + 1;
        int[] dp = new int[size];
        for (int i = stones[0]; i < size; i++) dp[i] = stones[0];
        for (int i = 1; i < stones.length; i++) {
            for (int j = size - 1; j >= stones[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[size - 1] * 2;
    }
}

leetcode494. 目标和🔐

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int findTargetSumWays(int[] nums, int s) {
        int sum = 0;
        for (int num : nums) sum += num;
        // 绝对值范围超过了sum的绝对值范围则无法得到
        if (Math.abs(s) > Math.abs(sum)) return 0;
        int len = nums.length;
        int range = sum * 2 + 1;//因为要包含负数所以要两倍，又要加上0这个中间的那个情况
        int[][] dp = new int[len][range];//这个数组是从总和为-sum开始的
        //加上sum纯粹是因为下标界限问题，赋第二维的值的时候都要加上sum
        // 初始化   第一个数只能分别组成+-nums[i]的一种情况
        dp[0][sum + nums[0]] += 1;
        dp[0][sum - nums[0]] += 1;
        for (int i = 1; i < len; i++) {
            for (int j = -sum; j <= sum; j++) {
                if ((j + nums[i]) > sum) {//+不成立 加上当前数大于了sum   只能减去当前的数
                    dp[i][j + sum] = dp[i - 1][j - nums[i] + sum];
                } else if ((j - nums[i]) < -sum) {//-不成立  减去当前数小于-sum   只能加上当前的数
                    dp[i][j + sum] = dp[i - 1][j + nums[i] + sum];
                } else {//+-都可以
                    dp[i][j + sum] = dp[i - 1][j + nums[i] + sum] + dp[i - 1][j - nums[i] + sum];
                }
            }
        }
        return dp[len - 1][sum + s];
    }
}

在这里插入图片描述

  • 范围优化0 ~（sum-target）/ 2
  • 思维转化：将从0到负值m再转化成target，定存在一个正值n使m+n=0，然后转化成target这个过程变成从0直接到target值中将m，n值舍弃的过程。故就转化成了只加或舍弃而不减的01背包问题。

题目详解

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int M = nums.length;
        int sum = 0;
        for (int i : nums) sum += Math.abs(i);
        if (target > sum || (sum - target) % 2 != 0) return 0;
        int N = (sum - target) / 2+1;
        int[][] dp = new int[M + 1][N] ;
        dp[0][0] = 1;
        for (int j = 0; j < N; j++) {
            if (nums[0] == j) dp[0][j] += 1;
        }
        for (int i = 1; i < M; i++) {
            for (int j = 0; j < N; j++) {
                dp[i][j] += dp[i - 1][j];
                if (j >= nums[i]) dp[i][j] += dp[i - 1][j - nums[i]];
            }
        }
        return dp[M-1][N-1];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int M = nums.length;
        int sum = 0;
        for (int i : nums) sum += Math.abs(i);
        if (target > sum || (sum - target) % 2 != 0) return 0;
        int N = (sum - target) / 2 + 1;
        int[] dp = new int[N];
        dp[0] = 1;
        for (int j = 0; j < N; j++) {
            if (nums[0] == j) dp[j] += 1;
        }
        for (int i = 1; i < M; i++) {
            for (int j = N - 1; j >= 0; j--) {
                if (j >= nums[i]) dp[j] += dp[j - nums[i]];
            }
        }
        return dp[N - 1];
    }
}

leetcode474. 一和零

在这里插入图片描述
在这里插入图片描述

  • 三维动态规划，压缩后的代码
class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        int[] ints = count0and1(strs[0]);
        for (String str : strs) {
            int[] cur = count0and1(str);
            for (int j = m; j >= cur[0]; j--) {// 只有空间压缩的时候才能>=cur[0]
                for (int k = n; k >= cur[1]; k--) {// 只有空间压缩的时候才能>=cur[1]
                    dp[j][k] = Math.max(dp[j][k], dp[j - cur[0]][k - cur[1]] + 1);
                }
            }
        }
        return dp[m][n];
    }

    private int[] count0and1(String str) {
        int[] res = new int[2];
        for (int i = 0; i < str.length(); i++) {
            res[str.charAt(i) - '0']++;
        }
        return res;
    }
}

完全背包

在这里插入图片描述

leetcode518. 零钱兑换 II

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int change(int amount, int[] coins) {
        int[][] dp = new int[coins.length][amount + 1];
        for (int n = 0; n * coins[0] <= amount; n++) {
            dp[0][n * coins[0]] = 1;
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = 0; j <= amount; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= coins[i]) {
                    dp[i][j] += dp[i][j - coins[i]];
                }
            }
        }
        return dp[coins.length - 1][amount];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];
        for (int n = 0; n * coins[0] <= amount; n++) {
            dp[n * coins[0]] = 1;
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
}

leetcode377. 组合总和 Ⅳ🔐

在这里插入图片描述

在这里插入图片描述

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[]dp = new int[target + 1];
        dp[0] = 1;
        for (int j = 1; j <= target; j++) {//组合加和为j情况下有几种方案
            for (int i = 0; i < nums.length; i++) {// 遍历背包，选择可以添加的数
                if (j >= nums[i]) {// 如果此时可以添加nums[i]这个数
                    dp[j] += dp[j - nums[i]];
                }
            }
        }
        return dp[target];
    }
}

leetcode70爬楼梯（续集）

题目：之前爬楼梯只能一次一个或两个，这次就又给丁一个整数m，可一次一走1 ~ m 次，整数n表示楼梯总数。问共有几种方案。

  • 和上一题leetcode377. 组合总和 Ⅳ本质相同
class Solution {
    public int combinationSum4(int n, int m) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        for (int i = 0; i <= n; i++) { // 遍历背包,就是楼层数量
            for (int j = 0; j < m; j++) { // 遍历物品，就是遍历步数
                if (i - j >= 0) {
                    dp[i] += dp[i - j];
                }
            }
        }
        return dp[n];
    }
}

leetcode322. 零钱兑换

在这里插入图片描述
在这里插入图片描述

  • 经典完全背包
class Solution {
    public int coinChange(int[] coins, int amount) {
        int[][] dp = new int[coins.length][amount + 1];
        for (int i = 0; i < coins.length; i++) Arrays.fill(dp[i], 1000000);
        for (int i = 0; coins[0] * i <= amount; i++) {
            dp[0][coins[0] * i] = i;
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = 0; j <= amount; j++) {
                dp[i][j] = dp[i - 1][j];
                for (int n = 0; n * coins[i] <= j; n++) {
                    dp[i][j] = Math.min(dp[i - 1][j - coins[i] * n] + n, dp[i][j]);
                }
            }
        }
        return dp[coins.length - 1][amount] == 1000000 ? -1 : dp[coins.length - 1][amount];
    }
}

在这里插入图片描述

  • 斜率优化
class Solution {
    public int coinChange(int[] coins, int amount) {
        int[][] dp = new int[coins.length][amount + 1];
        for (int i = 0; i < coins.length; i++) Arrays.fill(dp[i], 1000000);
        for (int i = 0; coins[0] * i <= amount; i++) {
            dp[0][coins[0] * i] = i;
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = 0; j <= amount; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= coins[i]) {
                    dp[i][j] = Math.min(dp[i][j], dp[i][j - coins[i]] + 1);
                }
            }
        }
        return dp[coins.length - 1][amount] == 1000000 ? -1 : dp[coins.length - 1][amount];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, 1000000);
        for (int i = 0; coins[0] * i <= amount; i++) {
            dp[coins[0] * i] = i;
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
            }
        }
        return dp[amount] == 1000000 ? -1 : dp[amount];
    }
}

leetcode279. 完全平方数

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int numSquares(int n) {
        int maxN = (int) Math.sqrt(n);
        int[] dp = new int[n + 1];
        Arrays.fill(dp, 1000000);
        dp[0] = 0;// 初始化值。组成0需要0个
        for (int i = 1; i <= maxN; i++) {// 背包遍历
            for (int j = i * i; j <= n; j++) {// 目标值遍历
                dp[j] = Math.min(dp[j - i * i] + 1, dp[j]);
            }
        }
        return dp[n];
    }
}

leetcode139. 单词拆分

在这里插入图片描述
在这里插入图片描述

  • 注意stringMaxLen的剪枝
  • 回溯超时
class Solution {
    List<String> dict;
    int stringMaxLen = 0;

    public boolean wordBreak(String s, List<String> wordDict) {
        if (s.length() < 1) return true;
        dict = wordDict;
        // 如果某个区间长度大于stringMaxLen，说明比该长度长的区间不可能成功匹配，达到剪枝效果
        for (String str : wordDict) {
            stringMaxLen = Math.max(stringMaxLen, str.length());
        }
        boolean[] dp = new boolean[s.length() + 1];
        dp[s.length()] = true;
        for (int start = s.length() - 1; start >= 0; start--) {
            for (int i = start; i < s.length() && i - start + 1 <= stringMaxLen; i++) {
                if (dict.contains(s.substring(start, i + 1)) && dp[i + 1]) {
                    dp[start] = true;
                    break;
                }
            }
        }
        return dp[0];
    }
}
  • 回溯超时思想
class Solution {
    List<String> dict;
    int stringMaxLen = 0;

    public boolean wordBreak(String s, List<String> wordDict) {
        if (s.length() < 1) return true;
        dict = wordDict;
        for (String str : wordDict) {
            stringMaxLen = Math.max(stringMaxLen, str.length());
        }
        return process(s, 0);
    }

    private boolean process(String s, int strat) {
        if (strat == s.length()) return true;
        for (int i = strat; i < s.length() && i - strat + 1 <= stringMaxLen; i++) {
            String str = s.substring(strat, i + 1);
            if (dict.contains(str)&&process(s, i + 1)) {
                return true;
            }
        }
        return  false;
    }
}

打家劫舍

leetcode198. 打家劫舍

在这里插入图片描述
在这里插入图片描述

  • dp[ i ] 表示前索引 i 个房间能偷的最大值
  • 和爬楼梯差不多，不压缩了，懒
class Solution {
    public int rob(int[] nums) {
        int N = nums.length;
        if (N <= 1) return nums[0];
        int[] dp = new int[N];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);// 这里不是dp[1] = nums[1];
        for (int i = 2; i < N; i++) {
        	// 两种情况取最优
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[N - 1];
    }
}

leetcode213. 打家劫舍 II

在这里插入图片描述
在这里插入图片描述

  • 两种情况，两个DP
class Solution {
    public int rob(int[] nums) {
        int N = nums.length;
        if (N == 1) return nums[0];
        if (N == 2) return Math.max(nums[0], nums[1]);
        int[] dp_1 = new int[N - 1], dp_2 = new int[N - 1];
        // 允许第一个房间被偷，不允许最后一个被偷的初始化
        dp_1[0] = nums[0];
        dp_1[1] = Math.max(nums[1], dp_1[0]);
        // 不允许第一个房间被偷，允许最后一个被偷的初始化
        dp_2[0] = nums[1];
        dp_2[1] = Math.max(dp_2[0], nums[2]);

        for (int i = 2; i < N - 1; i++) {
            // dp_1范围是 nums[0...N-2]
            dp_1[i] = Math.max(dp_1[i - 1], dp_1[i - 2] + nums[i]);
            // dp_1范围是 nums[1...N-1]
            dp_2[i] = Math.max(dp_2[i - 1], dp_2[i - 2] + nums[i + 1]);
        }
        // 最后取最值
        return Math.max(dp_1[N - 2], dp_2[N - 2]);
    }
}

leetcode337打家劫舍 III

在这里插入图片描述
在这里插入图片描述

  • 有动态规划的思想，不是严格的动态规划
class Solution {
    public int rob(TreeNode root) {
        if (root == null) return 0;
        transData data = process(root);
        return Math.max(data.yes, data.no);
    }

    private transData process(TreeNode root) {
        if (root == null) return new transData(0, 0);
        transData l = process(root.left);
        transData r = process(root.right);
        int yes = root.val + l.no + r.no;
        int no = Math.max(l.yes, l.no) + Math.max(r.yes, r.no);
        return new transData(yes, no);
    }

    static class transData {
        int yes;
        int no;

        public transData(int i, int j) {
            yes = i;
            no = j;
        }
    }
}

leetcode740. 删除并获得点数

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int deleteAndEarn(int[] nums) {
        int[] sum = new int[10001];
        for (int val : nums) sum[val] += val;
        int pre0 = sum[0], pre1 = Math.max(sum[0], sum[1]), cur = pre1;
        for (int i = 2; i < 10001; i++) {
            cur = Math.max(pre0 + sum[i], pre1);
            pre0 = pre1;
            pre1 = cur;
        }
        return cur;
    }
}

股票问题

leetcode121. 买卖股票的最佳时机

在这里插入图片描述

在这里插入图片描述

  • 动态规划（不压缩了，没意思）
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][] dp = new int[N][2];
        dp[0][0] = prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < N; i++) {
            dp[i][0] = Math.min(dp[i - 1][0], prices[i]);// i或i之前所买入股票的最小值
            dp[i][1] = Math.max(dp[i - 1][1], prices[i] - dp[i][0]);// i或i之前卖股票所获的最大利润
        }
        return dp[N - 1][1];
    }
}

在这里插入图片描述

  • 双指针，时间复杂度和动态规划相同
class Solution {
    public int maxProfit(int[] prices) {
        int max = 0;
        int res = 0;
        for (int i = prices.length - 1; i >= 0; i--) {
            if (max > prices[i]) res = Math.max(res, max - prices[i]);
            max = Math.max(prices[i], max);
        }
        return res;
    }
}

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

在这里插入图片描述

  • 递归思想（空间复杂度高，但是能提供思路）
class Solution {
    int[] prices;
    int N;

    public int maxProfit(int[] prices) {
        N = prices.length;
        this.prices = prices;
        return process(0, false);
    }

    /**
     * @param i    当前股票索引
     * @param have 当前手里面是否有股票
     * @return 利益值
     */
    public int process(int i, boolean have) {
        if (i == N) return 0;
        if (have) return Math.max(process(i + 1, true), process(i + 1, false) + prices[i]);
        return Math.max(process(i + 1, false), process(i + 1, true) - prices[i]);
    }
}

在这里插入图片描述

  • 写好暴搜后，动归不用动脑子了
  • 打败了低是因为有更优的贪心算法，这里不多说了
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        int[][] dp = new int[N + 1][2];
        for (int i = N - 1; i >= 0; --i) {
            dp[i][1] = Math.max(dp[i + 1][1], dp[i + 1][0] + prices[i]);
            dp[i][0] = Math.max(dp[i + 1][0], dp[i + 1][1] - prices[i]);
        }
        return dp[0][0];
    }
}

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

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int N = prices.length;
        int[] dp = new int[2];
        for (int i = N - 1; i >= 0; --i) {
            int temp=dp[0];
            dp[0] = Math.max(dp[0], dp[1] - fee - prices[i]);
            dp[1] = Math.max(dp[1], temp + prices[i]);
        }
        return dp[0];
    }
}

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

在这里插入图片描述

  • 暴力搜索
class Solution {
    int[] prices;
    int N;
    public int maxProfit(int[] prices) {
        this.prices=prices;
        N = prices.length;
        if (N <= 1) return 0;
        return process(0, false, 0);
    }
    private int process(int i, boolean have, int num) {
        if (num == 2 || i == N) return 0;
        if (have) return Math.max(process(i + 1, true, num),
                process(i + 1, false, num + 1) + prices[i]);
        return Math.max(process(i + 1, false, num),
                process(i + 1, true, num) - prices[i]);
    }
}
  • 递归转动规
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][][] dp = new int[N + 1][2][2];
        for (int i = N - 1; i >= 0; --i) {
            dp[i][1][1] = Math.max(dp[i + 1][1][1], prices[i]);
            dp[i][1][0] = Math.max(dp[i + 1][1][0], dp[i + 1][0][1] + prices[i]);
            dp[i][0][1] = Math.max(dp[i + 1][0][1], dp[i + 1][1][1] - prices[i]);
            dp[i][0][0] = Math.max(dp[i + 1][0][0], dp[i + 1][1][0] - prices[i]);
        }
        return dp[0][0][0];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][] dp = new int[2][2];
        for (int i = N - 1; i >= 0; --i) {
        	//依赖关系 11 --> 01 --> 10 --> 00
        	//填充关系 00 --> 10 --> 01 --> 11 严格不能变
            dp[0][0] = Math.max(dp[0][0], dp[1][0] - prices[i]);
            dp[1][0] = Math.max(dp[1][0], dp[0][1] + prices[i]);
            dp[0][1] = Math.max(dp[0][1], dp[1][1] - prices[i]);
            dp[1][1] = Math.max(dp[1][1], prices[i]);
        }
        return dp[0][0];
    }
}

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

在这里插入图片描述
在这里插入图片描述

  • 暴力递归 —> 动态规划 —> 空间压缩
class Solution {
    public int maxProfit(int k, int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][] dp = new int[2][k + 1];
        for (int i = N - 1; i >= 0; --i) {
            for (int j = 0; j < k; j++) {
            	// 严格依赖填表顺序
                dp[0][j] = Math.max(dp[0][j], dp[1][j] - prices[i]);
                dp[1][j] = Math.max(dp[1][j], dp[0][j + 1] + prices[i]);
            }
        }
        return dp[0][0];
    }
}

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

在这里插入图片描述

  • 暴搜超时
class Solution {
    int N;
    int[] prices;

    public int maxProfit( int[] prices) {
        this.N = prices.length;
        if (N <= 1) return 0;
        this.prices=prices;
        return process(0,false,false);
    }

    private int process(int i, boolean have, boolean FreePeriod) {
        if (i == N) return 0;
        if (have) return Math.max(process(i + 1, true, false),
                process(i + 1, false, true) + prices[i]);
        if (FreePeriod) return process(i + 1, false, false);
        return Math.max(process(i + 1, false, false),
                process(i + 1, true, false) - prices[i]);
    }
}

在这里插入图片描述

  • 经典三维动态规划
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][][] dp = new int[N + 1][2][2];
        for (int i = N - 1; i >= 0; --i) {
            dp[i][0][0] = Math.max(dp[i + 1][0][0], dp[i + 1][1][0] - prices[i]);
            dp[i][0][1] = dp[i + 1][0][0];
            dp[i][1][0] = Math.max(dp[i + 1][1][0], dp[i + 1][0][1] + prices[i]);
        }
        return dp[0][0][0];
    }
}

在这里插入图片描述

  • 压缩的动态规划
class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if (N <= 1) return 0;
        int[][] dp = new int[2][2];
        for (int i = N - 1; i >= 0; --i) {
            int temp=dp[0][0];
            dp[0][0] = Math.max(dp[0][0], dp[1][0] - prices[i]);
            dp[1][0] = Math.max(dp[1][0], dp[0][1] + prices[i]);
            dp[0][1] = temp;
        }
        return dp[0][0];
    }
}

序列问题

leetcode300. 最长递增子序列🔐

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int lengthOfLIS(int[] nums) {
        int N = nums.length, res = 0;
        int[] dp = new int[N];// dp[i]是指以nums[i]为序列结尾的最长子序列长度
        for (int i = 0; i < N; i++) {
            int curMax = 0;
            for (int j = i - 1; j >= 0; --j) {
                if (nums[i] > nums[j]) {// 比nums[i]小的才能成为nums[i]左边的序列
                    curMax = Math.max(curMax, dp[j]);
                }
            }
            dp[i] = curMax + 1;// 前面最长的加上nums[i]
            res = Math.max(res, dp[i]);// 记录最长结果
        }
        return res;
    }
}

在这里插入图片描述

  • dp[ i ]的下标作为结果值，dp值作为满足 i + 1 长度的子序列最小值。用二分查找
class Solution {
    public int lengthOfLIS(int[] nums) {
        int N = nums.length, res = -1;
        if (N <= 1) return N;
        int[] dp = new int[N];
        for (int val : nums) {
            if (res == -1 || dp[res] < val) dp[++res] = val;
            else dp[minNumOfBigger(dp, res, val)] = val;
        }
        return res + 1;
    }

    private int minNumOfBigger(int[] dp, int right, int target) {
        int left = 0;
        while (left < right) {
            int mid = (left + right) / 2;
            if (dp[mid] == target) return mid;
            else if (dp[mid] > target) right = mid;
            else left = mid + 1;
        }
        return left;
    }
}

leetcode354. 俄罗斯套娃信封问题🔐

在这里插入图片描述
在这里插入图片描述

class Solution {
    // 先对宽度w进行升序排序，如果遇到w相同的情况，则按照高度h降序排序。
    // 之后把所有的h作为一个数组，在这个数组上计算 LIS(最长递增子序列) 的长度就是答案。
    // 这个问题转化思路真的太绝了，这样就保证了 w 值定满足答案情况下，h 最长递增就是结果，从而二维转为一维运算
    public int maxEnvelopes(int[][] envelopes) {
        int N = envelopes.length;
        if (N <= 1) return 1;
        // w值升序排列，h值降序排列
        Arrays.sort(envelopes, (o1, o2) -> o1[0] != o2[0] ? Integer.compare(o1[0], o2[0]) : Integer.compare(o2[1], o1[1]));
        int[] dp = new int[N];
        int k = -1;// 初始值
        for (int[] envelope : envelopes) {
            if (k == -1 || envelope[1] > dp[k]) dp[++k] = envelope[1];
            else dp[binarySearchMinOfBiggerNum(dp, 0, k, envelope[1])] = envelope[1];
        }
        return k + 1;
    }

    // 和最长递增子序列题目的 dp 思路相同
    private int binarySearchMinOfBiggerNum(int[] dp, int left, int right, int target) {
        while (left < right) {
            int mid = (left + right) / 2;
            if (dp[mid] >= target) right = mid;
            else left = mid + 1;
        }
        return right;
    }
}

leetcode1143. 最长公共子序列

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int M = text1.length(), N = text2.length();
        int[][] dp = new int[M][N];
        dp[0][0] = text1.charAt(0) == text2.charAt(0) ? 1 : 0;
        for (int i = 1; i < M; ++i) {
            dp[i][0] = Math.max(dp[i - 1][0], text1.charAt(i) == text2.charAt(0) ? 1 : 0);
        }
        for (int i = 1; i < N; ++i) {
            dp[0][i] = Math.max(dp[0][i - 1], text1.charAt(0) == text2.charAt(i) ? 1 : 0);
        }
        for (int i = 1; i < M; ++i) {
            for (int j = 1; j < N; ++j) {
                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
                if (text1.charAt(i) == text2.charAt(j)) {
                    dp[i][j] = Math.max(dp[i - 1][j - 1] + 1, dp[i][j]);
                }
            }
        }
        return dp[M - 1][N - 1];
    }
}

在这里插入图片描述

  • 空间压缩
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int M = text1.length(), N = text2.length();
        int[] dp = new int[N];
        dp[0] = text1.charAt(0) == text2.charAt(0) ? 1 : 0;
        for (int i = 1; i < N; ++i) {
            dp[i] = Math.max(dp[i - 1], text1.charAt(0) == text2.charAt(i) ? 1 : 0);
        }
        for (int i = 1; i < M; ++i) {
        	// 注意dp[0]的初始化
            dp[0] = Math.max(dp[0], text1.charAt(i) == text2.charAt(0) ? 1 : 0);
            int pre = dp[0];// 记录上一层循环值为下一层循环做dp[i-1][j-1]的值
            for (int j = 1; j < N; ++j) {
                int temp = dp[j];
                dp[j] = Math.max(dp[j - 1], dp[j]);
                if (text1.charAt(i) == text2.charAt(j)) {
                    dp[j] = Math.max(pre + 1, dp[j]);
                }
                pre = temp;
            }
        }
        return dp[N - 1];
    }
}

leetcode583. 两个字符串的删除操作

在这里插入图片描述
在这里插入图片描述

  • 和最长公共子序列一毛一样
class Solution {
    public int minDistance(String word1, String word2) {
        int M = word1.length(), N = word2.length();
        int[][] dp = new int[M][N];
        dp[0][0] = word1.charAt(0) == word2.charAt(0) ? 1 : 0;
        for (int i = 1; i < M; ++i) {
            dp[i][0] = Math.max(dp[i - 1][0], word1.charAt(i) == word2.charAt(0) ? 1 : 0);
        }
        for (int i = 1; i < N; ++i) {
            dp[0][i] = Math.max(dp[0][i - 1], word1.charAt(0) == word2.charAt(i) ? 1 : 0);
        }
        for (int i = 1; i < M; ++i) {
            for (int j = 1; j < N; ++j) {
                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
                if (word1.charAt(i) == word2.charAt(j)) {
                    dp[i][j] = Math.max(dp[i - 1][j - 1] + 1, dp[i][j]);
                }
            }
        }
        return M + N - 2 * dp[M - 1][N - 1];
    }
}

leetcode1035. 不相交的线

在这里插入图片描述
在这里插入图片描述

  • 本质还是最长不重复子序列
class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int M = nums1.length,N=nums2.length;
        int[][] dp = new int[M][N];
        dp[0][0] = nums1[0] == nums2[0] ? 1 : 0;
        for (int i = 1; i < M; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], nums1[i] == nums2[0] ? 1 : 0);
        }
        for (int i=1;i<N;i++){
            dp[0][i] = Math.max(dp[0][i - 1], nums1[0] == nums2[i] ? 1 : 0);
        }
        for (int i = 1; i < M; i++) {
            for (int j = 1; j < N; j++) {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (nums1[i] == nums2[j]) dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
        }
        return dp[M - 1][N - 1];
    }
}

leetcode718. 最长重复子数组

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int M = nums1.length, N = nums2.length;
        int[][] dp = new int[M][N];
        int res = 0;// 记录最大值
        for (int i = 0; i < M; i++) {// 初始化
            if (nums1[i] == nums2[0]) {
                dp[i][0] = 1;
                res = 1;
            }
        }
        for (int i = 0; i < N; i++) {// 初始化
            if (nums1[0] == nums2[i]) {
                dp[0][i] = 1;
                res = 1;
            }
        }
        // dp依赖关系
        for (int i = 1; i < M; i++) {
            for (int j = 1; j < N; j++) {
                if (nums1[i] == nums2[j]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    res = Math.max(res, dp[i][j]);
                }
            }
        }
        return res;
    }
}

leetcode115. 不同的子序列

在这里插入图片描述

  • 暴搜
class Solution {
    int M, N;
    String s, t;

    public int numDistinct(String s, String t) {
        M = s.length();
        N = t.length();
        this.s = s;
        this.t = t;
        return process(0, 0);
    }

    private int process(int allIndex, int tarIndex) {
        if (tarIndex == N) return 1;
        if (allIndex == M) return 0;
        if (s.charAt(allIndex) != t.charAt(tarIndex)) return process(allIndex + 1, tarIndex);
        return process(allIndex + 1, tarIndex) + process(allIndex + 1, tarIndex + 1);
    }
}

在这里插入图片描述

class Solution {
    public int numDistinct(String s, String t) {
        int M = s.length(), N = t.length();
        int[][] dp = new int[M + 1][N + 1];
        for (int i = 0; i <= M; i++) dp[i][N] = 1;
        for (int i = M - 1; i >= 0; i--) {
            for (int j = N - 1; j >= 0; j--) {
                dp[i][j] = dp[i + 1][j];
                if (s.charAt(i) == t.charAt(j)) dp[i][j] += dp[i + 1][j + 1];
            }
        }
        return dp[0][0];
    }
}

leetcode72. 编辑距离

在这里插入图片描述

在这里插入图片描述

class Solution {
    public int minDistance(String word1, String word2)  {
        if (word1 == null || word2 == null) {
            return 0;
        }
        char[] chs1 = word1.toCharArray();
        char[] chs2 = word2.toCharArray();
        int row = chs1.length + 1;
        int col = chs2.length + 1;
        int[][] dp = new int[row][col];
        //0个字符变成i个的添加距离
        for (int i = 1; i < row; i++) {
            dp[i][0] = i;
        }
        //j个字符变成0个的删除距离
        for (int j = 1; j < col; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                //替换代价
                if (chs1[i - 1] == chs2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = dp[i - 1][j - 1] +1;
                }
                /*
                 dp[i][j - 1] + 1：
                            i个转化成j-1长度的代价+一个添加距离

                 dp[i - 1][j] + 1：
                            i-1个转化成j长度的代价+一个删除距离
                 */

                dp[i][j] = Math.min(dp[i][j], dp[i][j - 1] + 1);
                dp[i][j] = Math.min(dp[i][j], dp[i - 1][j] + 1);
            }
        }
        return dp[row - 1][col - 1];
    }
}

leetcode647. 回文子串

在这里插入图片描述
在这里插入图片描述

  • 一般回文的动态规划都是初始化主对角线
class Solution {
    public int countSubstrings(String s) {
        int N = s.length();
        boolean[][] dp = new boolean[N][N];
        for (int i = 0; i < N; i++) dp[i][i] = true;
        int res = N;
        for (int i = N - 2; i >= 0; i--) {
            for (int j = i + 1; j < N; j++) {
                if (s.charAt(i) == s.charAt(j) && (j - i == 1 || dp[i + 1][j - 1])) {
                    res++;
                    dp[i][j] = true;
                }
            }
        }
        return res;
    }
}

leetcode516. 最长回文子序列

在这里插入图片描述
在这里插入图片描述

class Solution {
    public int longestPalindromeSubseq(String s) {
        int N = s.length();
        int[][] dp = new int[N][N];
        for (int i = 0; i < N; i++) dp[i][i] = 1;
        int res = 1;
        for (int i = N - 2; i >= 0; i--) {
            for (int j = i + 1; j < N; j++) {
                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                if (s.charAt(i) == s.charAt(j)) {// 不用管j-i长度，因为j-i<=1时dp[i + 1][j - 1]为零
                    dp[i][j] = Math.max(dp[i][j], dp[i + 1][j - 1] + 2);
                }
                res = Math.max(res, dp[i][j]);
            }
        }
        return res;
    }
}

leetcode5. 最长回文子串

在这里插入图片描述
在这里插入图片描述

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() == 0) return "";
        int N = s.length();
        boolean[][] dp = new boolean[N][N];
        for (int i = 0; i < N; i++) dp[i][i] = true;
        int maxPre = 0, maxLen = 1;
        for (int i = N - 1; i >= 0; i--) {
            for (int j = i + 1; j < N; j++) {
                if (s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i + 1][j - 1])) {
                    if (j - i + 1 > maxLen) {
                        maxLen = j - i + 1;
                        maxPre = i;
                    }
                    dp[i][j] = true;
                }
            }
        }
        return s.substring(maxPre, maxPre + maxLen);
    }
}
「 25' h 」
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动态规划——区间dp [石子合并]
小天狼星_布莱克 的博客
07-06 2261
动态规划（dp）是一种通过将问题分解为子问题，并利用已解决的子问题的解来求解原问题的方法。适用于具有重叠子问题和最优子结构性质的优化问题。通过定义状态和状态转移方程，动态规划可以在避免重复计算的同时找到问题的最优解，是一种高效的求解方法，常用于解决各种问题，如最短路径、背包问题、序列比对等。区间dp是一种dp的应用，用于解决涉及区间的问题。它将问题划分为若干个子区间，并通过定义状态和状态转移方程来求解每个子区间的最优解，最终得到整个区间的最优解。
C++过河(动态规划dp)
Keven_11的博客
04-12 2921
C++过河(动态规划dp) 在一个夜黑风高的晚上，有 n 个小朋友在桥的这边，现在他们需要过桥，但是由于桥很窄，每次只允许不超过两人通过，他们只有一个手电筒，所以每次过桥后，需要有人把手电筒带回来，第 i 号小朋友过桥的时间为 a[i]，两个人过桥的总时间为二者中时间长者。问所有小朋友过桥的总时间最短是多少。 输入格式 第一行输入一个整数 n，表示有 n 个小朋友。 第二行有 n 个整数 ai ，...
动态规划DP算法理解
m0_55369183的博客
01-05 2139
每次决策依赖于当前状态，又随即引起状态的转移，多阶段最优化决策解决问题的过程就称为动态规划。
动态规划dp详解（破解之道，就在其中）
wzxtsl的博客
03-20 1449
动态规划（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。简单来说，动态规划其实就是，给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后呢，把子问题答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法。
铺砖 动态规划 DP
一粒大榴莲的博客
02-26 1105
解题思路：首先我们定义dp[i]为i列时候铺砖的方法数，我们考虑2 * 2的时候，一共有3个方法，考虑3 * 2的时候，多出了一列，如果我们竖着直接放一个，方法数就和2 * 2时候一样，即3，也就是dp[i-1]个方法数，如果我们对3的后两列进行铺砖，我们只能横着放两个和竖着放一大个，为什么不能竖着放2个呢，因为这时候的方法数其实就和前面重叠了，所以只能加上2 * dp[i-2]。 所以得出：...
python动态规划dp
yuer_xiao的博客
12-06 1999
文章目录1.简介2.背包问题3.最长非降子序列 1.简介 什么是动态规划 动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度，因此它比回溯法、暴力解法要快的多。 2.背包问题 问题描述 假设我们有n件物品，分别编号为1, 2…n。其中编号为i的物品价值为vi，它的重量为wi。为了简化问题，假定价值和重量都是整数值...
★动态规划（DP算法）详解
热门推荐
qq_17807067的博客
04-25 2万+
动态规划（DP算法）详解
轨迹规划-动态规划DP和最短路径问题
qq_36458461的博客
11-30 4480
1.简介 动态规划Dynamic Programming: 这里的“Programming”并非指编写程序代码，而是指一种表格计算法（A tabular method），即基于表格查询的方法计算得到最优结果。 动态规划与分治法（The Divide-and-Conquer Method）有些类似，也是将问题分解为多个子问题，并且基于子问题的结果获得最终解。二者的区别是，分治法将初始问题划分为多个不关联（Disjoint）的子问题（Subproblem)（即子问题相互之间互不依赖），递归地解决子问题，然后将子
动态规划dp算法经典包子凑数java
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
03-24 2807
目录 题目包子凑数 动态规划思想 具体代码 题目包子凑数 小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有NN种蒸笼，其中第ii种蒸笼恰好能放A_iAi​个包子。每种蒸笼都有非常多笼，可以认为是无限笼。 每当有顾客想买XX个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有XX个包子。比如一共有33种蒸笼，分别能放3、43、4和55个包子。当顾客想买1111个包子时，大叔就会选22笼33个的再加11笼55个的（也可能选出11笼33个的再加22笼44个的）。...
动态规划DP资料
09-25
动态规划DP资料,从入门到优化，讲了树状dp，状压dp，划分dp等内容，全！
动态规划dp（常用算法）
07-29
动态规划dp（常用算法）
动态规划 dp 状态转移方程
11-03
动态规划 dp 状态转移方程。 ACM\信息学奥赛精品资料。
动态规划dp
02-27
dp 动态规划 入门讲解以及例题分析 有源程序
斜率优化动态规划DP
01-11
斜率优化DP
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 197
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 437
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 323
动态规划理论基础（主要就是确定动态规划的几个步骤）
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 903
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
动态规划dp算法原理
07-29
动态规划（Dynamic Programming，简称DP）是一种用来解决多阶段决策最优化问题的算法思想。其原理可以概括为"将一个问题拆分成多个子问题，并保存子问题的解，以便重复利用"。 动态规划通常适用于具有重叠子问题和最优子结构性质的问题。重叠子问题指的是在问题的求解过程中，同一个子问题会被多次计算；最优子结构指的是问题的最优解可以由子问题的最优解推导出来。 动态规划算法一般包含以下几个步骤： 1. 定义状态：将原问题划分成若干个子问题，定义状态表示原问题或子问题的解。 2. 定义状态转移方程：根据子问题之间的关系，建立状态之间的转移方程，通常使用递推或者递归的方式定义。 3. 初始化状态：确定初始状态的值，即边界条件，通常是最简单的子问题的解。 4. 递推求解：按照状态转移方程，从初始状态开始逐步求解出更复杂的状态，直到得到最终解。 动态规划算法的核心思想是将大问题分解成小问题，并通过保存子问题的解来避免重复计算。这样可以大大提高算法的效率，减少不必要的计算量。动态规划算法在解决最短路径、背包问题、图论等多个领域都有广泛的应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

「 25' h 」

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值