Leetcode系列：动态规划-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41073619/article/details/147183858

118. 杨辉三角

class Solution {
    public List<List<Integer>> generate(int numRows) {

        List<List<Integer>> ans = new ArrayList<>();

        if(numRows==0) return ans;

        ans.add(new ArrayList<Integer>());
        ans.get(0).add(1);
        
        for(int i=0; i<numRows-1; i++){
            List<Integer> newList = new ArrayList<>();
            List<Integer> preList = ans.get(i);

            newList.add(1);
            for(int j=1; j<i+1; j++){
                newList.add(preList.get(j-1)+preList.get(j));
            }
            newList.add(1);
            ans.add(newList);
        }
        return ans; 
    }
}

198. 打家劫舍（⭐）

class Solution {
    public int rob(int[] nums) {

        int len = nums.length;
        int[] dp = new int[len+1];

        dp[0]=0;
        dp[1]=nums[0];

        for(int i=1; i<len; i++){
            dp[i+1]=Math.max(dp[i], nums[i]+dp[i-1]);
        }

        /*
        int ans=0;
        for(int i=0; i<len+1; i++){
            ans=Math.max(ans, dp[i]);
        }
        return ans;
        */
        return dp[len];
    }
}

279. 完全平方数

class Solution {
    public int numSquares(int n) {

        int dp[] = new int[n+1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0]=0;

        for(int i=1; i<n+1; i++){//dp的index 从0到n
            int x = i*i;
            for(int j=1; j*j<n+1; j++){//从1开始的完全平方数：1、4、9、16
                if(i-j*j>=0)
                    dp[i] = Math.min(dp[i], dp[i-j*j]+1);//从前到后遍历更新
            }
        }

        return dp[n];
    }
}

322. 零钱兑换

class Solution {
    public int coinChange(int[] coins, int amount) {

        int n = coins.length;
        int dp[] = new int[amount+1];
        Arrays.fill(dp, amount+1);
        dp[0]=0;

        for(int i=1; i<amount+1; i++){
            for(int j=0; j<n; j++){
                if(i-coins[j]>=0)
                    dp[i] = Math.min(dp[i], dp[i-coins[j]]+1);
            }
        }

        return dp[amount] == amount+1 ? -1 : dp[amount];
    }
}

139. 单词拆分

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int len = s.length();
        boolean[] dp = new boolean[len+1];
        Arrays.fill(dp, false);
        dp[0]=true;

        for(int i=1; i<len+1; i++){
            for(int j=0; j<i; j++){
                boolean flag = wordDict.contains(s.substring(j, i));
                //flag指后面的词在wordDict里面
                //dp[j]指前面的词已经符合条件，能被后面复合的接上
                if(flag && dp[j]){
                    dp[i]=true;
                    break;//有没有都行
                } 
            }
        }
        return dp[len];
        
    }
}

300. 最长递增子序列（⭐）

动态规划设计方法&&纸牌游戏讲解二分解法 300. 最长递增子序列 - 力扣（LeetCode）

class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;

        if(len == 0) return 0;

        int[] dp = new int[len];

        Arrays.fill(dp, 1);

        for(int i=0; i<len; i++){//dp数组下标
            for(int j=0; j<i; j++){//nums数组下标
                if(nums[i]>nums[j])
                    dp[i] = Math.max(dp[i], dp[j]+1);
            }
        }
        
        int ans=0;

        for(int i=0; i<len; i++){
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}

152. 乘积最大子数组

小姐姐刷题-Leetcode 152 乘积最大子数组动态规划_哔哩哔哩_bilibili

class Solution {
    public int maxProduct(int[] nums) {
        int ans = Integer.MIN_VALUE;
        int len = nums.length;

        int[] cur_max = new int[len];
        int[] cur_min = new int[len];
        cur_max[0]=cur_min[0]=nums[0];

        for(int i=1; i<len; i++){
            cur_max[i]=Math.max(nums[i]*cur_max[i-1], nums[i]*cur_min[i-1]);
            cur_max[i]=Math.max(nums[i], cur_max[i]);

            cur_min[i]=Math.min(cur_min[i-1]*nums[i], cur_max[i-1]*nums[i]);
            cur_min[i]=Math.min(cur_min[i], nums[i]);
        }

        for(int i=0; i<len; i++){
            ans = Math.max(ans, cur_max[i]);
        }
        return ans;
   
    }
}

