标签： easy

目标

给你一个下标从 0 开始的二维整数数组 dimensions。

对于所有下标 i (0 <= i < dimensions.length)，dimensions[i][0] 表示矩形 i 的长度，而 dimensions[i][1] 表示矩形 i 的宽度。

返回对角线最 长 的矩形的 面积 。如果存在多个对角线长度相同的矩形，返回面积最 大 的矩形的面积。

示例 1：

输入：dimensions = [[9,3],[8,6]]
输出：48
解释：
下标 = 0，长度 = 9，宽度 = 3。对角线长度 = sqrt(9 * 9 + 3 * 3) = sqrt(90) ≈ 9.487。
下标 = 1，长度 = 8，宽度 = 6。对角线长度 = sqrt(8 * 8 + 6 * 6) = sqrt(100) = 10。
因此，下标为 1 的矩形对角线更长，所以返回面积 = 8 * 6 = 48。

示例 2：

输入：dimensions = [[3,4],[4,3]]
输出：12
解释：两个矩形的对角线长度相同，为 5，所以最大面积 = 12。

说明：

• 1 <= dimensions.length <= 100
• dimensions[i].length == 2
• 1 <= dimensions[i][0], dimensions[i][1] <= 100

思路

依题意模拟即可。

代码

/**
 * @date 2025-08-26 8:45
 */
public class AreaOfMaxDiagonal3000 {

    /**
     * 网友题解
     */
    class Solution {
        public int areaOfMaxDiagonal(int[][] dimensions) {
            int ans = 0, maxL = 0;
            for (int[] d : dimensions) {
                int x = d[0], y = d[1];
                int l = x * x + y * y;
                if (l > maxL || l == maxL && x * y > ans) {
                    maxL = l;
                    ans = x * y;
                }
            }
            return ans;
        }
    }

    /**
     * 执行通过
     */
    public int areaOfMaxDiagonal(int[][] dimensions) {
        int res = 0;
        int diagonal = 0;
        for (int[] dimension : dimensions) {
            int length = dimension[0];
            int width = dimension[1];
            int cur = length * length + width * width;
            if (diagonal < cur) {
                res = length * width;
                // 出错点：不要忘记更新 diagonal
                diagonal = cur;
            } else if (diagonal == cur) {
                // 出错点：对角线相等需要分开处理，取面积的最大值
                res = Math.max(res, length * width);
            }
        }
        return res;
    }

}

性能

目标

给你一个仅由数字 6 和 9 组成的正整数 num。

你最多只能翻转一位数字，将 6 变成 9，或者把 9 变成 6 。

请返回你可以得到的最大数字。

示例 1：

输入：num = 9669
输出：9969
解释：
改变第一位数字可以得到 6669 。
改变第二位数字可以得到 9969 。
改变第三位数字可以得到 9699 。
改变第四位数字可以得到 9666 。
其中最大的数字是 9969 。

示例 2：

输入：num = 9996
输出：9999
解释：将最后一位从 6 变到 9，其结果 9999 是最大的数。

示例 3：

输入：num = 9999
输出：9999
解释：无需改变就已经是最大的数字了。

说明：

• 1 <= num <= 10^4
• num 每一位上的数字都是 6 或者 9 。

思路

有一个由 6 和 9 组成的数字，可以最多将一个 6 变成 9，返回可以得到的最大数字。

将左边第一个 6 变为 9 得到的数字最大。

代码

/**
 * @date 2025-08-16 17:09
 */
public class Maximum69Number1323 {

    public int maximum69Number(int num) {
        int l = String.valueOf(num).length();
        int pow10 = (int) Math.pow(10, l - 1);
        int n = num;
        while (pow10 > 0) {
            if (n / pow10 == 6) {
                return num + 3 * pow10;
            }
            n -= 9 * pow10;
            pow10 /= 10;
        }
        return num;
    }

}

性能

目标

给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 true ；否则，返回 false 。

整数 n 是 4 的幂次方需满足：存在整数 x 使得 n == 4^x

示例 1：

输入：n = 16
输出：true

示例 2：

输入：n = 5
输出：false

示例 3：

输入：n = 1
输出：true

说明：

• -2^31 <= n <= 2^31 - 1

进阶：你能不使用循环或者递归来完成本题吗？

思路

判断一个整数是否是 4 的幂。

参考 231.2的幂。

负数的二进制表示中前导零的个数为 0，而 4 的幂的前导零个数为奇数，恰好排除掉了负数。

代码

/**
 * @date 2025-08-15 8:43
 */
public class IsPowerOfFour342 {

    public boolean isPowerOfFour(int n) {
        return (n & (n - 1)) == 0 && Integer.numberOfLeadingZeros(n) % 2 == 1;
    }

}

性能

目标

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

示例 1：

输入：n = 1
输出：true
解释：20 = 1

示例 2：

输入：n = 16
输出：true
解释：24 = 16

示例 3：

输入：n = 3
输出：false

提示：

• -2^31 <= n <= 2^31 - 1

进阶：你能够不使用循环/递归解决此问题吗？

思路

判断数字是不是 2 的幂。

提前预处理 2 的幂。

进阶做法是判断 n & (n - 1) == 0。

代码

/**
 * @date 2025-08-09 20:33
 */
public class IsPowerOfTwo231 {

    static Set<Integer> set = new HashSet<>();

    static {
        for (int i = 0; i < 31; i++) {
            set.add(1 << i);
        }
    }

    public boolean isPowerOfTwo(int n) {
        return set.contains(n);
    }

}

性能

目标

