Leetcode 第174场周赛题解

这两天在央视上看了很多关于武汉医生的报道，颇受触动。每个人都有每个人的职责，对于赋闲在家的我们，除了老老实实自我隔离，为武汉加油鼓劲外，唯一能做的，可能就是不让每一天的时光荒废了。

武汉加油！！！

 

昨天进行的Leetcode第174场周赛颇有纪念意义，这是我第一次四道题全部在竞赛时间内做出，虽然几乎是最后一刻才AC。

1341. 方阵中战斗力最弱的k行

给你一个大小为 m * n 的方阵 mat，方阵由若干军人和平民组成，分别用 0 和 1 表示。

请你返回方阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。

如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。

军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。

 

示例 1：

输入：mat = 
[[1,1,0,0,0],
 [1,1,1,1,0],
 [1,0,0,0,0],
 [1,1,0,0,0],
 [1,1,1,1,1]], 
k = 3
输出：[2,0,3]
解释：
每行中的军人数目：
行 0 -> 2 
行 1 -> 4 
行 2 -> 1 
行 3 -> 2 
行 4 -> 5 
从最弱到最强对这些行排序后得到 [2,0,3,1,4]
示例 2：

输入：mat = 
[[1,0,0,0],
 [1,1,1,1],
 [1,0,0,0],
 [1,0,0,0]], 
k = 2
输出：[0,2]
解释： 
每行中的军人数目：
行 0 -> 1 
行 1 -> 4 
行 2 -> 1 
行 3 -> 1 
从最弱到最强对这些行排序后得到 [0,2,3,1]
 

提示：

m == mat.length
n == mat[i].length
2 <= n, m <= 100
1 <= k <= m
matrix[i][j] 不是 0 就是 1

题目解析

Leetcode竞赛每次的第一题都是送分题，思路显而易见，用一个数据结构存储行index和战斗力之和force，然后排序，输出结果。

代码

class Solution {
    
    class Element implements Comparable<Element>{
        int id;
        int force;
        
        @Override
        public int compareTo(Element e)
        {
            if(e.force!=this.force)
            {
                return this.force-e.force;
            }
            else
            {
                return this.id - e.id;   
            }
        }
        
    }
    public int[] kWeakestRows(int[][] mat, int k) {
        ArrayList<Element> es = new ArrayList<Element>();
        for(int i=0;i<mat.length;i++)
        {
            Element e= new Element();
            int counter = 0;
            for(int j=0;j<mat[i].length;j++)
            {
                if(mat[i][j]==1)
                {
                    counter++;
                }
                else
                {
                    break;
                }
            }
            e.id = i;
            e.force = counter;
            es.add(e);
        }
        Collections.sort(es);
        int []res = new int[k];
        for(int i=0;i<k;i++)
        {
            res[i] = es.get(i).id;
        }
        return res;
    }
}

5329. 数组大小减半

给你一个整数数组 arr。你可以从中选出一个整数集合，并删除这些整数在数组中的每次出现。

返回 至少 能删除数组中的一半整数的整数集合的最小大小。

 

示例 1：

输入：arr = [3,3,3,3,5,5,5,2,2,7]
输出：2
解释：选择 {3,7} 使得结果数组为 [5,5,5,2,2]、长度为 5（原数组长度的一半）。
大小为 2 的可行集合有 {3,5},{3,2},{5,2}。
选择 {2,7} 是不可行的，它的结果数组为 [3,3,3,3,5,5,5]，新数组长度大于原数组的二分之一。
示例 2：

输入：arr = [7,7,7,7,7,7]
输出：1
解释：我们只能选择集合 {7}，结果数组为空。
示例 3：

输入：arr = [1,9]
输出：1
示例 4：

输入：arr = [1000,1000,3,7]
输出：1
示例 5：

输入：arr = [1,2,3,4,5,6,7,8,9,10]
输出：5
 

提示：

1 <= arr.length <= 10^5
arr.length 为偶数
1 <= arr[i] <= 10^5

题目解析

