leetcode打卡-动态规划

已于 2023-03-18 09:43:56 修改
阅读量250 收藏 1
点赞数 1
分类专栏： 算法 文章标签： leetcode 动态规划 算法
于 2023-03-13 22:49:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43093878/article/details/129506065
版权

97. 交错字符串

leetcode题目链接：https://leetcode.cn/problems/interleaving-string/

leetcode AC记录：

思路：话不多说，动态规划。使用dp[i][j]表示s1从下标0开始，长度为i的子串，和s2从下标0开始，长度为j的子串，能否构成下标从0开始，长度为i+j的子串。状态转移方程为dp[i][j] = (dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1)) || (dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1))。

代码如下：

public boolean isInterleave(String s1, String s2, String s3) {
        boolean[][] dp = new boolean[s1.length()+1][s2.length()+1];

        if(s2.length() + s1.length() != s3.length()) {
            return false;
        }

        //dp[i][j]表示s1从下标0开始，长度为i的子串，和s2从下标0开始，长度为j的子串，能否构成下标从0开始，长度为i+j的子串
        //状态转移方程为dp[i][j] = (dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1)) || (dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1))
        
        dp[0][0] = true;

        for(int i = 0;i <= s1.length();i++) {
            for(int j = 0;j <= s2.length();j++) {
                if(i > 0 && j > 0) {
                    dp[i][j] = (dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1)) || (dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1));
                } else if(i > 0) {
                    dp[i][j] = dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1);
                } else if(j > 0) {
                    dp[i][j] = dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1);
                }
            }
        }

        return dp[s1.length()][s2.length()];
    }

 221. 最大正方形

leetcode题目链接：https://leetcode.cn/problems/maximal-square/

leetcode AC记录：

思路：最大正方形，使用dp[i][j]表示以i，j为正方形右下角顶点的最大边长。状态转移方程为dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])。初始化边缘，即i=0,j=[0-length]和i=[0-length][0]为如果[i][j]为1，则面积为1，否则为0。中间使用结果记录最大边长，最后结果是边长的乘积。

代码如下：

public int maximalSquare(char[][] matrix) {
        //使用dp[i][j]表示以i，j为正方形右下角的最大正方形面积
        //dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
        int[][] dp = new int[matrix.length][matrix[0].length];
        int res = 0;
        
        //初始化dp数组
        for(int i = 0;i < matrix.length;i++) {
            if(matrix[i][0] == '1') {
                dp[i][0] = 1;
                res = 1;
            }
        }

        for(int i = 0;i < matrix[0].length;i++) {
            if(matrix[0][i] == '1') {
                dp[0][i] = 1;
                res = 1;
            }
        }

        for(int i = 1;i < matrix.length;i++) {
            for(int j = 1; j < matrix[0].length;j++) {
                if(matrix[i][j] == '1') {
dp[i][j] = Math.min(dp[i-1][j-1], Math.min(dp[i][j-1], dp[i-1][j])) + 1;
                }
                
                if(res < dp[i][j]) {
                    res = dp[i][j];
                }
            }
        }
        
        
        return res * res;
    }

509. 斐波那契数

leetcode题目链接：https://leetcode.cn/problems/fibonacci-number/


leetcode AC记录：

代码如下：

 public int fib(int n) {
        if(n <= 1) {
            return n;
        }

        int a = 0;
        int b = 1;
        int c = 0;
        for(int i = 2;i <= n;i++) {
            c = a + b;
            a = b;
            b = c;
        }

        return c;
    }

70. 爬楼梯

leetcode题目链接：https://leetcode.cn/problems/climbing-stairs

leetcode AC记录：

代码如下：

public int climbStairs(int n) {
        if(n <= 1) {
            return n;
        }

        int a = 1;
        int b = 1;
        int c = 0;
        for(int i = 2;i <= n;i++) {
            c = a+b;
            a = b;
            b = c;
        }
        return c;
    }

746. 使用最小花费爬楼梯

