【2022.12.13】备战春招Day8——每日一题 + 416. 分割等和子集 + 135. 分发糖果

【每日一题】1832. 判断句子是否为全字母句

题目描述

全字母句指包含英语字母表中每个字母至少一次的句子。
给你一个仅由小写英文字母组成的字符串 sentence ，请你判断 sentence 是否为全字母句 。
输入：sentence = “thequickbrownfoxjumpsoverthelazydog”
输出：true
解释：sentence 包含英语字母表中每个字母至少一次。

题目解析

【哈希表】：遍历字符串数组，统计字母会出现的频率即可。

class Solution {
    public boolean checkIfPangram(String sentence) {
        int length = sentence.length();
        if(length < 26) return false;
        int[] re = new int[26];
        for(char c : sentence.toCharArray()){
            re[c - 'a']++;
        }
        for(int i : re){
            if(i == 0) return false;
        }
        return true;
    }
}

[leetcode hot 100] 416. 分割等和子集

题目描述

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

题目解析

【提前判断】：可以分割成等和子集的数组，之和一定是偶数。如果数组中有数字比sum / 2大，则一定不可以分割等和子集。
【背包问题】：可以将题目看作是背包问题，背包容量为sum / 2，每个物品的价格为nums[i]，最后判断是否能将背包装满，而非看价格。
【动态规划】：背包问题可以使用动态规划来解决。
设dp[i][j]：当装入第i个物品时，背包剩余容量为j，此时能装入物品的最大价格为dp[]i[j]。
状态转移方程为：
dp[i][j] = dp[i - 1][j] (j < nums[i])
dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]} (j > nums[i])

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        int max = 0;
        for(int i : nums){
            sum += i;
            max = Math.max(max, i);
        } 
        if(sum % 2 != 0) return false;
        sum /= 2;
        if(max > sum) return false;
        //动态规划
        int[][] dp = new int[nums.length][sum + 1];
        //初始化:可以装入第一个物品
        for(int j = nums[0]; j <= sum; j++){
            dp[0][j] = nums[0];
        }
        for(int i = 1; i < nums.length; i++){
            for(int j = 0; j < nums[i]; j++){
                dp[i][j] = dp[i - 1][j];
            }
            for(int j = nums[i]; j <= sum; j++){
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
            }
        }
        if(dp[nums.length - 1][sum] == sum) return true;
        return false;
    }
}

对于dp数组，第i行的状态只与i - 1行有关，所以可以使用一维的dp来完成。
设dp[j]：背包剩余容量为j时，可以容纳的最大价值。
状态转移方程:
dp[j] = max{dp[j], dp[j - nums[i]] + nums[i]} (j >= nums[i])
dp[j] = dp[j] (j < nums[i])

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        int max = 0;
        for(int i : nums){
            sum += i;
            max = Math.max(max, i);
        } 
        if(sum % 2 != 0) return false;
        sum /= 2;
        if(max > sum) return false;
        //动态规划
        int[]dp = new int[sum + 1];
        //初始化:可以装入第一个物品
        for(int j = nums[0]; j <= sum; j++){
            dp[j] = nums[0];
        }
        for(int i = 1; i < nums.length; i++){
            for(int j = sum; j >= nums[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
            for(int j = nums[i] - 1; j >= 0; j--){
                dp[j] = dp[j];
            }
        }
        if(dp[sum] == sum) return true;
        return false;
    }
}

【代码随想录】135. 分发糖果

题目描述

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
你需要按照以下要求，给这些孩子分发糖果：
-每个孩子至少分配到 1 个糖果。
-相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

题目解析

分两次遍历数组：
【正向遍历】：此时可以保证当i < j 且 ratings[i] < ratings[j] 时，j分到的糖果比i分到的糖果多。
【反向遍历】：此时可以保证当i < j 且 ratings[i] > ratings[j] 时，j分到的糖果比i分到的糖果少。

class Solution {
    public int candy(int[] ratings) {
        int[] re = new int[ratings.length];
        re[0] = 1;
        //正向遍历
        for(int i = 1; i < ratings.length; i++){
            if(ratings[i] > ratings[i - 1]){
                re[i] = re[i - 1] + 1;
            }else{
                re[i] = 1;
            }
        }
        //反向遍历
        for(int i = ratings.length - 2; i >= 0; i--){
            if(ratings[i] > ratings[i + 1]){
                re[i] = Math.max(re[i + 1] + 1, re[i]);
            }
        }
        int sum = 0;
        for(int i : re){
            sum += i;
        }
        return sum;
    }
}