动态规划问题-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_64704029/article/details/145809153

花费最小爬楼梯

dp[i]:到达i台阶所花费的最少体力是dp[i]

public int minCostClimbingStairs(int[] cost) {
    int len = cost.length;
    int[] dp = new int[len + 1];
    dp[0] = 0;
    dp[1] = 0;
    for (int i = 2; i <= len; i++) {
      dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
    }
    return dp[len];
  }

不同路径（机器人走迷宫）

从0，0到i，j有dp[i][j]种走法,dp[i][j] = dp[i-1][j]+dp[i][j-1]

public static 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];
    }

不同路径二（有障碍物）

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    int m = obstacleGrid.length;
    int n = obstacleGrid[0].length;
    int[][] dp = new int[m][n];
    for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
      dp[i][0] = 1;
    }
    for (int i = 0; i < n && obstacleGrid[0][i] == 0; i++) {
      dp[0][i] = 1;
    }
    for (int i = 1; i < m; i++) {
      for (int j = 1; j < n; j++) {
        if (obstacleGrid[i][j] == 1){
          continue;
        }
        dp[i][j] = dp[i-1][j] + dp[i][j-1];
      }
    }
    return dp[m-1][n-1];
  }

整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。
dp[i] = 分拆数字i，可以得到的最大乘积为dp[i]。

public int integerBreak(int n) {
       //dp[i] 为正整数 i 拆分后的结果的最大乘积
       int[] dp = new int[n+1];
       dp[2] = 1;
       for(int i = 3; i <= n; i++) {
           for(int j = 1; j <= i-j; j++) {
               // 这里的 j 其实最大值为 i-j,再大只不过是重复而已，
               //并且，在本题中，我们分析 dp[0], dp[1]都是无意义的，
               //j 最大到 i-j,就不会用到 dp[0]与dp[1]
               dp[i] = Math.max(dp[i], Math.max(j*(i-j), j*dp[i-j]));
               // j * (i - j) 是单纯的把整数 i 拆分为两个数 也就是 i,i-j ，再相乘
               //而j * dp[i - j]是将 i 拆分成两个以及两个以上的个数,再相乘。
           }
       }
       return dp[n];
   }

不同的二叉搜索树

dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量

public int numTrees(int n) {
    if (n == 1){
      return 1;
    }
    int[] dp = new int[n+1];
    dp[0] = 1;
    dp[1] = 1;
    for (int i = 2; i <=n; i++) {
      for (int j = 1; j <= i; j++) {
        dp[i] += dp[j-1] * dp[i-j];
      }
    }
    return dp[n];
  }

分割等和子串

给你一个只包含正整数的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。(0-1背包的变形题，)
dp[j] 表示：容量（所能装的重量）为j的背包，所背的物品价值最大可以为dp[j]。

public boolean canPartition(int[] nums) {
    if (nums == null || nums.length == 0){
      return false;
    }
    int n = nums.length;
    int sum = 0;
    for(int num : nums){
      sum+= num;
    }
    if (sum % 2 != 0){
      return false;
    }
    int target = sum / 2;
    int[] dp = new int[target + 1];
    for (int i = 0; i < n; i++) {
      for (int j = target;j>=nums[i];j--){
        dp[j] = Math.max(dp[j],dp[j-nums[i]]+nums[i]);
      }
    }
    return dp[target] == target;
  }

零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。你可以认为每种硬币的数量是无限的。（完全背包）
dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）

public int coinChange(int[] coins, int amount) {
    int max = Integer.MAX_VALUE;
    int[] dp = new int[amount+1];
    // 初始化dp为最大值
    for (int j = 0; j < dp.length; j++) {
      dp[j] = max;
    }
    dp[0] = 0;
    for (int i = 0; i < coins.length; i++) {
      for (int j = coins[i]; j <= amount; j++) {
        if (dp[j-coins[i]] != max){
          // 选择数量小的情况
          dp[j] = Math.min(dp[j],dp[j-coins[i]] + 1);
        }
      }
    }
    return dp[amount] == max ? -1 : dp[amount];
  }

零钱兑换二