leetcode题目链接：https://leetcode.cn/problems/min-cost-climbing-stairs

leetcode AC记录：

思路：使用dp[i]表示到下标为i所付出的成本，状态转移方程：dp[i] = min(dp[i-1],dp[i-2]) + cost[i]。

代码如下：

public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length];
        //使用dp[i]表示到下标为i所付出的成本
        //状态转移方程：dp[i] = min(dp[i-1],dp[i-2]) + cost[i]
        dp[0] = cost[0];
        dp[1] = cost[1];

        for(int i = 2;i < cost.length;i++) {
            dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
        }

        return Math.min(dp[cost.length-1], dp[cost.length-2]);
    }

1137. 第 N 个泰波那契数

leetcode题目链接：https://leetcode.cn/problems/n-th-tribonacci-number/

leetcode AC记录：

代码如下：

public int tribonacci(int n) {
        
        if(n == 0) {
            return 0;
        } else if(n <= 2) {
            return 1;
        }

        int a = 0;
        int b = 1;
        int c = 1;
        int d = 0;
        for(int i = 3;i <= n;i++) {
            d = a + b + c;
            a = b;
            b = c;
            c = d;
        }
        return d;
    }

 873. 最长的斐波那契子序列的长度

leetcode题目链接：https://leetcode.cn/problems/length-of-longest-fibonacci-subsequence

leetcode AC记录：

思路：使用dp[j][i]表示以j和i下标所在位置为末尾的斐波纳切数列的最大长度。状态转移方程为：dp[j][i] =

Math.max(dp[index][j] + 1, 3)，index < j && index >= 0

0， index = -1

其中使用map记录arr[i]和i的关系，index = map.getOrDefault(arr[i]-arr[j], -1)

代码如下：

public int lenLongestFibSubseq(int[] arr) {
        //使用dp[i][j]表示数组arr以下标i作为结尾的斐波那契数列最大长度，j为最长菲波纳切数列的倒数第二个元素下标
        Map<Integer, Integer> map = new HashMap<>(arr.length);
        for(int i = 0; i < arr.length;i++) {
            map.put(arr[i], i);
        }

        int[][] dp = new int[arr.length][arr.length];
        int res = 0;
        for(int i = 2;i < arr.length;i++) {
            for(int j = i-1; j >= 0;j--) {
                int diff = arr[i] - arr[j];
                int index = map.getOrDefault(diff, -1);
                if(index >= 0 && index < j) {
                    dp[j][i] = Math.max(dp[index][j] + 1, 3);
                }

                if(res < dp[j][i]) {
                    res = dp[j][i];
                }
            }
        }

        return res;
    }

62. 不同路径

leetcode题目链接：https://leetcode.cn/problems/unique-paths

leetcode AC记录：

代码如下：

public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for(int i = 0;i < m;i++) {
            dp[i][0] = 1;
        }

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

        for(int i = 1;i < m;i++) {
            for(int j = 1;j < n;j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }

        return dp[m-1][n-1];

    }

63.不同路径II

leetcode题目链接：https://leetcode.cn/problems/unique-paths-ii/

leetcode AC记录：

思路：如果obstacleGrid[0][0]等于1的话，直接返回0。使用动态规划，dp[i][j]保存的是从 0,0 到当前位置的路径总和，初始化操作：

初始化dp数组第一列和第一行，如果当前数字为1，dp数组的值为0；如果当前数字为0的话，dp数组的值为1；

遍历obstacleGrid数组，如果当前位置的值是1的话，路径和为0；如果当前位置的值是0的话，路径和的状态转移方程为dp[i][j]=dp[i-1][j-1]。

