标签： easy

目标

给你一个 m x n 的整数矩阵 grid，以及三个整数 x、y 和 k。

整数 x 和 y 表示一个 正方形子矩阵 的左上角下标，整数 k 表示该正方形子矩阵的边长。

你的任务是垂直翻转子矩阵的行顺序。

返回更新后的矩阵。

示例 1：

输入： grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], x = 1, y = 0, k = 3
输出： [[1,2,3,4],[13,14,15,8],[9,10,11,12],[5,6,7,16]]
解释：
上图展示了矩阵在变换前后的样子。

示例 2：

输入： grid = [[3,4,2,3],[2,3,4,2]], x = 0, y = 2, k = 2
输出： [[3,4,4,2],[2,3,2,3]]
解释：
上图展示了矩阵在变换前后的样子。

说明：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• 1 <= grid[i][j] <= 100
• 0 <= x < m
• 0 <= y < n
• 1 <= k <= min(m - x, n - y)

思路

将矩阵 grid 的正方形子矩阵 (x, y, k) 上下翻转，(x, y) 表示子矩阵的左上顶点，k为子矩阵边长。

根据题意交换正方形子矩阵的上下对称的行即可。

代码

/**
 * @date 2026-04-17 11:11
 */
public class ReverseSubmatrix3643 {

    public int[][] reverseSubmatrix(int[][] grid, int x, int y, int k) {
        int l = k / 2;
        for (int i = 0; i < l; i++) {
            for (int j = y; j < y + k; j++) {
                int tmp = grid[x + i][j];
                grid[x + i][j] = grid[x + k - i - 1][j];
                grid[x + k - i - 1][j] = tmp;
            }
        }
        return grid;
    }
}

性能

目标

每个非负整数 N 都有其二进制表示。例如， 5 可以被表示为二进制 "101"，11 可以用二进制 "1011" 表示，依此类推。注意，除 N = 0 外，任何二进制表示中都不含前导零。

二进制的反码表示是将每个 1 改为 0 且每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。

给你一个十进制数 N，请你返回其二进制表示的反码所对应的十进制整数。

示例 1：

输入：5
输出：2
解释：5 的二进制表示为 "101"，其二进制反码为 "010"，也就是十进制中的 2 。

示例 2：

输入：7
输出：0
解释：7 的二进制表示为 "111"，其二进制反码为 "000"，也就是十进制中的 0 。

示例 3：

输入：10
输出：5
解释：10 的二进制表示为 "1010"，其二进制反码为 "0101"，也就是十进制中的 5 。

说明：

• 0 <= N < 10^9

思路

已知非负整数 N，求其二进制表示（不含前导零）取反后所表示的十进制数字。

如果直接 ~N 会对前导零取反，只需得到有效位的长度，然后与对应长度的二进制连续 1 异或即可。

代码

/**
 * @date 2026-03-11 8:47
 */
public class BitwiseComplement1009 {

    public int bitwiseComplement(int n) {
        if (n == 0) {
            return 1;
        }
        int l = 32 - Integer.numberOfLeadingZeros(n);
        return ((1 << l) - 1) ^ n;
    }

}

性能

目标

给你一个二进制字符串 s ，该字符串 不含前导零 。

如果 s 包含 零个或一个由连续的 '1' 组成的字段 ，返回 true​​​ 。否则，返回 false 。

示例 1：

输入：s = "1001"
输出：false
解释：由连续若干个 '1' 组成的字段数量为 2，返回 false

示例 2：

输入：s = "110"
输出：true

说明：

• 1 <= s.length <= 100
• s[i] 为 '0' 或 '1'
• s[0] 为 '1'

思路

有一个 不含前导零 的二进制字符串，判断除了开头连续的 1 之外还有没有其它的 1。

即判断是否存在 01 子串。

代码

/**
 * @date 2026-03-06 8:46
 */
public class CheckOnesSegment1784 {

    public boolean checkOnesSegment_v1(String s) {
        return s.indexOf("01") == -1;
    }

}

性能

目标

给你一个仅由字符 '0' 和 '1' 组成的字符串 s 。一步操作中，你可以将任一 '0' 变成 '1' ，或者将 '1' 变成 '0' 。

交替字符串 定义为：如果字符串中不存在相邻两个字符相等的情况，那么该字符串就是交替字符串。例如，字符串 "010" 是交替字符串，而字符串 "0100" 不是。

