【LeetCode】动态规划专题

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

动态规划

打家劫舍

198. 打家劫舍

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

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

public class Solution {
   	/*
    dp[i] 表示 [0, i]所能偷到的最大金额数
    i如果要偷，则 dp[i-2] + nums[i]
    i如果不偷，则 dp[i-1]
     */
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int n = nums.length;
        if (n == 1) return nums[0];
        if (n == 2) return Math.max(nums[0], nums[1]);
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < n; i++) {
            dp[i] = Math.max(nums[i] + dp[i - 2], dp[i - 1]);
        }
        return dp[n - 1];
    }

    /*
    空间优化，由于每次都至于其前两个有关，可以设置两个变量
     */
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int n = nums.length;
        if (n == 1) return nums[0];
        int first = nums[0], second = Math.max(nums[0], nums[1]);
        for (int i = 2; i < n; i++) {
            int third = Math.max(first + nums[i], second);
            first = second;
            second = third;
        }
        return second;
    }
}
213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

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

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        } else if (n == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(rob_range(nums, 0, n - 2), rob_range(nums, 1, n - 1));
    }

    public int rob_range(int[] nums, int start, int end) {
        int first = nums[start], second = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
}
⭐337. 打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

class Solution {
    public int rob(TreeNode root) {
        /*
        你是我见过最聪明的小偷
        */
        /*
        //递归思想（不要深入递归函数体，只需知道递归函数的功能，以及找到跳出递归的边界条件）
        //思路：
        //能盗取的最高金额为 抢劫该节点+抢劫该节点的左孩子的左右子树+抢劫该节点的右孩子的左右子树
        //与 抢劫该节点的左子树+抢劫该节点的右子树的和  的最大值
        //超时，原因是出现了很多重复的计算，可使用动态规划解决
        if(root == null) return 0;
        int val = 0;
        if(root.left != null) val += rob(root.left.left) + rob(root.left.right);
        if(root.right != null) val += rob(root.right.left) + rob(root.right.right);
        return Math.max(rob(root.left) + rob(root.right),val + root.val);
        */
        
        //动态规划
        //思路：
        //定义一个数组res,长度为2,res[0]表示不抢该节点可获得最大值,res[1]表示抢劫该节点可获得最大值
        //方法helper(r)意为：在以r为根节点的树中,返回抢劫根节点与不抢劫根节点可获得的最大值
        //执行用时 0ms
        int[] res = helper(root);
        return Math.max(res[0],res[1]);
    }           
    public int[] helper(TreeNode r){
        if(r == null) return new int[2];//边界条件，r为null时，跳出
        int[] left = helper(r.left);//对于以r.left为根的树，计算抢劫根节点(r.left)与不抢劫根节点可获得最大金额. left[0]则为不抢r.left可获得的最大金额,left[1]则为抢劫r.left可获得的最大金额  以下right[] 分析同理
        int[] right = helper(r.right);
        int[] res = new int[2];
        res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);//计算不抢劫当前根节点可获得的最大金额(那么其左右子树可以随便抢)
        res[1] = r.val + left[0] + right[0];//计算若抢劫根节点可获得的最大金额(此时,其左右子树的根节点不能被抢)
        return res;
    }
}

子序列系列

300. 最长递增子序列

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

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