代码如下：

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];

        if(obstacleGrid[0][0] == 1) {
            return 0;
        }

        dp[0][0] = 1;

        for(int i = 1;i < obstacleGrid.length;i++) {
            if(obstacleGrid[i][0] == 0) {
                dp[i][0] = dp[i-1][0] == 0 ? 0 : 1;
            }
        }

         for(int i = 1;i < obstacleGrid[0].length;i++) {
            if(obstacleGrid[0][i] == 0) {
                dp[0][i] = dp[0][i-1] == 0 ? 0 : 1;
            }
        }

        for(int i = 1;i < obstacleGrid.length;i++) {
            for(int j = 1;j < obstacleGrid[0].length;j++) {
                if(obstacleGrid[i][j] == 0) {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
            }
        }

        return dp[obstacleGrid.length-1][obstacleGrid[0].length-1];
        
    }

343. 整数拆分

leetcode题目链接：https://leetcode.cn/problems/integer-break

leetcode AC记录：

思路：动态规划，使用dp[i]存储整数和为i的最大乘积。状态转移方程为dp[i] = max(dp[j] * (i-j), dp[i], (i-j)* j)。

代码如下：

public int integerBreak(int n) {
        //dp【i】数组表示以i为和的最大乘积
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;

        for(int i = 3;i <= n;i++) {
            for(int j = i-1;j >= 1;j--) {
                dp[i] = Math.max(Math.max(dp[j] * (i-j), dp[i]), j * (i-j));
            }
        }

        return dp[n];
    }

96. 不同的二叉搜索树

leetcode题目链接：https://leetcode.cn/problems/unique-binary-search-trees

leetcode AC记录：

思路：使用动态规划。dp[i]表示以节点1到i组成的二叉搜索树的总量，状态转移方程为dp[i] = sum(dp[k] * dp[i-k-1])。因为都是顺序递增的，所以说只用关心节点的数量就行，不用关心节点具体的值。举个例子，比如以1到3组成的二叉搜索树的总量计算过程为：分别以1，2，3为头节点，

以1为头节点时，将数组分为左右子树【左子树：null】【头节点1】【右子树：2，3】，结果为dp[0] * dp[2];

以2为头节点时，将数组分为左右子树【左子树：1】【头节点2】【右子树：3】，结果为dp[1] * dp[1]；

以3为头节点时，将数组分为左右子树【左子树：1，2】【头节点3】【右子树：null】，结果为dp[2] * dp[0]；

所以dp[3] = dp[0] * dp[2] + dp[1] * dp[1]  + dp[2] * dp[0]，符合我们的状态转移方程。

其中，初始化操作为：dp[0] = 1, dp[1] = 1, dp[2] = 2。

代码如下：

 public int numTrees(int n) {
        //使用dp【i】表示以节点1到i的二叉搜索树的总量
        //状态转移方程为dp[i] = sum(dp[k] * dp[i-k-1])
        int[] dp = new int[n+1];
        if(n <= 2) {
            return n == 2 ? 2 : 1;
        }
        
        dp[0] =1;
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3;i <= n;i++) {
            for(int k = 0;k < i;k++) {
                dp[i] += dp[k] * dp[i-k-1];
            }
        }

        return dp[n];
    }

279.完全平方数

leetcode题目链接：https://leetcode.cn/problems/perfect-squares/

leetcode AC记录：

思路：动态规划，使用dp[i]表示组成和为i的完全平方数的最小个数。状态转移方程为dp[i] = dp[i-j*j] +1。

代码如下：

public int numSquares(int n) {
        //使用动态规划
        //状态转移方程为dp[i] = dp[j] + dp[i-(j*j)]
        int[] dp = new int[n+1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2;i <= n;i++) {
            for(int j = 1;j * j <= n;j++) {
                if(i - j*j >= 0) {
                    dp[i] = Math.min(dp[i-j*j]+1, dp[i]);
                }
            }
        }
        return dp[n];
    }

 

