实习校招面试手撕代码真题题型10——动态规划，回溯，贪心

这类题型是我的薄弱点，我好多也不会，感觉需要花比较久的时间才能掌握，时间允许的话读者可以看从这里开始看下去 回溯算法套路①子集型回溯【基础算法精讲 14】_哔哩哔哩_bilibili

但我因为时间有限，有的一下理解不了的，我就想着遇到了就换题。

1 最大数组和

（lc 53 最大子数组和 https://leetcode.cn/problems/maximum-subarray/description/）

• 思路：一开始看题目求最大，连续，想到滑动窗口。

  但实际上该题不能直接通过滑动窗口的方法来解决，原因在于这道题，我们不明确知道最佳的窗口长度是多少，且子数组的大小和位置是动态变化的，而滑动窗口通常适用于固定长度的窗口，或者窗口的变化与某些条件相关。

a 贪心解法：若当前指针所指元素之前的和小于0，则丢弃当前元素之前的数列

public int maxSubArray(int[] nums) {
    //贪心思想 若当前指针所指元素之前的和小于0，则丢弃当前元素之前的数列
    int n = nums.length;
    int preSum = 0; //之前元素的和
    int maxSum = Integer.MIN_VALUE;

    for(int i = 0; i < n; i ++){
        int cur = nums[i];

        if(preSum < 0){
            preSum = cur;
        }else{
            preSum += cur;
        }
        maxSum = Math.max(preSum, maxSum);
    }
    return maxSum;
}

b 动态规划解法

核心思想是：

• 维护一个变量 currentSum 来记录当前的子数组和；
• 每次遍历到一个新的元素时，判断是要将其加入现有子数组，还是重新开始一个新的子数组；
• 维护另一个变量 maxSum 来记录全局最大子数组和。

动态规划的具体步骤：

1. 初始化 currentSum = nums[0] 和 maxSum = nums[0]。
2. 从数组第二个元素开始，逐个遍历数组：
   • 对于每个元素，更新 currentSum = max(currentSum + nums[i], nums[i])，即判断是继续加入之前的子数组，还是从当前位置重新开始计算子数组。
   • 更新 maxSum = max(maxSum, currentSum)，记录当前出现的最大和。
3. 返回 maxSum 作为结果。

 public int maxSubArray(int[] nums) {
     int currentSum = nums[0];
     int maxSum = nums[0];

     for (int i = 1; i < nums.length; i++) {
         // 更新当前的子数组和，决定是继续加还是从当前元素重新开始
         currentSum = Math.max(currentSum + nums[i], nums[i]);
         // 更新全局最大子数组和
         maxSum = Math.max(maxSum, currentSum);
     }

     return maxSum;
    }

2 换零钱

322. 零钱兑换 - 力扣（LeetCode）

思路：dp[i] 表示凑i元钱需要的最少硬币数, 当j硬币可以用来凑i元钱时，dp[i] = Math.min(dp[i], dp[i - coinNum] + 1);

public int coinChange(int[] coins, int amount) {
        int k = coins.length;
        int[] dp = new int[amount + 1];
        
        Arrays.fill(dp, amount + 1);

        dp[0] = 0; //表示凑0元钱最少需要0个硬币


        //遍历从1到amout元钱 的凑法
        for (int i = 1; i <= amount; i ++){ 
            for (int j = 0; j < k; j ++){
                int coinNum = coins[j]; //表示j硬币的面值
                
                //如果j硬币的面值小于i元钱，则说明可以尝试用j硬币来凑i元钱
                if (coinNum <= i){
                    //i - coinNum表示用j硬币凑i元 剩下的钱，dp[i - coinNum]表示凑剩下的钱需要的硬币数，+ 1是因为用了一个j硬币 
                    //因此dp[i - coinNum] + 1表示为凑剩下来的钱需要的硬币数加上用的一个j硬币
                    dp[i] = Math.min(dp[i], dp[i - coinNum] + 1);
                } 
            }
        }
        //若dp[amount] > amount 则表示凑不成
        return dp[amount] > amount ? -1 : dp[amount];
    }

2 硬币兑换 （遇到换题）

这题就是本人一面遇到的第一个题目，然后本人一下想不起来就让面试官换题了

