2710. 移除字符串中的尾随零
给你一个用字符串表示的正整数 num ，请你以字符串形式返回不含尾随零的整数 num 。
示例 1：
输入：num = "51230100"
输出："512301"
解释：整数 "51230100" 有 2 个尾随零，移除并返回整数 "512301" 。
示例 2：
输入：num = "123"
输出："123"
解释：整数 "123" 不含尾随零，返回整数 "123" 。
提示：
1 <= num.length <= 1000
num 仅由数字 0 到 9 组成
num 不含前导零解答：按照题意模拟
class Solution {
public String removeTrailingZeros(String num) {
int n = num.length();
int i = n - 1;
// 找到第一个非零数字的位置
while (i >= 0 && num.charAt(i) == '0') {
i--;
}
// 构建结果字符串
StringBuilder sb = new StringBuilder();
for (int j = 0; j <= i; j++) {
sb.append(num.charAt(j));
}
return sb.toString();
}
}2711. 对角线上不同值的数量差
给你一个下标从 0 开始、大小为 m x n 的二维矩阵 grid ，请你求解大小同样为 m x n 的答案矩阵 answer 。
矩阵 answer 中每个单元格 (r, c) 的值可以按下述方式进行计算：
令 topLeft[r][c] 为矩阵 grid 中单元格 (r, c) 左上角对角线上 不同值 的数量。
令 bottomRight[r][c] 为矩阵 grid 中单元格 (r, c) 右下角对角线上 不同值 的数量。
然后 answer[r][c] = |topLeft[r][c] - bottomRight[r][c]| 。
返回矩阵 answer 。
矩阵对角线 是从最顶行或最左列的某个单元格开始，向右下方向走到矩阵末尾的对角线。
如果单元格 (r1, c1) 和单元格 (r, c) 属于同一条对角线且 r1 < r ，则单元格 (r1, c1) 属于单元格 (r, c) 的左上对角线。类似地，可以定义右下对角线。
示例 1：
输入：grid = [[1,2,3],[3,1,5],[3,2,1]]
输出：[[1,1,0],[1,0,1],[0,1,1]]
解释：第 1 个图表示最初的矩阵 grid 。
第 2 个图表示对单元格 (0,0) 计算，其中蓝色单元格是位于右下对角线的单元格。
第 3 个图表示对单元格 (1,2) 计算，其中红色单元格是位于左上对角线的单元格。
第 4 个图表示对单元格 (1,1) 计算，其中蓝色单元格是位于右下对角线的单元格，红色单元格是位于左上对角线的单元格。
- 单元格 (0,0) 的右下对角线包含 [1,1] ，而左上对角线包含 [] 。对应答案是 |1 - 0| = 1 。
- 单元格 (1,2) 的右下对角线包含 [] ，而左上对角线包含 [2] 。对应答案是 |0 - 1| = 1 。
- 单元格 (1,1) 的右下对角线包含 [1] ，而左上对角线包含 [1] 。对应答案是 |1 - 1| = 0 。
其他单元格的对应答案也可以按照这样的流程进行计算。
示例 2：
输入：grid = [[1]]
输出：[[0]]
解释：- 单元格 (0,0) 的右下对角线包含 [] ，左上对角线包含 [] 。对应答案是 |0 - 0| = 0 。
提示：
m == grid.length
n == grid[i].length
1 <= m, n, grid[i][j] <= 50解答：直接模拟
class Solution {
public int[][] differenceOfDistinctValues(int[][] grid) {
int m = grid.length, n = grid[0].length;
int[][] ans = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
Set<Integer> ts = new HashSet<>();
Set<Integer> bs = new HashSet<>();
int t = i - 1, l = j - 1;
int b = i + 1, r = j + 1;
while (t >= 0 && l >= 0) {
ts.add(grid[t--][l--]);
}
while (b < m && r < n) {
bs.add(grid[b++][r++]);
}
ans[i][j] = Math.abs(ts.size() - bs.size());
}
}
return ans;
}
}2712. 使所有字符相等的最小成本
给你一个下标从 0 开始、长度为 n 的二进制字符串 s ，你可以对其执行两种操作：
选中一个下标 i 并且反转从下标 0 到下标 i（包括下标 0 和下标 i ）的所有字符，成本为 i + 1 。
选中一个下标 i 并且反转从下标 i 到下标 n - 1（包括下标 i 和下标 n - 1 ）的所有字符，成本为 n - i 。
返回使字符串内所有字符 相等 需要的 最小成本 。
反转 字符意味着：如果原来的值是 '0' ，则反转后值变为 '1' ，反之亦然。
示例 1：
输入：s = "0011"
输出：2
解释：执行第二种操作，选中下标 i = 2 ，可以得到 s = "0000" ，成本为 2 。可以证明 2 是使所有字符相等的最小成本。
示例 2：
输入：s = "010101"
输出：9
解释：执行第一种操作，选中下标 i = 2 ，可以得到 s = "101101" ，成本为 3 。
执行第一种操作，选中下标 i = 1 ，可以得到 s = "011101" ，成本为 2 。
执行第一种操作，选中下标 i = 0 ，可以得到 s = "111101" ，成本为 1 。
执行第二种操作，选中下标 i = 4 ，可以得到 s = "111110" ，成本为 2 。
执行第一种操作，选中下标 i = 5 ，可以得到 s = "111111" ，成本为 1 。
使所有字符相等的总成本等于 9 。可以证明 9 是使所有字符相等的最小成本。
提示：
1 <= s.length == n <= 10^5
s[i] 为 '0' 或 '1'解答：灵神思路
class Solution {
public long minimumCost(String S) {
long ans = 0;
char[] s = S.toCharArray();
int n = s.length;
for (int i = 1; i < n; i++)
if (s[i - 1] != s[i])
ans += Math.min(i, n - i);
return ans;
}
}2713. 矩阵中严格递增的单元格数
给你一个下标从 1 开始、大小为 m x n 的整数矩阵 mat，你可以选择任一单元格作为 起始单元格 。
从起始单元格出发，你可以移动到 同一行或同一列 中的任何其他单元格，但前提是目标单元格的值 严格大于 当前单元格的值。
你可以多次重复这一过程，从一个单元格移动到另一个单元格，直到无法再进行任何移动。
请你找出从某个单元开始访问矩阵所能访问的 单元格的最大数量 。
返回一个表示可访问单元格最大数量的整数。
示例 1：
输入：mat = [[3,1],[3,4]]
输出：2
解释：上图展示了从第 1 行、第 2 列的单元格开始，可以访问 2 个单元格。可以证明，无论从哪个单元格开始，最多只能访问 2 个单元格，因此答案是 2 。
示例 2：
输入：mat = [[1,1],[1,1]]
输出：1
解释：由于目标单元格必须严格大于当前单元格，在本示例中只能访问 1 个单元格。
示例 3：
输入：mat = [[3,1,6],[-9,5,7]]
输出：4
解释：上图展示了从第 2 行、第 1 列的单元格开始，可以访问 4 个单元格。可以证明，无论从哪个单元格开始，最多只能访问 4 个单元格，因此答案是 4 。
提示：
m == mat.length
n == mat[i].length
1 <= m, n <= 10^5
1 <= m * n <= 10^5
-10^5 <= mat[i][j] <= 10^5解答：
