力扣练习1：dp

最新推荐文章于 2025-03-08 09:36:36 发布

水木糸

最新推荐文章于 2025-03-08 09:36:36 发布

阅读量228

点赞数

文章标签： java leetcode 动态规划

本文链接：https://blog.youkuaiyun.com/qq_44467578/article/details/104115451

版权

本文探讨了动态规划在解决实际问题中的应用，如买卖股票的最佳时机II，通过确定状态和边界条件，找出最优策略。此外，还讨论了如何找到最长回文子串，同样利用动态规划解决，分析子问题并建立状态转移方程。最后提到了三角形最小路径和的问题，通过从底向上逐层计算，找到到达底层的最短路径。

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

买卖股票的最佳时机 II
子问题
每天的股票是否买入
确定状态
cash 每天持有的现金 precash 昨天持有的现金
stock 每天持有的股票 prestock 昨天持有的股票
边界状态
第一天是否买入股票
否 cash=0；是 stock=-prices[i]
状态转移
cash=Math.max(precash,prestock+prices[i]);//继续不买，还是昨天买今天卖
stock=Math.max(prestock,precash-prices[i]);//继续持有，还是昨天不买今天买

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length<2){
            return 0;
        }
        int cash=0;
        int stock=-prices[0];
        int precash;
        int prestock;
        for(int i=1;i<prices.length;i++){
            precash=cash;
            prestock=stock;

            cash=Math.max(precash,prestock+prices[i]);
            stock=Math.max(prestock,precash-prices[i]);
        }
        return cash;
    }
}

最长回文子串
子问题
每个子串是否为回文，输出最长的一个
确定状态
dp[i][j]：i~j是否为回文
边界状态
dp[i][i]，单独一个字符也是回文
状态转移
i~j若为回文，则头尾相同，且内部是回文
dp[i][j]= (i==j && dp[i+1][j-1])
有[i+1][j-1],就要考虑边界，显然，如果i+1~j-1不成区间，也就是内部是一个单字或者是空的情况下，只要头尾相等，他就是回文。
即 j-1-(i+1)+1<2 => j-i<3 时，直接判定是回文

class Solution {
    public String longestPalindrome(String s) {
        
        int len=s.length();

        if(len<2){
            return s;
        }

        boolean[][] dp=new boolean[len][len];
        int maxlen=1;
        int start=0;

        for(int i=0;i<len;i++){
            dp[i][i]=true;
        }

        for(int j=1;j<len;j++){
            for(int i=0;i<j;i++){
                if(s.charAt(i)==s.charAt(j)){
                    if(j-i<3){
                        dp[i][j]=true;
                    }else{
                        dp[i][j]=dp[i+1][j-1];
                    }
                }else{
                    dp[i][j]=false;
                }

                if(dp[i][j]){
                    int xlen=j-i+1;
                    if(xlen>maxlen){
                        maxlen=xlen;
                        start=i;
                    }
                    
                }
            }
        }
        return s.substring(start, start + maxlen);
    }
}

三角形最小路径和
子问题
从底向上，每一层到达底层的最小路径和
确定状态
dp[i]：该层i位置到达底层的最短路径和
边界状态
处于底层
状态转移
每一层dp[i]+=下一层Math.min(dp[i],dp[i+1])

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
         if (triangle == null || triangle.size() == 0){
            return 0;
        }
        //创建时+1，方便底层初始化
        int[] dp = new int[triangle.size()+1];
		//从底层向上
        for (int i = triangle.size() - 1; i >= 0; i--) {
            List<Integer> curTr = triangle.get(i);
            //该层每一个位置到达底层的最短路径
            for (int j = 0; j < curTr.size(); j++) {
                dp[j] = Math.min(dp[j],dp[j+1]) + curTr.get(j);
            }
        }
        return dp[0];
    }
}