题目：在一个国家仅有1分，2分，3分硬币，将钱N兑换成硬币有很多种兑法。请你编程序计算出共有多少种兑法。

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] coins = {1, 2, 3};
    int Max = 32768; //题目规定的N的上限

    //dp[i] 表示凑成i元钱需要的最少硬币数
    int[] dp = new int[Max + 1];
    //初始化
    dp[0] = 1;// 表示凑0元钱的方法只有1种，就是什么也不凑

    //动态规划计算所有可能的兑换方式
    for (int coin : coins) {
        for (int i = coin; i <= Max; i ++){
            
            dp[i] = dp[i] + dp[i - coin];
        }
    }

    //处理输入
    while (sc.hasNextInt()){
        int N = sc.nextInt();
        //输出换N元钱有多少个兑换方式
        System.out.println(dp[N]);
    }
    sc.close();
}

时间复杂度：O（N * m) N是要换的钱，m是硬币的种类数

空间复杂度：O(N)，只需要一个大小为 N 的数组来存储 dp 值。

3 给定一个字符串，判断是否能够分为三个回文子串 （遇到换题）

1745. 分割回文串 IV - 力扣（LeetCode）

时间原因，没有理解这道题，想着遇到就换题。

4 切割回文串最小切割次数 （遇到换题）

132. 分割回文串 II - 力扣（LeetCode）

时间原因，没有理解这道题，想着遇到就换题。

5 救生艇

881. 救生艇 - 力扣（LeetCode）

贪心思想：先对数字排序，然后尝试让最轻的人和最重的人坐一个船，若能坐下则一起坐一个船，否则最重的人单独坐一条船

public int numRescueBoats(int[] people, int limit) {
    Arrays.sort(people);

    int n = people.length;
    int left = 0, right = n - 1;
    int cnt = 0; //cnt用来记录要用多少搜救生艇

    while(left <= right){
        int lv = people[left];
        int rv = people[right];

        if (lv + rv <= limit){//若两个人的重量小于等于船最大承载
            cnt ++; //两个人用一条船
            left ++; 
            right --;
        }else{ //若两个人的重量大于船最大承载
            cnt ++; //右边重量大的人用一条船
            right --;
        }
    }
    return cnt;
}

6 单词拆分 （遇到换题，考前可看看）

139. 单词拆分 - 力扣（LeetCode）

public boolean wordBreak(String s, List<String> wordDict) {
        //思路 用dp[i]表示s中[0,i-1] i前面字符能否由字典中的单词组成

        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[0] = true; //空字符串能由字典中的单词组成

        Set<String> set = new HashSet<>(wordDict);

        //由子串[start,end) 推出 dp[end]
        for (int end = 1; end <= n; end ++){ 
            for (int start = 0; start < end; start ++){
                String substr = s.substring(start, end);
                 //检查子串s[j,i]是否在字典中,并且dp[j]是否为true
                if (dp[start] == true && set.contains(substr)){ 
                    dp[end] = true;
                    break;
                }
            }
        }
        return dp[n];
    }

7分发糖果

135. 分发糖果 - 力扣（LeetCode）

思路：两次循环，第一次从左到右遍历 若右边的孩子比左边孩子评分高，则右孩子糖数为左孩子糖+1，否则为1。第二次从右到左遍历 若左边孩子比右边孩子评分高，则左边孩子糖 = max(左孩子第一轮糖，右孩子糖 + 1)

    public int candy(int[] ratings) {
       int n = ratings.length;
       int[] candy = new int[n]; //candy[i] 表示第i个孩子收到的糖数
       candy[0] = 1; //初始化

       int cnt = 0; //用来统计糖总数
       
       //从左往右遍历 若右孩子评分比左孩子高则右孩子糖数 = 左孩子糖数 + 1,否则右孩子糖数为1
       for (int right = 1; right < n; right ++){
            int leftCandy = candy[right - 1];
            int leftRate = ratings[right - 1];
            int rightRate = ratings[right];

            if (rightRate > leftRate) {
                candy[right] = leftCandy + 1; //若右孩子评分比左孩子高则右孩子糖数 = 左孩子糖数 + 1
            }else{
                candy[right] = 1;//否则右孩子糖数为1
            }
       }

       //从右往左遍历 若左孩子评分比右孩子高 左孩子糖数 = max（左孩子糖数，右孩子糖数 + 1）
       for (int left = n - 2; left >= 0; left --){
            int rightRate = ratings[left + 1];
            int rightCandy = candy[left + 1];
            int leftRate = ratings[left];

            if (leftRate > rightRate){
                candy[left] = Math.max(candy[left], rightCandy + 1);
            }
       }
        
        //统计糖总数
        for (int a : candy){
            cnt += a;
        }
        return cnt;
    }

8 字符串所有排列（遇到换题）

输入一个字符串，打印出该字符串中字符的所有排列。可以任意顺序返回这个字符串数组，但里面不能有重复元素。

[LCR 157. 套餐内商品的排列顺序 - 力扣（LeetCode）](