// dp
class Solution {
    public int lengthOfLIS(int[] nums) {
        // dp[i] 表示以i结束的最长递增子序列的长度
        // 0 1 2 ... i - 1 i
        int n = nums.length;
        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = 1;
        }
        int res = 1;
        for (int i = 1; i < n; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], 1 + dp[j]);
                    res = Math.max(res, dp[i]);
                }
            }
        }
        return res;
    }
}
674. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        // dp[i]表示以nums[i]结尾的最长连续递增子序列的长度
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        int res = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                dp[i] = 1 + dp[i - 1];
                res = Math.max(res, dp[i]);
            }
        }
        return res;
    }
}
718. 最长重复子数组

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        int[][] dp = new int[len1 + 1][len2 + 1];
        int res = 0;
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                    res = Math.max(res, dp[i][j]);
                }
            }
        }
        return res;
    }
}
1143. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

  • 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        // dp[i][j] 表示以text1[i]和text2[j]结尾的子字符串的最长公共子序列的长度
        int len1 = text1.length(), len2 = text2.length();
        int[][] dp = new int[len1][len2];
        dp[0][0] = text1.charAt(0) == text2.charAt(0) ? 1 : 0;
        for (int i = 1; i < len1; i++) {
            for (int j = 1; j < len2; j++) {
                if (text1.charAt(i) == text2.charAt(j)) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
                }
            }
        }
        return dp[len1 - 1][len2 - 1];
    }
}
1035. 不相交的线

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：

  • nums1[i] == nums2[j]
  • 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

// 等价于两个字符串的最长公共子序列
class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[len1][len2];
    }
}
392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

// 双指针
class Solution {
    public boolean isSubsequence(String s, String t) {
        int i = 0, j = 0;
        while (i < s.length() && j < t.length()) {
            if (s.charAt(i) == t.charAt(j)) {
                i++;
                j++;
            } else {
                j++;
            }
        }
        return i == s.length();
    }
}
// dp
class Solution {
    public boolean isSubsequence(String s, String t) {
        // dp[i][j]表示使用s的前i个字符在t的前j个字符中进行匹配能够匹配成功的字符数
        int len1 = s.length(), len2 = t.length();
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                } else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        return dp[len1][len2] == len1;
    }
}
115. 不同的子序列

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

题目数据保证答案符合 32 位带符号整数范围。

class Solution {
    public int numDistinct(String s, String t) {
        // dp[i][j]表示使用s中前i个字符生成的子序列在t的前j个字符中进行匹配匹配成功的不同种数
        int len1 = s.length(), len2 = t.length();
        int[][] dp = new int[len1 + 1][len2 + 1];
        // 对于s中前i个字符，可以删除所有字符然后和t中的前0个字符即空字符串匹配
        for (int i = 0; i <= len1; i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    // 子序列可以匹配该字符也可以不匹配该字符
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    // 子序列匹配不了该字符，不匹配了，试试前面的
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[len1][len2];
    }
}
583. 两个字符串的删除操作

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

class Solution {
    public int minDistance(String word1, String word2) {
        // dp[i][j]表示word1前i个字符可以和word2中前j个字符相同所需要的操作数
        int len1 = word1.length(), len2 = word2.length();
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 0; i <= len1; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= len2; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.min(2 + dp[i - 1][j - 1], Math.min(1 + dp[i - 1][j], 1 + dp[i][j - 1]));
                }
            }
        }
        return dp[len1][len2];
    }
}
72. 编辑距离

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

  • 插入一个字符
  • 删除一个字符
  • 替换一个字符
class Solution {
    public int minDistance(String word1, String word2) {
        // dp[i][j]表示word1前i个字符可以和word2中前j个字符相同所需要的操作数
        // i \in [0, m], j \in [0, n]
        // 转移方程：
        // dp[i-1][j] + 1次删除word1的最后一个元素
        // dp[i][j-1] + 1次添加word2的最后一个元素
        // dp[i-1][j-1] + 0次（如果word1，word2最后一个字符相同）
        // dp[i-1][j-1] + 1次替换word1中最后一个字符为word2中最后一个字符
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int j = 0; j < n + 1; j++) {
            dp[0][j] = j;
        }
        for (int i = 0; i < m + 1; i++) {
            dp[i][0] = i;
        }
        for (int i = 1; i < m + 1; i++) {
            for (int j = 1; j < n + 1; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = Math.min(Math.min(dp[i][j - 1] + 1, dp[i - 1][j] + 1), dp[i - 1][j - 1]);
                } else {
                    dp[i][j] = Math.min(Math.min(dp[i][j - 1] + 1, dp[i - 1][j] + 1), dp[i - 1][j - 1] + 1);
                }
            }
        }
        return dp[m][n];
    }
}
647. 回文子串

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

