Leetcode刷题 2021.01.07

Leetcode1283 使结果不超过阈值的最小除数

给你一个整数数组 nums 和一个正整数 threshold ，你需要选择一个正整数作为除数，然后将数组里每个数都除以它，并对除法结果求和。

请你找出能够使上述结果小于等于阈值 threshold 的除数中 最小 的那个。

每个数除以除数后都向上取整，比方说 7/3 = 3 , 10/2 = 5 。

输入：nums = [1,2,5,9], threshold = 6
输出：5

自然的思路就是从1开始枚举，直到找到小于等于阈值的最小的那个数。既然是有序枚举，就可以二分。
之前一直不懂二分各种小于等于的细节，刷了不少题，看了liweiwei的题解，学习了不少。
这题取整的时候有些小细节，应该还有更好的写法吧。

class Solution {
    public int smallestDivisor(int[] nums, int threshold) {
    	//好像没什么好注释的。。。
        int i = 1, j = 1_000_000;
        while (i < j){
            int pivot = i + (j - i) / 2;
            if (sum(nums, pivot) > threshold){
                i = pivot + 1;
            }else{
                j = pivot;
            }
        }

        return i;
    }

    private int sum (int[] nums, int divide){
        int sum = 0;
        for(int num : nums){
            int temp = num % divide;
            if (temp > 0){
                sum += num / divide + 1;
            }else{
                sum += num / divide;
            }
        }
        return sum;
    }
}

Leetcode1110 删点成林

又是愉快的二叉树题，好像和之前的题目差不多。给定数组，要查找，就放在set里面。还有一些小细节，看了下题解好像都没返回布尔值的，可能我就是比较喜欢这么写吧。

class Solution {
    List<TreeNode> res = new ArrayList<>();
    Set<Integer> set = new HashSet<>();
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
    	//放到set里方便查找
        for(int ele : to_delete){
            set.add(ele);
        }
        //题目没说数组长度，其实可以放到第一步做
        if (set.size() == 0) return res;
        //对于root的结点的特殊处理
        boolean flag = helper(root);
        if (!flag){
            res.add(root);
        }
        return res;
    }

    private boolean helper(TreeNode root){
        if (root == null) return true;
        boolean l = helper(root.left);
        boolean r = helper(root.right);
        boolean flag = set.contains(root.val);
        //用两个临时变量先保存起来
        TreeNode leftTree = root.left;
        TreeNode rightTree = root.right;
        //删除
        if (l) root.left = null;
        if (r) root.right = null;
        //添加到结果
        if (flag){
            if (root.left != null) res.add(leftTree);
            if (root.right != null) res.add(rightTree);
        }

        return flag;
    }
}

Leetcode1200 最小绝对差

早上太冷了，在宿舍待了一会儿，随便刷了一道简单题。本来以为会有O(n)的解法，写完看了题解基本都是要先排序的。那也没什么可说的，比较简单的题。要是面试都是这种题就好了。

给你个整数数组 arr，其中每个元素都 不相同。

请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。

输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]

class Solution {
    public List<List<Integer>> minimumAbsDifference(int[] arr) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(arr);
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < arr.length - 1; i++){
            if (Math.abs(arr[i] - arr[i + 1]) <= min){				//如果小于min，就clear掉
                if (Math.abs(arr[i] - arr[i + 1]) < min) {
                    res.clear();
                    min = Math.abs(arr[i] - arr[i + 1]);
                }
                //添加list，之前一直不会这个方法。还有好多技巧方法得学啊。。
                res.add(Arrays.asList(arr[i], arr[i + 1]));
            }
        }

        return res;
    }   
}