JAVA-动态规划常考题汇总

JAVA-动态规划高频面试题汇总

小编统计出了动态规划中常考题,附上了题目出处以及最优解法.接下来还会进行其他模块的总结,有一起在准备暑期实习的JAVA软开伙伴可以一起交流!

1.打家劫舍

class Solution {
     
    public int rob(int[] nums) {
     
        if(nums.length==0) return 0;   //长度为0和1时要考虑,否则后面会越界
        if(nums.length==1) return nums[0];
       int[] dp = new int[nums.length];
       dp[0] = nums[0];
       dp[1] = Math.max(nums[0], nums[1]); //初始化要注意,dp[1]也要考虑max
    for(int i = 2; i < nums.length; i++){
     
      dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]); //转移方程
    }
    return dp[nums.length-1];
    }
}

2.连续子数组的最大和

这题和上一题很像，对比二者转移方程

class Solution {
     
    public int maxSubArray(int[] nums) {
     
   int[] dp=new int[nums.length];
   dp[0]=nums[0];
   int res=dp[0];
   for(int i=1;i<dp.length;i++){
     
       dp[i]=Math.max(nums[i],dp[i-1]+nums[i]);  //转移方程
       res=Math.max(res,dp[i]);
   }
   return res; 
    }
}

3.零钱兑换

class Solution {
     
    public int coinChange(int[] coins, int amount) {
     
        int[] dp = new int[amount+1];
        dp[0] = 0;
        for(int i = 1; i <= amount; i++){
     
            int min = Integer.MAX_VALUE; //设个最大值 为了最终确定哪些值取不到
            for(int coin:coins){
     
                if(coin <= i && dp[i-coin]!=-1){
       // dp[i-coin]!=-1确保dp[i-coin]可以被取到
                    min = Math.min(dp[i - coin] + 1, min);  //假设i=100,要凑到100，然后依次遍历硬币值1，2，5，代表                                              了1与99的最优凑，2与98的最有凑，5与95的最优凑，+1代表该硬币的一个数量
                }
            }
            dp[i] = min == Integer.MAX_VALUE ? -1 : min;  //取不到的dp[i]就是-1
        }
        return dp[amount];
    }
}

4.最小路径和

 public int minPathSum(int[][] grid) {
     
int m = grid.length;
    int n = grid[0].length;
    if (m <= 0 || n <= 0) {
     
        return 0;
    }
    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 i = 1; i < n; i++){
     
      dp[0][i] = dp[0][i-1] + grid[0][i]; // 初始化最上边的行
    }
    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]; // 推导出 dp[m-1][n-1]
        }
    }
    return dp[m-1][n-1];
    }

5.矩形覆盖

https://www.nowcoder.com/questionTerminal/72a5a919508a4251859fb2cfb987a0e6

n块矩形有f(n)种覆盖方法。进行逆向分析，要完成最后的搭建有两种可能。

第一种情况等价于情形1中阴影部分的n-1块矩形有多少种覆盖方法，为f(n-1);

第二种情况等价于情形2中阴影部分的n-2块矩形有多少种覆盖方法，为f(n-2);

故f(n) = f(n-1) + f(n-2)，还是一个斐波那契数列。。。。

且f(1) = 1, f(2) = 2，代码如下

public class Solution {
     
    public int RectCover(int target) {
     
   if(target<=2) return target;
        int a=1,b=2;
        for(int i=3; i<=target ; i++){
     
            int temp=a+b;
            a=b;
            b=temp;
        }
        return b;
    }
}

6.变态跳台阶

public int JumpFloorII(int target) {
     
        if(target <= 2) return target; 
       int[] dp =new int[target+1];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        for(int m = 3; m <= target; m++){
     
            dp[m] = 0;
            for(int n = 0; n < m; n++){
        //简便方法直接替代：   dp[m] = 2*dp[m-1];
                dp[m] = dp[m] + dp[n];   
            }
        }
        return dp[target];
    }

简便方法

7.不同的二叉搜索树

class Solution {
     
    public int numTrees(int n) {
     
        int[] dp = new int[n+1];
        dp[0] = 1;
         dp[1] = 1;
        for(int i = 2; i <= n; i++){
     
            dp[i] = 0;
            for(int j = 1; j <= i; j++){
     
                dp[i] = dp[i] +dp[j-1]*dp[i-j];  //这里要特别注意  i和j的书写
            }
        }
        return dp[n];
    }
}

8.买卖股票的最佳时机

class Solution {
     
    public int maxProfit(int[] prices) {
     
        int maxprofit = 0;
        int minprice = Integer.MAX_VALUE;
        for(int i=0; i<prices.length; i++){
     
            if(prices[i]<minprice){
     
                minprice = prices[i];
            }else if(prices[i] - minprice > maxprofit){
     
                maxprofit = prices[i] - minprice;
            }
        }
        return maxprofit;
    }
}