这个题目我使用了一个hashmap来存储数值和其出现的次数，之后为了排序，把它转移存储到了一个类中。之后按照出现次数从大到小的顺序取出这些数值，直到出现数值的次数大于等于数组长度的一半。

代码

class Solution {
    
    class Element implements Comparable<Element>{
        int key;
        int counter;
        
        public Element(int key, int counter)
        {
            this.key = key;
            this.counter = counter;
        }
        
        @Override
        public int compareTo(Element e)
        {
            return e.counter - this.counter;
        }
        
    }
    public int minSetSize(int[] arr) {
        Map<Integer, Integer> maps = new HashMap<>();
        for(int i=0;i<arr.length;i++)
        {
            int key = arr[i];
            if(maps.containsKey(key))
            {
                int counter = maps.get(key);
                maps.put(key,counter+1);
            }
            else
            {
                maps.put(key,1);
            }
        }
        ArrayList<Element> es = new ArrayList<Element>();
        for (Map.Entry<Integer, Integer> entry : maps.entrySet()) {
            Integer mapKey = entry.getKey();
            Integer mapValue = entry.getValue();
            Element e = new Element(mapKey, mapValue);
            es.add(e);
        }
        Collections.sort(es);
        int total = 0;
        int c= 0;
        
        while(total<arr.length/2)
        {
            total +=es.get(c).counter;
            c++;
        }
        return c;
        
    }
}

5330. 分裂二叉树的最大乘积

给你一棵二叉树，它的根为 root 。请你删除 1 条边，使二叉树分裂成两棵子树，且它们子树和的乘积尽可能大。

由于答案可能会很大，请你将结果对 10^9 + 7 取模后再返回。

 

示例 1：

输入：root = [1,2,3,4,5,6]
输出：110
解释：删除红色的边，得到 2 棵子树，和分别为 11 和 10 。它们的乘积是 110 （11*10）
示例 2：

输入：root = [1,null,2,3,4,null,null,5,6]
输出：90
解释：移除红色的边，得到 2 棵子树，和分别是 15 和 6 。它们的乘积为 90 （15*6）
示例 3：

输入：root = [2,3,9,10,7,8,6,5,4,11,1]
输出：1025
示例 4：

输入：root = [1,1]
输出：1
 

提示：

每棵树最多有 50000 个节点，且至少有 2 个节点。
每个节点的值在 [1, 10000] 之间。

题目解析

这个题目最开始看来解法还是比较清晰的，但是在写代码的时候，细节上出现了一些问题。首先，我们想什么时候乘积最大，这就是x(sum-x)什么时候最大的问题，显然，在x=sum/2的时候最大。接下来我们要想如何寻找最接近x的值。在这里，我们采用自底向上遍历树，对节点求和的方式来找。我们把每个节点的值变为当前节点的值加上其所有子节点的值。然后再遍历所有节点，寻找最接近的。这样写完代码后，提交错误了好几次。关键点在于sum/2这里，我们应该采用double存储，不然找到的不一定是最近的。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int modNumber = 1000000000 + 7;
    double sum = -1;
    double minValue = 1000000000;
    int target = -1;
    double half = -1.0;
    int sumUp(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }
        else
        {
            root.val = root.val+sumUp(root.left)+sumUp(root.right);
            return root.val;
        }
    }
    
    void inOrder(TreeNode root){
        if(root==null)
            return;
        inOrder(root.left);
        if(Math.abs((double)root.val-half)<minValue)
        {
            minValue = Math.abs((double)root.val-half);
            target = root.val;
        }
        inOrder(root.right);
    }
    
    public int maxProduct(TreeNode root) {
        sum = sumUp(root);
        half = sum/2.0;
        inOrder(root);
        int first = target;
        double second = sum - target;
        double res = (first*second)%modNumber;
        return (int)res;
    }
}

5331. 跳跃游戏V

给你一个整数数组 arr 和一个整数 d 。每一步你可以从下标 i 跳到：

