D347周赛复盘：移除字符串中的尾随零+对角线上不同值的数量差

现在水平比较菜周赛最多只能搞出来两道，后面再争取多做一些

题外话：最近阳了发烧头晕恶心，学习很难推进，大家平常状态好的时候还是不要摆烂，不要像博主一样阳了还得苦哈哈地补进度……报应啊

移除字符串中的尾随零

给你一个用字符串表示的正整数 num ，请你以字符串形式返回不含尾随零的整数 num 。

示例 1：

输入：num = "51230100"
输出："512301"
解释：整数 "51230100" 有 2 个尾随零，移除并返回整数 "512301" 。

• 这道题思路上没什么问题，注意边界条件-1即可

class Solution {
public:
    string removeTrailingZeros(string num) {
         // 从后往前遍历字符串，找到第一个不为零的字符的位置
    int i = num.size() - 1;
    while (i >= 0 && num[i] == '0') {
        i--;
    }
    // 如果字符串全为零，返回空字符串
    if (i == -1) {
        return "";
    }
    // 否则，返回从开头到第一个不为零的字符的子字符串
    else {
        return num.substr(0, i + 1);
    }
        
    }
};

对角线上不同值的数量差

给你一个下标从 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) 的左上对角线。类似地，可以定义右下对角线。

在这里插入图片描述

输入：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 。

思路

使用两个嵌套循环遍历二维矩阵 grid 中的每个单元格，然后分别统计左上对角线和右下对角线上的不同元素的数量，并计算它们之差的绝对值，最后将结果保存在答案矩阵中。

• 这道题因为没有有序/无序的特殊要求，并且需要去重处理，因此选用查询/增删效率最优的unordered_set

class Solution {
public:
    vector<vector<int>> differenceOfDistinctValues(vector<vector<int>>& grid) {
     // 获取网格的行数和列数
    int m = grid.size(), n = grid[0].size();
    
    // 初始化答案矩阵为同样的大小，所有元素都是0
    vector<vector<int>> answer(m, vector<int>(n, 0));

    // 遍历网格的每一个元素
    for (int r = 0; r < m; ++r) {
        for (int c = 0; c < n; ++c) {
            // 初始化两个集合，用于存储左上对角线和右下对角线上的元素
            unordered_set<int> topLeftValues;
            unordered_set<int> bottomRightValues;

            // 遍历左上对角线上的元素，将每一个元素加入到集合中
            for (int i = r - 1, j = c - 1; i >= 0 && j >= 0; --i, --j) {
                topLeftValues.insert(grid[i][j]);
            }

            // 遍历右下对角线上的元素，将每一个元素加入到集合中
            for (int i = r + 1, j = c + 1; i < m && j < n; ++i, ++j) {
                bottomRightValues.insert(grid[i][j]);
            }

            // 计算左上对角线和右下对角线上的不同元素数量的差的绝对值，作为答案矩阵中对应位置的值
            answer[r][c] = abs((int)topLeftValues.size() - (int)bottomRightValues.size());
        }
    }

    // 返回答案矩阵
    return answer;
        
    }
};

主要思路是通过分别遍历每个元素的左上对角线和右下对角线，来计算对角线上的不同元素数量。

1. 接受一个二维网格 grid 作为输入,先获取网格的行数 m 和列数 n，然后初始化一个大小和 grid 相同的二维数组 answer 用于存储最终的结果。
2. 使用两层循环遍历 grid 中的每一个元素，对于当前元素，分别计算其左上对角线和右下对角线上的不同元素数量。我们使用两个 unordered_set（哈希集合）来存储左上对角线和右下对角线上的元素，这样可以自动去除重复元素，保证我们存储的都是不同的元素。
3. 对于左上对角线，我们从当前元素的左上角开始遍历，向左上方向移动，将遇到的每一个元素加入到 topLeftValues 这个集合中。同理，对于右下对角线，我们从当前元素的右下角开始遍历，向右下方向移动，将遇到的每一个元素加入到 bottomRightValues 这个集合中。
4. 在完成了上述步骤后，我们就分别获取到了左上对角线和右下对角线上的不同元素数量，只需要求出这两个数量的差的绝对值，就可以得到 answer 中对应位置的值。

另一种写法

相比于第一种来说，这种更好理解一些，这种方法核心思想就是利用nx和ny。

nx 和 ny 分别表示相对于当前单元格 (x, y) 的左上方向的偏移量。通过 nx = x - d 和 ny = y - d，我们可以在每次循环迭代中更新 nx 和 ny 的值，以便访问左上对角线上的其他单元格。

循环变量 d 代表当前循环迭代的步数，从 1 开始递增。通过将 d 逐渐增加，我们可以向左上方向移动离当前单元格 (x, y) 逐渐远的单元格。在每次循环迭代中，我们使用 nx = x - d 和 ny = y - d 计算出相对于 (x, y) 的左上方向的新坐标 (nx, ny)。

因此，通过这种方式，我们可以遍历左上对角线上的单元格，并在每次迭代中执行一些操作，如将元素添加到集合中。

#include <vector>
#include <unordered_set>
using namespace std;

class Solution {
public:
    // 计算答案矩阵
    vector<vector<int>> differenceOfDistinctValues(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> ans(m, vector<int>(n)); // 创建答案矩阵，初始化为0
        
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                ans[i][j] = cp(grid, i, j); // 计算每个单元格的值
            }
        }
        
        return ans;
    }
    
    // 计算单元格的值
    int cp(vector<vector<int>>& g, int x, int y) {
        unordered_set<int> s1, s2; // 使用unordered_set存储不同值
        
        // 向左上方向遍历，统计左上对角线上的不同值
        for (int d = 1; ; ++d) {
            int nx = x - d;
            int ny = y - d;
            if (nx >= 0 && ny >= 0) {
                s1.insert(g[nx][ny]);
            } else {
                break;
            }
        }
        
        // 向右下方向遍历，统计右下对角线上的不同值
        for (int d = 1; ; ++d) {
            int nx = x + d;
            int ny = y + d;
            if (nx < g.size() && ny < g[0].size()) {
                s2.insert(g[nx][ny]);
            } else {
                break;
            }
        }
        
        return abs(s1.size() - s2.size()); // 返回左上对角线和右下对角线上不同值的数量之差的绝对值
    }
};