返回使 s 变成 交替字符串 所需的 最少 操作数。

示例 1：

输入：s = "0100"
输出：1
解释：如果将最后一个字符变为 '1' ，s 就变成 "0101" ，即符合交替字符串定义。

示例 2：

输入：s = "10"
输出：0
解释：s 已经是交替字符串。

示例 3：

输入：s = "1111"
输出：2
解释：需要 2 步操作得到 "0101" 或 "1010" 。

说明：

• 1 <= s.length <= 10^4
• s[i] 是 '0' 或 '1'

思路

有一个字符串 s，每次操作可以任选一个 0 变成 1 或者 1 变成 0，返回将字符串变为交替字符串的最小操作次数。

对于特定长度的交替字符串只有两种可能，考虑第一个字符是 1 还是 0，记录将 s 变为交替字符的操作次数，取其最小值即可。

一般地，如果变成 t0=010101⋯ 需要修改 k 次，那么由于 t1=101010⋯ 每个位置都和 t0 不同，变成 t0 需要修改的字符，变成 t1 无需修改；变成 t0 不需要修改的字符，变成 t1 需要修改。所以变成 t1 需要修改 n−k 次。答案为 min(k, n−k)。

代码

/**
 * @date 2026-03-05 8:51
 */
public class MinOperations1758 {

    public int minOperations(String s) {
        int res1 = 0, res2 = 0;
        char[] chars = s.toCharArray();
        char prev1 = '0', prev2 = '1';
        for (char c : chars) {
            if (c == prev1) {
                res1++;
            }
            if (c == prev2) {
                res2++;
            }
            prev1 ^= 1;
            prev2 ^= 1;
        }
        return Math.min(res1, res2);
    }

}

性能

目标

给定一个 m x n 的二进制矩阵 mat，返回矩阵 mat 中特殊位置的数量。

如果位置 (i, j) 满足 mat[i][j] == 1 并且行 i 与列 j 中的所有其他元素都是 0（行和列的下标从 0 开始计数），那么它被称为 特殊 位置。

示例 1：

输入：mat = [[1,0,0],[0,0,1],[1,0,0]]
输出：1
解释：位置 (1, 2) 是一个特殊位置，因为 mat[1][2] == 1 且第 1 行和第 2 列的其他所有元素都是 0。

示例 2：

输入：mat = [[1,0,0],[0,1,0],[0,0,1]]
输出：3
解释：位置 (0, 0)，(1, 1) 和 (2, 2) 都是特殊位置。

说明：

• m == mat.length
• n == mat[i].length
• 1 <= m, n <= 100
• mat[i][j] 是 0 或 1。

思路

返回二进制矩阵 mat 的特殊位置个数，所谓特殊位置指，当前位置的值为 1，且所在行列的其它元素均为 0。

计算每行每列中 1 的个数，如果当前单元格的值为 1，且行列 1 的个数也是 1，累加结果。

代码

/**
 * @date 2026-03-04 9:50
 */
public class NumSpecial1582 {

    public int numSpecial(int[][] mat) {
        int m = mat.length, n = mat[0].length;
        int[] rc = new int[m];
        int[] cc = new int[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                rc[i] += mat[i][j];
                cc[j] += mat[i][j];
            }
        }
        int res = 0;
        for (int i = 0; i < m; i++) {
            if (rc[i] > 1) {
                continue;
            }
            for (int j = 0; j < n; j++) {
                if (cc[j] == 1 && mat[i][j] == 1) {
                    res++;
                }
            }
        }
        return res;
    }
}

性能

目标

给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。

如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。

请你返回排序后的数组。

示例 1：

输入：arr = [0,1,2,3,4,5,6,7,8]
输出：[0,1,2,4,8,3,5,6,7]
解释：[0] 是唯一一个有 0 个 1 的数。
[1,2,4,8] 都有 1 个 1 。
[3,5,6] 有 2 个 1 。
[7] 有 3 个 1 。
按照 1 的个数排序得到的结果数组为 [0,1,2,4,8,3,5,6,7]

示例 2：

输入：arr = [1024,512,256,128,64,32,16,8,4,2,1]
输出：[1,2,4,8,16,32,64,128,256,512,1024]
解释：数组中所有整数二进制下都只有 1 个 1 ，所以你需要按照数值大小将它们排序。

示例 3：

输入：arr = [10000,10000]
输出：[10000,10000]