dp[i][j]：使用下标为[0, i]的coins[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种组合方法。

public int change(int amount, int[] coins) {
    //dp[i][j]：使用 下标为[0, i]的coins[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种组合方法。
   int[][] dp = new int[coins.length][amount + 1];
   for(int[] row : dp){
     Arrays.fill(row,-1);// 表示没有计算过
   }
   return dfs(coins.length-1,amount,coins,dp)
  }
  private int dfs(int i, int c, int[] coins, int[][] dp) {
    if (i<0){
      return c == 0 ? 1 :0;
    }
    if (dp[i][c] != -1){
      return dp[i][c];// 计算过了
    }
    if (c<coins[i]){
      return dp[i][c] = dfs(i-1,c,coins,dp);
    }
    return dp[i][c] = dfs(i-1,c,coins,dp)+dfs(i,c-coins[i],coins,dp);
  }

打家劫舍

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

打家劫舍二

public int rob(int[] nums) {
    if (nums.length == 1){
      return nums[0];
    }
    //从第一个房屋开始到倒数第二个房屋（不偷最后一个房屋）。
    //从第二个房屋开始到最后一个房屋（不偷第一个房屋）。
    int res1 = rob1(nums,0,nums.length-2);
    int res2 = rob1(nums,1,nums.length-1);
    return Math.max(res1,res2);
  }
  private int rob1(int[] nums, int start, int end) {
    if (start == end) {
      return nums[start];
    }
    // dp[i]:下标i的房间以内偷的最多的金额
    int n = nums.length;
    int[] dp = new int[n];
    dp[start] = nums[start];
    dp[start + 1] = Math.max(dp[start], nums[start + 1]);
    for (int i = start + 2; i <= end; i++) {
      dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
    }
    return dp[end];
  }

买卖股票的最佳时机

public int maxProfit(int[] prices) {
    int pay = Integer.MAX_VALUE;
    int max = 0;
    for (int i = 0; i < prices.length; i++) {
      if (prices[i]<pay){
        pay = prices[i];
      }
      max = Math.max(max,prices[i]-pay);
    }
    return max;
  }

 public int maxProfit(int[] prices) {
    int len = prices.length;
    int[][] dp = new int[len][2];
    int res = 0;
    dp[0][0] = -prices[0];
    dp[0][1] = 0;
    for (int i = 1; i < len; i++) {
    	// dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
      dp[i][0] = Math.max(dp[i-1][0],-prices[i]);
      dp[i][1] = Math.max(dp[i-1][0]+prices[i],dp[i-1][1]);
    }
    return dp[len-1][1;]
  }

买卖股票的最佳时机二

最多只能持有一个股票
贪心：

public int maxProfit2(int[] prices) {
    // 只求为正的情况
    int sum = 0;
    for (int i = 0; i < prices.length - 1; i++) {
      if (prices[i+1]-prices[i] > 0){
        sum+=prices[i+1]-prices[i];
      }
    }
    return sum;
  }

动态规划：

public int maxProfit2(int[] prices) {
    int n = prices.length;
    int[][] dp = new int[n][2];
    //dp[i][0] 表示在第 i 天没有持有股票的最大利润。
    //dp[i][1] 表示在第 i 天持有股票的最大利润。
    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 len = prices.length;
        if (len == 0) {
            return 0;
        }
        int[][] dp = new int[len][5];
        // 初始化
        dp[0][0] = 0;// 不操作
        dp[0][1] = -prices[0];// 第一次持有股票的状态
        dp[0][2] = 0;
        dp[0][3] = -prices[0];// 第二次持有股票的状态
        dp[0][4] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][1] = Math.max(dp[i - 1][1], dp[i][0] - prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2], dp[i-1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3], dp[i-1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4], dp[i-1][3] + prices[i]);
        }
        return dp[len - 1][4];
    }

最长递增子序列

dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

public int lengthOfLIS(int[] nums) {
    int[] dp = new int[nums.length];
    Arrays.fill(dp,1);
    int res =1;
    for(int i = 1;i<dp.length;i++){
      for(int j=0;j<i;j++){
        if(nums[i]>nums[j]){
          dp[i] = Math.max(dp[i],dp[j]+1);
        }
      }
      res = Math.max(res,dp[i]);
    }
    return res;
  }

最长连续递增序列

public int findLengthOfLCIS(int[] nums) {
    if (nums.length == 1) {
      return 1;
    }
    int[] dp = new int[nums.length];
    Arrays.fill(dp,1);
    int res = 0;
    for (int i = 1; i < dp.length; i++) {
      if (nums[i] > nums[i-1]){
        dp[i] = dp[i-1] + 1;
      }
      res = Math.max(res,dp[i]);
    }
    return res;
  }