// dp
class Solution {
    public int countSubstrings(String s) {
        int res = 0;
        int len = s.length();
        boolean[][] dp = new boolean[len][len];
        // s[i] == s[j] && dp[i + 1][j - 1] → dp[i][j]
        // 从左下角开始往右上角进行状态转移
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {
                // [i, j], j - i + 1 <= 3
                if (s.charAt(i) == s.charAt(j) && (j - i + 1 <= 3 || dp[i + 1][j - 1])) {
                    dp[i][j] = true;
                    res++;
                }
            }
        }
        return res;
    }
}
// 中心扩展
class Solution {
    int res = 0;
    public int countSubstrings(String s) {
        for (int i = 0; i < s.length(); i++) {
            count(i, i, s);
            count(i, i + 1, s);
        }
        return res;
    }

    private void count(int left, int right, String s) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            res++;
            left--;
            right++;
        }
    }
}
516. 最长回文子序列

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

class Solution {
    public int longestPalindromeSubseq(String s) {
        // dp[i][j]表示[i, j]这个范围最长回文子序列的长度
        int res = 0, len = s.length();
        int[][] dp = new int[len][len];
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {
                // [i, j] cnt = j - i + 1
                if (j - i + 1 == 1) {
                    dp[i][j] = 1;
                } else if (j - i + 1 == 2) {
                    dp[i][j] = (s.charAt(i) == s.charAt(j) ? 2 : 1);
                } else {
                    if (s.charAt(i) == s.charAt(j)) {
                        dp[i][j] = 2 + dp[i + 1][j - 1];
                    } else {
                        dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                    }
                }  
                res = Math.max(res, dp[i][j]);
            }
        }
        return res;
    }
}

股票问题

121. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[] dp = new int[2];
        dp[0] = 0;
        dp[1] = -prices[0];
        for (int i = 1; i < n; i++) {
            dp[0] = Math.max(dp[0], dp[1] + prices[i]);
            dp[1] = Math.max(dp[1], -prices[i]);
        }
        return dp[0];
    }
}
122. 买卖股票的最佳时机 II

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

class Solution {
    public int maxProfit_1(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[n - 1][0];
    }

    public int maxProfit(int[] prices) {
        int n = prices.length;
        int no_socket = 0, own_socket = -prices[0];
        for (int i = 1; i < n; i++) {
            no_socket = Math.max(no_socket, own_socket + prices[i]);
            own_socket = Math.max(own_socket, no_socket - prices[i]);
        }
        return no_socket;
    }
}
309. 最佳买卖股票时机含冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

  • 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
  • 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; i++) {
            // 第i天不持股，i-1天可以是不持股，也可以是持股然后第i天卖了
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            // 第i天持股，
            // i-1天可以是持股
            // i-1天不持股然后第i天买入
            // i-1天不持股是冷冻期，所以可以直接看第i-2天不持股的情况
            dp[i][1] = Math.max(dp[i - 1][1], (i >= 2 ? dp[i - 2][0] : 0) - prices[i]);
        }
        return dp[n - 1][0];
    }
}

完全背包

⭐322. 零钱兑换

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

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

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

class Solution {
    public int coinChange(int[] coins, int amount) {
        // 完全背包问题
        // 背包容量amount，物品集合为coins
        // 选择最少的物品放满背包
        // dp[i][j]表示用前i个物品装满背包j所需最少的物品数
        int n = coins.length;
        int[][] dp = new int[n + 1][amount + 1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= amount; j++) {
                if (j == 0) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = amount + 1;
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= amount; j++) {
                if (coins[i - 1] > j) { // 当前物品太大了放不下
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j], 1 + dp[i][j - coins[i - 1]]);
                }
            }
        }
        return dp[n][amount] == amount + 1 ? -1 : dp[n][amount];
    }
}