示例 4：

输入：arr = [2,3,5,7,11,13,17,19]
输出：[2,3,5,17,7,11,13,19]

示例 5：

输入：arr = [10,100,1000,10000]
输出：[10,100,10000,1000]

说明：

• 1 <= arr.length <= 500
• 0 <= arr[i] <= 10^4

思路

将数组 arr 中的元素按照 bitCount 升序排列，如果相等根据元素值升序排列。

代码

/**
 * @date 2026-02-25 8:42
 */
public class SortByBits1356 {

    public int[] sortByBits(int[] arr) {
        return Arrays.stream(arr)
                .boxed()
                .sorted(Comparator.comparing(Integer::bitCount).thenComparing(Integer::intValue))
                .mapToInt(Integer::intValue)
                .toArray();
    }

}

性能

目标

给定一个正整数 n，找到并返回 n 的二进制表示中两个 相邻 1 之间的 最长距离 。如果不存在两个相邻的 1，返回 0 。

如果只有 0 将两个 1 分隔开（可能不存在 0 ），则认为这两个 1 彼此 相邻 。两个 1 之间的距离是它们的二进制表示中位置的绝对差。例如，"1001" 中的两个 1 的距离为 3 。

示例 1：

输入：n = 22
输出：2
解释：22 的二进制是 "10110" 。
在 22 的二进制表示中，有三个 1，组成两对相邻的 1 。
第一对相邻的 1 中，两个 1 之间的距离为 2 。
第二对相邻的 1 中，两个 1 之间的距离为 1 。
答案取两个距离之中最大的，也就是 2 。

示例 2：

输入：n = 8
输出：0
解释：8 的二进制是 "1000" 。
在 8 的二进制表示中没有相邻的两个 1，所以返回 0 。

示例 3：

输入：n = 5
输出：2
解释：5 的二进制是 "101" 。

说明：

• 1 <= n <= 10^9

思路

判断正整数二进制表示中两个 1 之间 0 的个数，返回其长度 +1，如果不存在返回 0。

根据题意模拟，先去掉右侧的尾零，然后记录 1 前面连续 0 的个数，取最大值即可。

代码

/**
 * @date 2026-02-24 15:03
 */
public class BinaryGap868 {

    public int binaryGap(int n) {
        int res = 0;
        while (n > 0) {
            while (n > 0 && (n & 1) == 0) {
                n >>= 1;
            }
            if (n == 0) {
                break;
            }
            n >>= 1;
            int cnt = 0;
            while (n > 0 && (n & 1) == 0) {
                n >>= 1;
                cnt++;
            }
            if (n > 0) {
                res = Math.max(res, cnt + 1);
            }
        }
        return res;
    }

}

性能

目标

给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。

重复出现（不同位置）的子串也要统计它们出现的次数。

示例 1：

输入：s = "00110011"
输出：6
解释：6 个子串满足具有相同数量的连续 1 和 0 ："0011"、"01"、"1100"、"10"、"0011" 和 "01" 。
注意，一些重复出现的子串（不同位置）要统计它们出现的次数。
另外，"00110011" 不是有效的子串，因为所有的 0（还有 1 ）没有组合在一起。

示例 2：

输入：s = "10101"
输出：4
解释：有 4 个子串："10"、"01"、"10"、"01" ，具有相同数量的连续 1 和 0 。

说明：

• 1 <= s.length <= 10^5
• s[i] 为 '0' 或 '1'

思路

统计二进制字符串 s 中满足条件的子串个数。子串需满足 0 与 1 的个数相等，且子串中所有 0 都是相邻且连续的（由于数量相同，子串中所有的 1 也是相邻且连续的），即 0 与 1 都是成组连续的。

00011 满足条件的子串个数为 min(3, 2)，可以分组循环字符串，记录前一组的个数，累加二者最小值即可。

代码

/**
 * @date 2026-02-24 16:14
 */
public class CountBinarySubstrings696 {

    public int countBinarySubstrings(String s) {
        char[] chars = s.toCharArray();
        int n = chars.length;
        int preCnt = 0;
        int i = 0;
        int res = 0;
        while (i < n) {
            int start = i;
            while (i < n && chars[start] == chars[i]) {
                i++;
            }
            int cnt = i - start;
            res += Math.min(preCnt, cnt);
            preCnt = cnt;
        }
        return res;
    }

}

性能