最长重复子数组

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]

public int findLength(int[] nums1, int[] nums2) {
    int res = 0;
    int[][] dp = new int[nums1.length+1][nums2.length+1];
    for (int i = 1; i <= nums1.length; i++) {
      for (int j = 1; j <= nums2.length; j++) {
        if (nums1[i-1] == nums2[j-1]){
          dp[i][j] = dp[i-1][j-1]+1;
        }else{
          dp[i][j] = 0;
        }
        res = Math.max(res,dp[i][j]);
      }
    }
    return res;
  }

最长公共子序列

public int longestCommonSubsequence(String text1, String text2) {
        //明确dp
        //dp[i][j]表示从0-（i-1）和0-（j-1）中最长公共子序列的长度
        int[][] dp = new int[text1.length()+1][text2.length()+1];
        dp[0][0] = 0;
        int res = 0;
        for (int i = 1; i <= text1.length(); i++) {
            char t = text1.charAt(i-1);
            for (int j = 1; j <= text2.length(); j++) {
                if (t == text2.charAt(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[text1.length()][text2.length()];
    }

最大子数组和

public int maxSubArray(int[] nums) {
        //dp[i]:以nums[i]为结尾的最大连续子序列的和是dp[i]
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int res = dp[0];
        for(int i=1;i<nums.length;i++){
            dp[i] = Math.max(dp[i-1]+nums[i],nums[i]);
            res = res>dp[i]?res:dp[i];
        }
        return res;
    }

编辑距离

public int minDistance(String word1, String word2) {
    //dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。
    int m = word1.length();
    int n = word2.length();
    int[][] dp = new int[m+1][n+1];
    for (int i = 1; i <= m ; i++) {
      dp[i][0] = i;
    }
    for (int i = 0; i <= n; i++) {
      dp[0][i] = i;
    }
    for (int i = 1; i <= m; i++) {
      for (int j = 1; j <= n; j++) {
        if (word1.charAt(i-1) == word2.charAt(j-1)){
          dp[i][j] = dp[i-1][j-1];
        }else {
          // 总共有三种情况，但是这里添加和删除是反向操作看作是一种
          dp[i][j] = Math.min(Math.min(dp[i-1][j-1],dp[i][j-1]),dp[i-1][j])+1;
        }
      }
    }
    return dp[m][n];
  }

单词拆分

public boolean wordBreak(String s, List<String> wordDict) {
    // 完全背包的思路，dp[i]:长度为i，能否组成
    HashSet<String> set = new HashSet<>(wordDict);
    boolean[] valid = new boolean[s.length() + 1];
    valid[0] = true;
    for (int i = 1; i <= s.length(); i++) {
        for (int j = 0; j < i && !valid[i]; j++) {
            if (set.contains(s.substring(j, i)) && valid[j]) {
                valid[i] = true;
            }
        }
    }
    return valid[s.length()];
}

最长回文子序列

public int longestPalindromeSubseq(String s) {
    //dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
    int len = s.length();
    int[][] dp = new int[len+1][len+1];
    // 因为是回文所以要从两边开始遍历
    for (int i = len - 1; i >= 0; i--) {
      dp[i][i] = 1;//初始化情况，走到最中间i=j,这里写成i=i
      for (int j = i + 1; j < len; j++) {
        if (s.charAt(i) == s.charAt(j)){
          dp[i][j] = dp[i+1][j-1] + 2;
        }else{
          dp[i][j] = Math.max(dp[i+1][j],Math.max(dp[i][j],dp[i][j-1]));
        }
      }
    }
    return dp[0][len-1];
  }

最长回文子串

public class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) {
            return "";
        }
        
        int start = 0; // 最长回文子串的起始位置
        int end = 0;   // 最长回文子串的终止位置

        for (int i = 0; i < s.length(); i++) {
            // 以 s[i] 为中心的回文
            int len1 = expandAroundCenter(s, i, i);
            // 以 s[i] 和 s[i + 1] 为中心的回文
            int len2 = expandAroundCenter(s, i, i + 1);
            // 取最大长度
            int len = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2; // 更新起始位置
                end = i + len / 2;         // 更新终止位置
            }
        }
        
        return s.substring(start, end + 1); // 返回最长回文子串
    }

    private int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1; // 返回回文长度
    }
}