class Solution {
    public int coinChange(int[] coins, int amount) { 
        int n = coins.length;
        int[] dp = new int[amount + 1];
        for (int j = 1; j <= amount; j++) {
            dp[j] = amount + 1;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = coins[i - 1]; j <= amount; j++) {
            // for (int j = amount; j >= coins[i - 1]; j--) {
                // 因为 dp[j - coins[i - 1]]在前面，因此更新dp[j]之前要先得到dp[j - coins[i - 1]] 的值，也就是说要从左到右进行遍历
                dp[j] = Math.min(dp[j], 1 + dp[j - coins[i - 1]]);
            }
        }
        return dp[amount] == amount + 1 ? -1 : dp[amount];
    }
}
518. 零钱兑换 II

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

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

class Solution {
    public int change(int amount, int[] coins) {
        int n = coins.length;
        // 转换为完全背包问题
        // 物品集coins，背包容积 amount
        // dp[i][j]表示用前i个物品塞满背包可以产生的组合数
        // 最后返回dp[n][amount]
        int[][] dp = new int[n + 1][amount + 1];
        // 对于第0行：用0个物品塞背包，组合数肯定为0
        // 对于第0列：用i个物品塞背包，组合数也为0
        // 直接从(1, 1)遍历
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= amount; j++) {
                if (coins[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
                }
            }
        }
        return dp[n][amount];
    }
}

class Solution {
    public int change(int amount, int[] coins) {
        int n = coins.length;
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = coins[i - 1]; j <= amount; j++) {
                dp[j] = dp[j] + dp[j - coins[i - 1]];
            }
        }
        return dp[amount];
    }
}
377. 组合总和 Ⅳ

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target + 1];
        // dp[i]表示总和为i的组合个数
        dp[0] = 1;
        for (int i = 1; i <= target; i++) {
            for (int num : nums) {
                if (i >= num) {
                    dp[i] += dp[i - num];
                }
            }
        }
        return dp[target];
    }
}

01背包

⭐416. 分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 == 1) return false;
        int n = nums.length, target = sum / 2;
        boolean[][] dp = new boolean[n][target + 1];
       	// dp[i][j]表示是否能从[0, i]这些元素中找到一组和为j
        // 理解为01背包，就是这些物品能不能把背包塞满
        if (nums[0] >= 0 && nums[0] <= target) {
            dp[0][nums[0]] = true;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= target; j++) {
                if (nums[i] > j) {	// 当前元素太大了，不考虑
                    dp[i][j] = dp[i - 1][j];
                } else {	// 当前元素可以考虑放，可放可不放
                    dp[i][j] = dp[i - 1][j - nums[i]] || dp[i - 1][j];
                }
            }
        }
        return dp[n - 1][target];
    }
}

// 空间优化
class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 == 1) return false;
        int n = nums.length, target = sum / 2;
        boolean[] dp = new boolean[target + 1];
        if (nums[0] >= 0 && nums[0] <= target) {
            dp[nums[0]] = true;  // 只有一个元素，只能塞满这么大的背包
        }
        
        for (int i = 1; i < n; i++) {
            for (int j = target; j >= nums[i]; j--) {
                if (dp[target]) return true;
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
        return dp[target];
    }
}
1049. 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

  • 如果 x == y，那么两块石头都会被完全粉碎；
  • 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

class Solution {
    public int lastStoneWeightII(int[] stones) {
        // 我们要将stones分为两组，让这两组的差值尽量的小
        // target = sum / 2
        // 那么最好情况就是 一个容量为 target 一个容量为 sum - target
        // 我们要做的就是判断使用stones[0:j-1]，装到容量为 target 的背包中，能够放入的最大容量
        int n = stones.length, sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum / 2;
        int[][] dp = new int[n][target + 1];
        for (int i = 0; i < n; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= target; j++) {
            if (j >= stones[0]) {
                dp[0][j] = stones[0];
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= target; j++) {
                if (stones[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], stones[i] + dp[i - 1][j - stones[i]]);
                }
            }
        }
        return sum - dp[n - 1][target] - dp[n - 1][target];
    }
}
⭐698. 划分为k个相等的子集

给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。

