动态规划相关题目

最新推荐文章于 2024-07-25 10:54:19 发布

Holmes Zhu

最新推荐文章于 2024-07-25 10:54:19 发布

阅读量100

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.youkuaiyun.com/hbkzhu13579/article/details/111826396

版权

数据结构与算法专栏收录该内容

23 篇文章

订阅专栏

博客介绍了《剑指offer》和LeetCode相关题目。《剑指offer》包含斐波那契数列、跳台阶等入门题目，均用Java实现；LeetCode有买卖股票最佳时机系列题解参考，还给出了最长回文子串、最大子序和等题目的链接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

《剑指offer》相关题目

这几道题目比较简单，算是入门题目

《剑指offer》系列斐波那契数列（Java）

《剑指offer》系列跳台阶（Java）

《剑指offer》系列变态跳台阶（Java）

《剑指offer》系列矩形覆盖（Java）

LeetCode 相关题目

题解参考：买卖股票的最佳时机系列（Java）

题目链接：5. 最长回文子串

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        String ans = "";
        for (int l = 0; l < n; ++l) {
            for (int i = 0; i + l < n; ++i) {
                int j = i + l;
                if (l == 0) {
                    dp[i][j] = true;
                } else if (l == 1) {
                    dp[i][j] = (s.charAt(i) == s.charAt(j));
                } else {
                    dp[i][j] = (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]);
                }
                if (dp[i][j] && l + 1 > ans.length()) {
                    ans = s.substring(i, i + l + 1);
                }
            }
        }
        return ans;
    }
}

题目链接：53. 最大子序和

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int last = nums[0];
        for (int i = 1; i < nums.length; i++) {
            int curDp = last > 0 ? last + nums[i] : nums[i];
            last = curDp;
            max = Math.max(curDp, max);
        }
        return max;
    }
}

题目链接：62. 不同路径

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