力扣双周赛 123

3024. 三角形类型

给你一个下标从 0 开始长度为 3 的整数数组 nums ，需要用它们来构造三角形。

• 如果一个三角形的所有边长度相等，那么这个三角形称为 equilateral 。
• 如果一个三角形恰好有两条边长度相等，那么这个三角形称为 isosceles 。
• 如果一个三角形三条边的长度互不相同，那么这个三角形称为 scalene 。

如果这个数组无法构成一个三角形，请你返回字符串 "none" ，否则返回一个字符串表示这个三角形的类型。

示例 1：

输入：nums = [3,3,3]
输出："equilateral"
解释：由于三条边长度相等，所以可以构成一个等边三角形，返回 "equilateral" 。

class Solution {
    public String triangleType(int[] nums) {
        Arrays.sort(nums);
        int x = nums[0];
        int y = nums[1];
        int z = nums[2];
        if (x + y <= z) { 
            return "none";
        }
        if (x == z) { 
            return "equilateral";
        }
        if (x == y || y == z) {
            return "isosceles";
        }
        return "scalene";
    }
}

3025. 人员站位的方案数 I

给你一个  n x 2 的二维数组 points ，它表示二维平面上的一些点坐标，其中 points[i] = [xi, yi] 。

我们定义 x 轴的正方向为 右 （x 轴递增的方向），x 轴的负方向为 左 （x 轴递减的方向）。类似的，我们定义 y 轴的正方向为 上 （y 轴递增的方向），y 轴的负方向为 下 （y 轴递减的方向）。

你需要安排这 n 个人的站位，这 n 个人中包括 Alice 和 Bob 。你需要确保每个点处 恰好 有 一个 人。同时，Alice 想跟 Bob 单独玩耍，所以 Alice 会以 Alice 的坐标为 左上角 ， Bob 的坐标为 右下角 建立一个矩形的围栏（注意，围栏可能 不 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 内部 或者 边缘 上有任何其他人，Alice 都会难过。

请你在确保 Alice 不会 难过的前提下，返回 Alice 和 Bob 可以选择的 点对 数目。

注意，Alice 建立的围栏必须确保 Alice 的位置是矩形的左上角，Bob 的位置是矩形的右下角。比方说，以 (1, 1) ，(1, 3) ，(3, 1) 和 (3, 3) 为矩形的四个角，给定下图的两个输入，Alice 都不能建立围栏，原因如下：

• 图一中，Alice 在 (3, 3) 且 Bob 在 (1, 1) ，Alice 的位置不是左上角且 Bob 的位置不是右下角。
• 图二中，Alice 在 (1, 3) 且 Bob 在 (1, 1) ，Bob 的位置不是在围栏的右下角。

示例 1：

输入：points = [[1,1],[2,2],[3,3]]
输出：0
解释：没有办法可以让 Alice 的围栏以 Alice 的位置为左上角且 Bob 的位置为右下角。所以我们返回 0 。

枚举

class Solution {
    public int numberOfPairs(int[][] points) {
        int ans = 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] && is(points, i, j)) {
                    ans++;
                }
            }
        }
        return ans;
    }

    public boolean is(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[index2][1] && points[i][1] <= points[index1][1])
                return false;
        }
        return true;

    }
}

3026. 最大好子数组和

给你一个长度为 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] 。

知道要用前缀和，没想到要用哈希表

Map<Integer, Long> minS = new HashMap<>(); //键为 a[i]，值为相同 a[i] 下的 s[i] 的最小值。

class Solution {
    public long maximumSubarraySum(int[] nums, int k) {
        long ans = Long.MIN_VALUE;
        long sum = 0;
        Map<Integer, Long> minS = new HashMap<>();
        for (int x : nums) {
            long s1 = minS.getOrDefault(x - k, Long.MAX_VALUE / 2);
            long s2 = minS.getOrDefault(x + k, Long.MAX_VALUE / 2);
            ans = Math.max(ans, sum + x - Math.min(s1, s2));
            minS.merge(x, sum, Math::min);
            sum += x;
        }
        return ans > Long.MIN_VALUE / 4 ? ans : 0;
    }
}

3027. 人员站位的方案数 II

如果 points[j][1]比之前枚举的点的纵坐标都大，那么矩形内没有其它点，符合要求，答案加一。
如果 points[j][1] 小于等于之前枚举的某个点的纵坐标，那么矩形内有其它点，不符合要求

class Solution {
    public int numberOfPairs(int[][] points) {
        Arrays.sort(points, (p, q) -> p[0] != q[0] ? p[0] - q[0] : q[1] - p[1]);
        int ans = 0;
        for (int i = 0; i < points.length; i++) {
            int y0 = points[i][1];
            int maxY = Integer.MIN_VALUE;
            for (int j = i + 1; j < points.length; j++) {
                int y = points[j][1];
                if (y <= y0 && y > maxY) {
                    maxY = y;
                    ans++;
                }
            }
        }
        return ans;
    }
}