Leetcode第123场双周赛
本人水平有限，只做前三道
一、三角形类型
给你一个下标从 0 开始长度为 3 的整数数组 nums ，需要用它们来构造三角形。
如果一个三角形的所有边长度相等，那么这个三角形称为 equilateral 。
如果一个三角形恰好有两条边长度相等，那么这个三角形称为 isosceles 。
如果一个三角形三条边的长度互不相同，那么这个三角形称为 scalene 。
如果这个数组无法构成一个三角形，请你返回字符串 “none” ，否则返回一个字符串表示这个三角形的类型。
示例 1：
输入：nums = [3,3,3]
输出：“equilateral”
解释：由于三条边长度相等，所以可以构成一个等边三角形，返回 “equilateral” 。
示例 2：
输入：nums = [3,4,5]
输出：“scalene”
解释：
nums[0] + nums[1] = 3 + 4 = 7 ，大于 nums[2] = 5 。
nums[0] + nums[2] = 3 + 5 = 8 ，大于 nums[1] = 4 。
nums[1] + nums[2] = 4 + 5 = 9 ，大于 nums[0] = 3 。
由于任意两边纸盒都大于第三边，所以可以构成一个三角形。
因为三条边的长度互不相等，所以返回 “scalene” 。
解题思路
经典的条件逻辑题
先将数组排序能够简化条件逻辑
代码
class Solution {
public String triangleType(int[] nums) {
Arrays.sort(nums);
int a = nums[0];
int b = nums[1];
int c = nums[2];
if(a==c){
return "equilateral";
}
if(a+b>c){
if(a==b||b==c){
return "isosceles";
}
return "scalene";
}
return "none";
}
}
二、最大好子数组和
题目
给你一个长度为 n 的数组 nums 和一个 正 整数 k 。
如果 nums 的一个子数组中，第一个元素和最后一个元素 差的绝对值恰好 为 k ，我们称这个子数组为 好 的。换句话说，如果子数组 nums[i…j] 满足 |nums[i] - nums[j]| == k ，那么它是一个好子数组。
请你返回 nums 中 好 子数组的 最大 和，如果没有好子数组，返回 0 。
示例 1：
输入：nums = [1,2,3,4,5,6], k = 1
输出：11
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 1 。好子数组有 [1,2] ，[2,3] ，[3,4] ，[4,5] 和 [5,6] 。最大子数组和为 11 ，对应的子数组为 [5,6] 。
示例 2：
输入：nums = [-1,3,2,4,5], k = 3
输出：11
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 3 。好子数组有 [-1,3,2] 和 [2,4,5] 。最大子数组和为 11 ，对应的子数组为 [2,4,5] 。
示例 3：
输入：nums = [-1,-2,-3,-4], k = 2
输出：-6
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 2 。好子数组有 [-1,-2,-3] 和 [-2,-3,-4] 。最大子数组和为 -6 ，对应的子数组为 [-1,-2,-3] 。
解题思路
前缀和+哈希表
如果不使用前缀和数组而构建求区间和的函数，很容易导致超时。
哈希表是为了记录数组值和其下标，便于找到与数组值的差的绝对值为k的下标。同时如果在数组中出现重复数字，则需要考虑更新数组
代码
class Solution {
public long maximumSubarraySum(int[] nums, int k) {
int n = nums.length;
// 构建前缀和数组
long[] pre = new long[n+1];
for (int i = 0; i < n; i++) {
pre[i+1] = pre[i] + nums[i];
}
// 答案
long ans = Long.MIN_VALUE;
// 记录nums[i] : i
Map<Integer,Integer> index = new HashMap<>();
for (int i = 0; i < n; i++) {
int x = nums[i];
int last1 = k + x;
int last2 = x - k;
if(index.containsKey(last1)){
int idx = index.get(last1);
// 更新答案
ans = Math.max(pre[i+1]-pre[idx],ans);
}
if(index.containsKey(last2)){
int idx = index.get(last2);
ans = Math.max(pre[i+1]-pre[idx],ans);
}
// 如果nums[i]在之前出现过，那么用贪心的想法来更新
if(index.containsKey(x)){
int idx = index.get(x);
long seg = pre[i] - pre[idx];
if(seg <= 0){
index.put(x,i);
}
} else{
index.put(x,i);
}
}
return ans == Long.MIN_VALUE ? 0 : ans;
}
}
三、人员站位的方案数I
给你一个 n x 2 的二维数组 points ，它表示二维平面上的一些点坐标，其中 points[i] = [xi, yi] 。
我们定义 x 轴的正方向为 右 （x 轴递增的方向），x 轴的负方向为 左 （x 轴递减的方向）。类似的，我们定义 y 轴的正方向为 上 （y 轴递增的方向），y 轴的负方向为 下 （y 轴递减的方向）。
你需要安排这 n 个人的站位，这 n 个人中包括 liupengsay 和小羊肖恩 。你需要确保每个点处 恰好 有 一个 人。同时，liupengsay 想跟小羊肖恩单独玩耍，所以 liupengsay 会以 liupengsay 的坐标为 左上角 ，小羊肖恩的坐标为 右下角 建立一个矩形的围栏（注意，围栏可能 不 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 内部 或者 边缘 上有任何其他人，liupengsay 都会难过。
请你在确保 liupengsay 不会 难过的前提下，返回 liupengsay 和小羊肖恩可以选择的 点对 数目。
注意，liupengsay 建立的围栏必须确保 liupengsay 的位置是矩形的左上角，小羊肖恩的位置是矩形的右下角。比方说，以 (1, 1) ，(1, 3) ，(3, 1) 和 (3, 3) 为矩形的四个角，给定下图的两个输入，liupengsay 都不能建立围栏，原因如下：
图一中，liupengsay 在 (3, 3) 且小羊肖恩在 (1, 1) ，liupengsay 的位置不是左上角且小羊肖恩的位置不是右下角。
图二中，liupengsay 在 (1, 3) 且小羊肖恩在 (1, 1) ，小羊肖恩的位置不是在围栏的右下角。
示例 1：
输入：points = [[1,1],[2,2],[3,3]]
输出：0
解释：没有办法可以让 liupengsay 的围栏以 liupengsay 的位置为左上角且小羊肖恩的位置为右下角。所以我们返回 0 。
示例 2：
输入：points = [[6,2],[4,4],[2,6]]
输出：2
解释：总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
- liupengsay 站在 (4, 4) ，小羊肖恩站在 (6, 2) 。
- liupengsay 站在 (2, 6) ，小羊肖恩站在 (4, 4) 。
不能安排 liupengsay 站在 (2, 6) 且小羊肖恩站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。
示例 3：
输入：points = [[3,1],[1,3],[1,1]]
输出：2
解释：总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
- liupengsay 站在 (1, 1) ，小羊肖恩站在 (3, 1) 。
- liupengsay 站在 (1, 3) ，小羊肖恩站在 (1, 1) 。
不能安排 liupengsay 站在 (1, 3) 且小羊肖恩站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。
注意围栏是可以不包含任何面积的，上图中第一和第二个围栏都是合法的。
解题思路
这个题目要求我们计算在给定的点集中，有多少种方式可以选择两个点作为矩形的左上角和右下角，满足以下条件：
- 矩形的左上角和右下角分别是两个特定的人，我们可以称之为A和B。
- A必须位于矩形的左上角，B必须位于矩形的右下角。
- 矩形的内部和边缘不能有任何其他点。
为了解决这个问题，我们需要遍历每一对点对，并判断一个点是否在另一个点的左上角，并且这两个点形成的矩形(包括边界)是否存在其他点？
- 对所有点按照x坐标进行排序，如果x坐标相同，则按照y坐标排序。这样可以确保我们在遍历点对时，总是从左向右，从上到下进行。
- 实际的点对并不是所有点的排布都遵循
从左上到右下的规律，在循环内还要对点的纵坐标进行一次判断后才能计数。
代码
class Solution {
public int numberOfPairs(int[][] points) {
int pairs = 0;
Arrays.sort(points,(a,b) -> {
if(a[0] != b[0]){
return a[0]-b[0];
} else{
return b[1]-a[1];
}
});
int n = points.length;
for (int i = 0; i < n; i++) {
for (int j = i+1; j < n; j++) {
if(points[i][1] >= points[j][1] && isGood(points, i, j)){
pairs++;
}
}
}
return pairs;
}
public boolean isGood(int[][] points,int index1,int index2){
int n = points.length;
for (int i = 0; i < n; i++) {
if(i==index1||i==index2){
continue;
}
if(points[i][0]>=points[index1][0] && points[i][0]<=points[index2][0] && points[i][1] <= points[index1][1] && points[i][1] >= points[index2][1]){
return false;
}
}
return true;
}
}
