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{
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 es = new ArrayList();
for(int i=0;i 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{
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 maps = new HashMap<>();
for(int i=0;i es = new ArrayList();
for (Map.Entry 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 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)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{
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 es = new ArrayList();
int[] dp = new int[arr.length];
for(int i=0;i=left;i--)
{
if(arr[i]>=height)
{
break;
}
if(arr[i]maxValue)
{
maxValue = dp[id] + dp[i];
}
}
for(int i=id+1;i<=right;i++)
{
if(arr[i]>=height)
{
break;
}
if(arr[i]maxValue)
{
maxValue = dp[id] + dp[i];
}
}
dp[id] = maxValue;
}
int res = -1;
for(int i=0;ires)
{
res = dp[i];
}
}
return res;
}
}