【2023-08-13】T1431_拥有最多糖果的孩子

1431.拥有最多糖果的孩子 使用Java stream流完成

一、题目要求

题目：

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

示例 1：

输入：candies = [2,3,5,1,3], extraCandies = 3
输出：[true,true,true,false,true] 
解释：
孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

示例 2：

输入：candies = [4,2,1,1,2], extraCandies = 1
输出：[true,false,false,false,false] 
解释：只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。

示例 3：

输入：candies = [12,1,12], extraCandies = 10
输出：[true,false,true]

提示：

• 2 <= candies.length <= 100
• 1 <= candies[i] <= 100
• 1 <= extraCandies <= 50

---

二、思路分析

思路：

对于每一个小朋友，只要这个小朋友「拥有的糖果数目」加上「额外的糖果数目」大于等于所有小朋友拥有的糖果数目最大值，那么这个小朋友就可以拥有最多的糖果。时间复杂度为$O(n)$。

证明：

设某个小朋友的糖果数为 $x$，其余小朋友拥有的糖果数目最大值为 $y$，额外的糖果数为 $e$。这个小朋友可以拥有最多的糖果，当且仅当$x+e\ge y$.

由于 $x+e\ge x$ 显然成立，那么我们有$x+e\ge max(x,y)$，而 $max(x,y)$就是所有小朋友拥有的糖果数目最大值。因此我们可以预处理出这个值，随后遍历每一个小朋友，只要这个小朋友「拥有的糖果数目」加上「额外的糖果数目」大于等于这个值，就可以满足要求。

---

三、最高效率方法

作者：力扣官方题解
链接：https://leetcode.cn/problems/kids-with-the-greatest-number-of-candies/solutions/269245/yong-you-zui-duo-tang-guo-de-hai-zi-by-leetcode-so/
来源：力扣（LeetCode）

code

class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
        int n = candies.length;
        int maxCandies = 0;
        for (int i = 0; i < n; ++i) {
            maxCandies = Math.max(maxCandies, candies[i]);
        }
        List<Boolean> ret = new ArrayList<Boolean>();
        for (int i = 0; i < n; ++i) {
            ret.add(candies[i] + extraCandies >= maxCandies);
        }
        return ret;
    }
}

复杂度分析

假设小朋友的总数为 $n$。

时间复杂度：我们首先使用 $O(n)$ 的时间预处理出所有小朋友拥有的糖果数目最大值。对于每一个小朋友，我们需要 $O(1)$ 的时间判断这个小朋友是否可以拥有最多的糖果，故渐进时间复杂度为 $O(n)$。

空间复杂度：这里只用了常数个变量作为辅助空间，与 $n$ 的规模无关，故渐进空间复杂度为 $O(1)$。

---

四、使用Java stream流

作者是Java小白，看了JavaSE一年还没看完，非常的痛苦，并且看完后面的前面就忘记了。恰好看到Java中的stream流，借此题练一下能否运用，故不考虑时间复杂度与空间复杂度。

将以小白的视角解读我目前了解的stream()流一些知识点，难免会有错误，请各位大佬指出不足之处！

Leetcode初始化代码

class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
		// ...
    }
}

1. Java int[]数组转换成List列表, 方便操作

代码

// int[] -> List<Integer>
public static List<Integer> convert(int[] arr){
    return Arrays.stream(arr)
        .boxed()
        .collect(Collectors.toList());
}

知识点1: .boxed()

.boxed() 有时需要将原始类型转换为盒式类型。

在原始类型「primitives」和盒式类型「boxed」之间转换数组

// Java SE 8
// int类型的stream转成了Integer类型的Stream
int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

知识点2: .collect()

参考: Java函数式编程Stream.collect()方法使用小结_且随风而行的博客-CSDN博客

2. 根据思路补全初始化代码

思路

step1. 把candies都加上extraCandies变成新的list

step2. 在原来的list中找出max

step3. 对比新list的数值, >=max为true

public static List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
    // 1.转换int[]数组
    List<Integer> candiesList = convert(candies);

    // 2.candiesList + extraCandies
    // map():用于映射每个元素到对应的结果
    List<Integer> addCandiesList = candiesList.stream()
            .map(elem -> elem + extraCandies)
            .toList();
    
    // 3.找出原来list中的max
    int maxCandies = Collections.max(candiesList);
    
    // 4.对比新list的数值, >=max为true
    // 使用forEach遍历读取每一个数, 判断是否>=max
    List<Boolean> ans = new ArrayList<Boolean>();
    addCandiesList.forEach(e -> {
                     ans.add(e >= maxCandies);
                 });
    return ans;
}

知识点: stream().map()

map(): 用于映射每个元素到对应的结果

并配合 .toList() 生成新的列表

// 例如: 我们要把一个列表oldList中所有的数都加上1, 变成新的列表newList
List<Integer> newList = oldList.stream()
    .map(i -> i+1)
    .toList();

// 例如: 我们要把一个列表oldList中所有的数都变成平方, 变成新的列表newList
List<Integer> newList = oldList.stream()
    .map(i -> i*i)
    .toList();

五、完整代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class T1431_KidsWithMostCandies {
    public static void main(String[] args) {
        int[] candies = {2,3,5,1,3};
        int extraCandies = 3;
        System.out.println(kidsWithCandies(candies, extraCandies));
    }
    
    
    public static List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
        // 1.转换int[]数组
        List<Integer> candiesList = convert(candies);
    
        // 2.candiesList + extraCandies
        // map():用于映射每个元素到对应的结果
        List<Integer> addCandiesList = candiesList.stream()
                .map(elem -> elem + extraCandies)
                .toList();
        
        // 3.找出原来list中的max
        int maxCandies = Collections.max(candiesList);
        
        // 4.对比新list的数值, >=max为true
        // 使用forEach遍历读取每一个数, 判断是否>=max
        List<Boolean> ans = new ArrayList<Boolean>();
        addCandiesList.forEach(e -> {
                         ans.add(e >= maxCandies);
                     });
        return ans;
    }
    
    // int[] -> List<Integer>
     public static List<Integer> convert(int[] arr){
        return Arrays.stream(arr)
                       .boxed()
                       .collect(Collectors.toList());
    }
    
}