// 先建立k个容量为sum/k的桶，然后一个一个桶的往里面放数字
class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        //因为题目限制条件不用担心溢出
        int sum = 0;
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        if(sum % k != 0){
            return false;
        }
        //求出子集的和
        sum = sum / k;
        //排序 小的放最前面大的放最后面
        Arrays.sort(nums);
        //如果子集的和小于数组最大的直接返回false
        if(nums[nums.length - 1] > sum){
            return false;
        }
        //建立一个长度为k的桶
        int[] arr = new int[k];
        //桶的每一个值都是子集的和
        Arrays.fill(arr, sum);
        //从数组最后一个数开始进行递归
        return help(nums, nums.length - 1, arr, k);
    }
    
    private boolean help(int[] nums, int cur, int[] arr, int k){
        //已经遍历到了-1说明前面的所有数都正好可以放入桶里，那所有桶的值此时都为0，说明找到了结果，返回true
        if(cur < 0){
            return true;
        }
        //遍历k个桶
        for(int i = 0; i < k; i++){
            //如果正好能放下当前的数或者放下当前的数后，还有机会继续放前面的数（剪枝）
            if(arr[i] == nums[cur] || (cur > 0 && arr[i] - nums[cur] >= nums[0])){
                //放当前的数到桶i里
                arr[i] -= nums[cur];
                //开始放下一个数
                if(help(nums, cur - 1, arr, k)){
                    return true;
                }
                //这个数不该放在桶i中
                //从桶中拿回当前的数
                arr[i] += nums[cur];
            }
        }
        return false;
    }
}
⭐474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // dp[i][j][k] 表示strs前i个字符串使用j个0和k个1所能得到的字符串的最多数量
        int len = strs.length;
        int[][][] dp = new int[len + 1][m + 1][n + 1];
        // 最终返回 dp[len][m][n]
        for (int i = 1; i <= len; i++) {
            int ones = 0, zeros = 0;
            for (char c : strs[i - 1].toCharArray()) {
                if (c == '1') ones++;
                else zeros++;
            }
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    if (zeros > j || ones > k) {
                        dp[i][j][k] = dp[i - 1][j][k];
                    } else {
                        dp[i][j][k] = Math.max(dp[i - 1][j][k], 1 + dp[i - 1][j - zeros][k - ones]);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
}
// 空间优化
class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // dp[i][j][k] 有[0, i]这么多物品，要求其总和0要能放到j中，其总和1要能放到k中，最多能装多少物品
        int len = strs.length;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= len; i++) {
            String s = strs[i - 1];
            int zeros = 0, ones = 0;
            for (char c : s.toCharArray()) {
                if (c == '0') zeros++;
                else ones++;
            }
            for (int j = m; j >= zeros; j--) {
                for (int k = n; k >= ones; k--) {
                    dp[j][k] = Math.max(dp[j][k], 1 + dp[j - zeros][k - ones]);
                    
                }
            }
        }
        return dp[m][n];
    }
}
494. 目标和

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

  • 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

  1. dfs回溯

    class Solution {
    int res = 0;

    public int findTargetSumWays(int[] nums, int target) {
        dfs(nums, 0, target, 0);
        return res;
    }

    private void dfs(int[] nums, int begin, int target, int pathSum) {
        if (begin == nums.length) {
            if (pathSum == target) {
                res++;
            }
        } else {
            dfs(nums, begin + 1, target, pathSum + nums[begin]);
            dfs(nums, begin + 1, target, pathSum - nums[begin]);
        }
    }
}

  2. dp

    class Solution {
	public int findTargetSumWays(int[] nums, int target) {
        // Sum(P) - Sum(N) = target
        // Sum(P) - Sum(N) + Sum(P) + Sum(N) = target + Sum
        // 2 * Sum(P) = target + Sum
        // Sum(P) = (target + Sum) / 2
        // 问题转化为数组的子集个数，该子集和为 (target + Sum) / 2
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        // target应当是一个正的偶数
        if ((target + sum) % 2 != 0 || (target + sum) < 0) return 0;
        target = (target + sum) / 2;
        if (target < 0) return 0;
        return findTargetNum(nums, target);
    }

    private int findTargetNum(int[] nums, int target) {
        // dp[i][j] 表示用nums中前i个数可以得到的和为target的子集数量
        // 返回dp[len][target]
        int len = nums.length;
        int[][] dp = new int[len + 1][target + 1];
        dp[0][0] = 1;
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j <= target; j++) {
                if (nums[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i - 1]];
                }
            }
        }
        return dp[len][target];
    }
}