i + x ，其中 i + x < arr.length 且 0 < x <= d 。
i - x ，其中 i - x >= 0 且 0 < x <= d 。
除此以外，你从下标 i 跳到下标 j 需要满足：arr[i] > arr[j] 且 arr[i] > arr[k] ，其中下标 k 是所有 i 到 j 之间的数字（更正式的，min(i, j) < k < max(i, j)）。

你可以选择数组的任意下标开始跳跃。请你返回你 最多 可以访问多少个下标。

请注意，任何时刻你都不能跳到数组的外面。

 

示例 1：

输入：arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2
输出：4
解释：你可以从下标 10 出发，然后如上图依次经过 10 --> 8 --> 6 --> 7 。
注意，如果你从下标 6 开始，你只能跳到下标 7 处。你不能跳到下标 5 处因为 13 > 9 。你也不能跳到下标 4 处，因为下标 5 在下标 4 和 6 之间且 13 > 9 。
类似的，你不能从下标 3 处跳到下标 2 或者下标 1 处。
示例 2：

输入：arr = [3,3,3,3,3], d = 3
输出：1
解释：你可以从任意下标处开始且你永远无法跳到任何其他坐标。
示例 3：

输入：arr = [7,6,5,4,3,2,1], d = 1
输出：7
解释：从下标 0 处开始，你可以按照数值从大到小，访问所有的下标。
示例 4：

输入：arr = [7,1,7,1,7,1], d = 2
输出：2
示例 5：

输入：arr = [66], d = 1
输出：1
 

提示：

1 <= arr.length <= 1000
1 <= arr[i] <= 10^5
1 <= d <= arr.length

题目解析

这道题确实是最难的一道题目了，但是同时，我也觉得这道题目的题意要想读懂要花费很多时间。我把这道题目总结一下，从任意一点都可以向两边跳，跳的范围是index-d,index+d(要考虑数组的边界)。但是不是想跳就跳，如果中间有建筑比你当前站的建筑高，那么你就跳不过这个建筑。想了很久，觉得这个题目是一个动态规划问题，可以从最简单的问题入手，一步步逆推。dp[i]代表第i个建筑能跳跃几个建筑。最简单的情况是什么呢？最矮的建筑，它没有建筑可以跳，因此dp[shortest]=1，那么状态转移方程是啥呢？dp[i] = max(dp[k])+dp[i]，其中k是能跳到i的所有建筑的下标。我们按照建筑从矮到高的顺序搜索。

代码

class Solution {
    
    class Element implements Comparable<Element>{
        int id;
        int height;
        
        Element(int id, int height)
        {
            this.id = id;
            this.height = height;
        }
        
        @Override
        public int compareTo(Element e){
            return this.height-e.height;
        }
    }
    public int maxJumps(int[] arr, int d) {
        ArrayList<Element> es = new ArrayList<Element>();
        int[] dp = new int[arr.length];
        for(int i=0;i<arr.length;i++)
        {
            dp[i] = 1;
        }
        for(int i=0;i<arr.length;i++)
        {
            Element e = new Element(i,arr[i]);
            es.add(e);
        }
        Collections.sort(es);
        for(Element e:es)
        {
            int id = e.id;
            int height = e.height;
            int maxValue = 1;
            int left = Math.max(0,id-d);
            int right = Math.min(arr.length-1,id+d);
            for(int i=id-1;i>=left;i--)
            {
                if(arr[i]>=height)
                {
                    break;
                }
                if(arr[i]<height&&dp[id]+dp[i]>maxValue)
                {
                    maxValue = dp[id] + dp[i];
                }
            }
            for(int i=id+1;i<=right;i++)
            {
                if(arr[i]>=height)
                {
                    break;
                }
                if(arr[i]<height&&dp[id]+dp[i]>maxValue)
                {
                    maxValue = dp[id] + dp[i];
                }
            }
            dp[id] = maxValue;
        }
        int res = -1;
        for(int i=0;i<arr.length;i++)
        {
            if(dp[i]>res)
            {
                res = dp[i];
            }
        }
        return res;
    }
}