川夜施密特
关注
专栏目录
leetcode卡-Daily-LeetCode-:每天一题LeetCode打卡
07-06
1. **巩固基础知识**：LeetCode的题目涵盖了许多基础数据结构（如数组、链表、栈、队列、树等）和算法（如排序、搜索、动态规划等），每天一题可以帮助你不断巩固和深化这些基础知识。 2. **提升解决问题的能力**：...
leetcode卡-leetCode:leetCode打卡#
07-06
【标题】"leetCode卡-leetCode:leetCode打卡#"涉及的是在leetCode平台上进行算法训练和打卡的活动。leetCode是一个在线编程平台，它提供了大量的编程题目，旨在帮助程序员提升算法技能，尤其是对于准备面试或者希望...
leetcode打卡-贪心算法
川夜施密特的博客
03-12 346
贪心算法
leetcode打卡-二叉树II
川夜施密特的博客
02-25 415
leetcode打卡：二叉树II
leetcode打卡-回溯I
川夜施密特的博客
02-25 307
回溯算法 leetcode打卡
leetcode打卡-数学分析
川夜施密特的博客
03-17 137
leetcode打卡-数学分析
备战秋招-LeetCode 打卡-最长有效括号（动态规划）
qq_41022094的博客
08-17 239
给定一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长的包含有效括号的子串的长度。 示例 1: 输入: "(()" 输出: 2 解释: 最长有效括号子串为 "()" 示例 2: 输入: ")()())" 输出: 4 解释: 最长有效括号子串为 "()()" 题目链接（LeetCode） 思路：这题很有意思，官方提供了好几种解法，看了之后都给我耳目一新的感觉，深深感受到智商被碾压。我用的是dp ...
LeetCode打卡-day6
m0_72355692的博客
10-25 117
1480. 一维数组的动态和
LeetCode打卡-Day3
m0_72355692的博客
10-22 121
509. 斐波那契数 1492. n 的第 k 个因子 1925. 统计平方和三元组的数目
LeetCode 打卡day52--动态规划之子序列问题
weixin_45872648的博客
06-30 460
● 300.最长递增子序列 ● 674. 最长连续递增序列 ● 718. 最长重复子数组
LeetCode打卡--数学专题
The blog of XMAN
01-23 907
文章目录数学专题LeetCode 268. Missing NumberLeetCode 62. Unique PathsLeetCode 462. Minimum Moves to Equal Array Elements IILeetCode 458. Poor PigsLeetCode 319. Bulb SwitcherLeetCode 343. Integer BreakLeetCode...
leetcode卡-leetcode:leetcode打卡
07-06
3. **动态规划**：解决复杂问题时，动态规划是一种强大的工具，它通过将问题分解为子问题来求解，LeetCode中有大量动态规划题目。 4. **贪心算法**：在面对有最优解的局部最优策略问题时，贪心算法是一种有效的解决...
leetcode题库-leetcode-week-attendance:leetcode群学习打卡
06-29
leetcode群学习打卡,坚持就是胜利 加群方式 open一个issue留下微信号和刷题截图.邀请进群. 纯公益坚持自我提升群. 打卡规则 以下规则,最低满足一条: 一周最低2道,起码一道medium,时间充足建议,一周5道-10道. 参加...
leetcode卡-leetcodeSoluton:leetcode打卡
07-06
例如，二分查找、动态规划等算法在数据分析、软件开发等领域有着广泛的应用。因此，熟悉LeetCode的解题策略，对于提升个人在职场中的竞争力具有重要意义。 总的来说，这个名为“leetcodeSoluton-master”的开源项目...
C++速通LeetCode中等第3题-盛最多水的容器
lyx的博客
09-18 293
双指针法：两个指针分别指向左右边界，记录最大面积，由于面积由短板决定，两个指针中较短的短指针向内移动一格，再次记录最大面积，直到两指针相遇，得出答案。
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 352
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 735
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode 459.重复的子字符串
最新发布
weixin_50878507的博客
09-20 223
给定一个非空的字符串s，检查是否可以通过由它的一个子串重复多次构成。
宫水三叶的刷题日记：LeetCode模拟题解析
当在学习过程中遇到难题，可以加入作者提供的“每日一题打卡QQ群”，在那里与其他学习者交流，共同进步。这不仅可以解答疑惑，还能增进对算法的理解。 以题目“两数之和”为例，这是一个基础的搜索问题，可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值