// 空间优化
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        // sum(pos) + sum(neg) = target
        // sum(pos) - sum(neg) = sum(nums)
        // 2*sum(pos) = target + sum(nums)
        // sum(pos) = (target + sum(nums)) / 2
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if ((target + sum) % 2 != 0 || (target + sum) < 0) return 0;
        target = (target + sum) / 2;
        // 转化为在[0, n]中找物品组合使得总和为target
        int n = nums.length;
        int[] dp = new int[target + 1];
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = target; j >= nums[i - 1]; j--) {
                dp[j] = dp[j] + dp[j - nums[i - 1]];
            }
        }
        return dp[target];
    }
}
arthur01p
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode之动态规划
weixin_47414034的博客
06-23 1839
以爬楼梯问题为例，总结动态规划的步骤：第一步：定义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动态规划专题（共38道）
weixin_45627369的博客
04-10 6006
某一问题有很多重叠子问题 每一状态一定由上一状态推导出来 而贪心没有状态推导，而是直接选局部最优 解决方式： 确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历顺序 举例推导dp数组 模拟：举例推导dp数组 检查：打印dp数组 1.Leetcode509. 斐波那契数 class Solution { public: int fib(int n) { //第i个数的值 vector<int>n
leetcode-动态规划-python
Greeksilverfir的博客
09-25 211
一、动态规划 动态规划的三要素:最优子结构,边界和状态转移函数, 最优子结构是指每个阶段的最优状态可以从之前某个阶段的某个或某些状态直接得到(子问题的最优解能够决定这个问题的最优解) 边界指的是问题最小子集的解(初始范围) 状态转移函数是指从一个阶段向另一个阶段过度的具体形式,描述的是两个相邻子问题之间的关系(递推式) 重叠子问题,对每个子问题只计算一次,然后将其计算的结果保存到一个表格中,每一次需要上一个子问题解时,进行调用,只要o(1)时间复杂度,准确的说,动态规划是利用空间去换取时间的算法. 判断
动态规划经典例题leetcode思路代码详解
xiaoliii0401的博客
11-25 1225
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。这一篇的例题解答是严格按照我上一篇写的动态规划三部曲做的，对动态规划不太了解或者比较感兴趣的朋友可以看我上一篇文章。给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。个台阶向上爬需要支付的费用。，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
[动态规划] (九) 路径问题：LeetCode 64.最小路径和
好兄弟起把大狙
11-06 191
[动态规划] (九) 路径问题：LeetCode 64.最小路径和
动态规划专题精讲（v2.0）.pdf
06-06
它详细讲解了40多道LeetCode动态规划经典题目，并保持「代码随想录」的严谨缜密的风格。这本PDF是全网对动规最深刻的讲解系列。 如何使用动态规划专题精讲 使用动态规划专题精讲非常简单，只需要按照顺序刷题，...
5LeetCode专题解答.docx
08-04
leetcode专题解答 - BFS（Breadth First Search，广度优先搜索） BFS是leetcode中的一种常见的解题方法，广泛应用于树和图的遍历。下面我们将深入讨论BFS的基本概念、树和图的BFS区别、leetcode中的一道典型BFS应用...
leetcode:leetcode专题算法总结golang
03-20
方法一：迭代 思路：将当前例程的下一个指针更改指向前一个例程。 func reverseList ( head * ListNode ) * ListNode { var prev * ListNode curr := head for curr != nil { next := curr ....
leetcode叫数-lf-leetcode:leetcode专题
06-30
leetcode专题 参考博客： github： 1.术语说明 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成...
leetcode和oj-Dynamic-Programming-9C:九章算法动态规划专题相关代码
06-30
leetcode 和 oj 简介 :balloon: 题目为九章算法DP专题中讲到的题目。 :balloon: 每道题目有好几个程序，这是因为，大部分题目我都是先自己做，然后再对照老师的讲解，修改自己的程序。 :balloon: 另外吐槽一下lint ...
leetcode系列-动态规划
dafeng_xiaobai的博客
06-01 398
动态规划 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] 确定递推公式 为什么这是一道非常简单的入
动态规划算法——40道leetcode实例入门到熟练
qq_59708493的博客
05-06 868
链接:1049. 最后一块石头的重量 IIi ++) {//将stones数组一分为二，找到重量最接近target的dp数组 int dp [ ] = new int [ target + 1 ];//默认初始化为0 for(int i = 0;i ++) {//先遍历石头 for(int j = target;j --) {
【Leetcode刷题】动态规划
m0_51976564的博客
01-20 364
Leetcode5.最长回文子串 Leetcode62.不同路径 Leetcode63.不同路径 II Leetcode121.买卖股票的最佳时机 Leetcode122.买卖股票的最佳时机 II Leetcode123.买卖股票的最佳时机 III Leetcode188.买卖股票的最佳时机 IV Leetcode309.最佳买卖股票时机含冷冻期 Leetcode53.最大子数组和 Leetcode152.乘积最大子数组 Leetcode91.解码方法 Leetcode97.交错字符串
【LeetCode刷题笔记】动态规划（一）
川峰的博客
12-23 1175
LeetCode刷题笔记之动态规划篇（一）。
【Leetcode 专题六】动态规划专题
qq_38253797的博客
03-21 655
目录一、一般问题系列1.1、题目汇总leetcode 509. 斐波那契数leetcode 70. 爬楼梯leetcode 343. 整数拆分leetcode 343. 整数拆分剑指 Offer 62. 圆圈中最后剩下的数字（约瑟夫环问题 难 地推公式没懂）二、背包系列三、打家劫舍系列四、股票问题系列五、子序列问题系列六、路径规划系列 动态规划的核心就是最优化问题。核心是穷举。 判断可不可以用动态规划：当前的状态取决于前一个时刻的状态。 动态规划的特点： 1、重叠子问题 2、状态转移方程 3、最优子结构
leetcode动态规划
qq_43283527的博客
04-16 653
最优子结构 子问题最优问题可导出原问题最优决策 无后效性 重叠子问题 去冗余 空间换时间 基本步骤： 设计暴力算法，找到冗余 设计并储存状态 递归式（状态转移方程） 自底向上计算最优解（编程方式） 例题： 983. 最低票价 在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 ...
leetcode-动态规划
SunYutong_1234的博客
03-02 738
动态规划有自底向上和自顶向下两种解决问题的方式。自顶向下即记忆化递归，自底向上就是递推。
leetcode动态规划题型整理
A24565的博客
07-04 293
动态规划 动态规划核心问题怎么找DP，如果是矩阵路径类的题很容易想到dp[i][j]，但是并非所有题都可以清楚找到DP项。 DP引子：斐波那契额数列 剑指 Offer 10- II. 青蛙跳台阶问题 //该题为斐波那契额数列变种，是dp问题中最经典题型，dp[i] = dp[i-1]+dp[i-2],由于dp只与前两项有关，所以可以优化dp将空间复杂度降低为O(1) class Solution{ public: int numWays(int n) { if(n<=1) re
「代码随想录」动态规划专题精讲（v2.0）.pdf
最新发布
04-22
通过阅读这本PDF，学习者将有机会系统地学习40多道LeetCode的经典动态规划题目，深入了解动态规划的各个分支，以及一套连贯的方法论。这是一本致力于提升读者动态规划技能，帮助他们在算法领域取得突破的珍贵资源。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值