多维动态规划

62. 不同路径

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(i==0 || j==0) dp[i][j]=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];
    }
}

64. 最小路径和

class Solution {
    public int minPathSum(int[][] grid) {

        int m = grid.length;
        int n = grid[0].length;

        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];

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

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

        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
        
    }
}

5. 最长回文子串（⭐）

动态规划：O（N^2）

class Solution {
    public String longestPalindrome(String s) {
        
        char[] chars = s.toCharArray();

        int len = chars.length;
        if(len==1 || len==0) return s;

        boolean[][] dp = new boolean[len][len];

        int start = 0;
        int maxLen = 1;

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

        for(int j=1; j<len; j++){
            for(int i=0; i<j; i++){
                if(chars[i]!=chars[j])
                    dp[i][j]=false;
                else{
                    //i和j挨着，说明i和j对应的字符中间只有一个字符，直接判断
                    if(j==i+1) dp[i][j]=true;
                    //i和j不挨着，说明i和j对应的字符中间多于一个字符，用数组递推
                    if(j>i+1)  dp[i][j]=dp[i+1][j-1];
                }

                if(dp[i][j] && j-i+1>maxLen){
                    start=i;
                    maxLen=j-i+1;
                }
            }
        }

        return s.substring(start, start+maxLen);

        
    }
}

暴力：O（N^3）

class Solution {
    public String longestPalindrome(String s) {
        
        char[] chars = s.toCharArray();

        int len = chars.length;
        if(len==1 || len==0) return s;

        int start = 0;
        int maxLen = 1;

        for(int i=0; i<len-1; i++){
            for(int j=1; j<len; j++){
                if(j+1-i>maxLen && isPalindrome(chars, i, j)){
                    start=i;
                    maxLen=j+1-i;
                }
            }
        }

        return s.substring(start, start+maxLen);

        
    }

    public boolean isPalindrome(char[] chars, int left, int right){
        
        while(left<right){
            if(chars[left]==chars[right]){
                left++;
                right--;
            }else
                return false;
        }
        return true;
    }
}

1143. 最长公共子序列（⭐）

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int l_len = text1.length();
        int r_len = text2.length();

        char[] l_chars = text1.toCharArray();
        char[] r_chars = text2.toCharArray();

        int[][] dp = new int[l_len+1][r_len+1];

        for(int i=0; i<l_len; i++){
            for(int j=0; j<r_len; j++){
                if(i==0 || j==0)
                    dp[i][j]=0;
            }
        }
        

        for(int i=1; i<l_len+1; i++){
            for(int j=1; j<r_len+1; j++){
                if(l_chars[i-1]==r_chars[j-1])
                    dp[i][j] = dp[i-1][j-1]+1;
                else
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
            }
        }

        return dp[l_len][r_len];
    }
}

72. 编辑距离

class Solution {
    public int minDistance(String word1, String word2) {
        int l_len = word1.length();
        int r_len = word2.length();

        char[] l_chars = word1.toCharArray();
        char[] r_chars = word2.toCharArray();

        int[][] dp = new int[l_len+1][r_len+1];

        for(int i=0; i<=l_len; i++){
            for(int j=0; j<=r_len; j++){
                if(i==0 || j==0) dp[i][j] = i==0 ? j : i;
            }
        }

        for(int i=1; i<=l_len; i++){
            for(int j=1; j<=r_len; j++){
                if(l_chars[i-1] != r_chars[j-1]){
                    dp[i][j] = Math.min(dp[i][j-1], dp[i-1][j])+1;
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1]+1);
                }else
                    dp[i][j]=dp[i-1][j-1];
                   
            }
        }
        return dp[l_len][r_len];
    }
}