给你两个长度为 n 的整数数组，fruits 和 baskets，其中 fruits[i] 表示第 i 种水果的 数量，baskets[j] 表示第 j 个篮子的 容量。

你需要对 fruits 数组从左到右按照以下规则放置水果：

• 每种水果必须放入第一个 容量大于等于 该水果数量的 最左侧可用篮子 中。
• 每个篮子只能装 一种 水果。
• 如果一种水果 无法放入 任何篮子，它将保持 未放置。

返回所有可能分配完成后，剩余未放置的水果种类的数量。

示例 1

输入： fruits = [4,2,5], baskets = [3,5,4]
输出： 1
解释：
fruits[0] = 4 放入 baskets[1] = 5。
fruits[1] = 2 放入 baskets[0] = 3。
fruits[2] = 5 无法放入 baskets[2] = 4。
由于有一种水果未放置，我们返回 1。

示例 2

输入： fruits = [3,6,1], baskets = [6,4,7]
输出： 0
解释：
fruits[0] = 3 放入 baskets[0] = 6。
fruits[1] = 6 无法放入 baskets[1] = 4（容量不足），但可以放入下一个可用的篮子 baskets[2] = 7。
fruits[2] = 1 放入 baskets[1] = 4。
由于所有水果都已成功放置，我们返回 0。

说明：

• n == fruits.length == baskets.length
• 1 <= n <= 100
• 1 <= fruits[i], baskets[i] <= 1000

思路

有一个数组 baskets 和 fruits，从左到右遍历 fruits，并删除 baskets 中第一个大于等于 fruits[i] 的元素，返回 baskets 最后剩余元素个数。

依题意模拟。

代码

/**
 * @date 2025-08-05 9:10
 */
public class NumOfUnplacedFruits3477 {

    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
        int n = fruits.length;
        int res = n;
        for (int fruit : fruits) {
            for (int i = 0; i < n; i++) {
                if (baskets[i] >= fruit){
                    res--;
                    baskets[i] = 0;
                    break;
                }
            }
        }
        return res;
    }

}

性能

目标

给你一个整数数组 nums 。

你可以从数组 nums 中删除任意数量的元素，但不能将其变为 空 数组。执行删除操作后，选出 nums 中满足下述条件的一个子数组：

• 子数组中的所有元素 互不相同 。
• 最大化 子数组的元素和。

返回子数组的 最大元素和 。

子数组 是数组的一个连续、非空 的元素序列。

示例 1：

输入：nums = [1,2,3,4,5]
输出：15
解释：
不删除任何元素，选中整个数组得到最大元素和。

示例 2：

输入：nums = [1,1,0,1,1]
输出：1
解释：
删除元素 nums[0] == 1、nums[1] == 1、nums[2] == 0 和 nums[3] == 1 。选中整个数组 [1] 得到最大元素和。

示例 3：

输入：nums = [1,2,-1,-2,1,0,-1]
输出：3
解释：
删除元素 nums[2] == -1 和 nums[3] == -2 ，从 [1, 2, 1, 0, -1] 中选中子数组 [2, 1] 以获得最大元素和。

说明：

• 1 <= nums.length <= 100
• -100 <= nums[i] <= 100

思路

有一个数组 nums，允许删除其中任意元素得到一个 非空 数组，使得最终数组中 不包含重复元素 并且所有 元素和最大。

为了使和最大，我们应该删掉所有的负数，同时对剩余元素去重累加求和。需要注意如果数组中全是负数，需要保留最大元素。

代码

/**
 * @date 2025-07-25 8:55
 */
public class MaxSum3487 {

    public int maxSum(int[] nums) {
        int sum = Arrays.stream(nums).distinct().filter(x -> x > 0).sum();
        if (sum == 0){
            OptionalInt max = Arrays.stream(nums).max();
            return max.isPresent() ? max.getAsInt() : sum;
        }
        return sum;
    }

}

性能

目标

一个字符串如果没有 三个连续 相同字符，那么它就是一个 好字符串 。

给你一个字符串 s ，请你从 s 删除 最少 的字符，使它变成一个 好字符串 。

请你返回删除后的字符串。题目数据保证答案总是 唯一的 。

示例 1：

输入：s = "leeetcode"
输出："leetcode"
解释：
从第一组 'e' 里面删除一个 'e' ，得到 "leetcode" 。
没有连续三个相同字符，所以返回 "leetcode" 。

示例 2：

输入：s = "aaabaaaa"
输出："aabaa"
解释：
从第一组 'a' 里面删除一个 'a' ，得到 "aabaaaa" 。
从第二组 'a' 里面删除两个 'a' ，得到 "aabaa" 。
没有连续三个相同字符，所以返回 "aabaa" 。

示例 3：

输入：s = "aab"
输出："aab"
解释：没有连续三个相同字符，所以返回 "aab" 。

说明：

• 1 <= s.length <= 10^5
• s 只包含小写英文字母。

思路

定义 好字符串 是不包含连续三个相同字符的字符串，给定一个字符串，删掉最少的字符使之变为好字符串。

记录连续重复字符个数，不同则重置，如果达到三个则跳过。

代码

/**
 * @date 2025-07-21 8:40
 */
public class MakeFancyString1957 {

    public String makeFancyString_v1(String s) {
        int n = s.length();
        char prev = ' ';
        int cnt = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (prev == c) {
                if (cnt < 2) {
                    cnt++;
                    sb.append(c);
                }
            } else {
                sb.append(c);
                prev = c;
                cnt = 1;
            }
        }
        return sb.toString();
    }

}

性能