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

class Solution {
public:
    string removeTrailingZeros(string num) {
        stack<char> q;
        for(int i = 0; i < num.size(); ++i){
            q.push(num[i]);
        }
        while(!q.empty() && q.top() == '0'){
            q.pop();
        }
        string s;
        while(!q.empty()){
            s += q.top();
            q.pop();
        }
        reverse(s.begin(), s.end());
    return s;
    }
};

(1) 去除尾随0，那么就利用栈，然后去除栈顶的0即可。

(2) 因为栈是后进先出的，将栈中剩下的字符压入进字符串s后要将s反转一下才是最后的结果。

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

class Solution {
public:
    vector<vector<int>> differenceOfDistinctValues(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> res;
        res.resize(m);
        int hash[100];
        for(int i = 0; i < m; ++i){
            res[i].resize(n);
        }
        memset(hash, 0, sizeof(hash));
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                int cnt1 = 0;
                int cnt2 = 0;
                int tx1 = i - 1;
                int ty1 = j - 1;
                int tx2 = i + 1;
                int ty2 = j + 1;
                memset(hash, 0, sizeof(hash));
                while(tx1 >= 0 && ty1 >= 0){
                    if(hash[grid[tx1][ty1]] == 0){
                        hash[grid[tx1][ty1]] = 1;
                        cnt1++;
                    }
                    tx1--;
                    ty1--;
                }
                memset(hash, 0, sizeof(hash));
                while(tx2 < m && ty2 < n){
                    if(hash[grid[tx2][ty2]] == 0){
                        hash[grid[tx2][ty2]] = 1;
                        cnt2++;
                    }
                    tx2++;
                    ty2++;
                }
                res[i][j] = abs(cnt1 - cnt2);
            }
        }
    return res;
    }
};

(1) 这道题目就是模拟题目，模拟思路(2)中所说。

(2) 对于每个点，利用哈希表来统计左对角线的不同元素的个数，同样利用哈希表来统计右下对角线的不同元素的个数。

(3) 最后返回结果数组即可。

给你一个下标从 0 开始、长度为 n 的二进制字符串 s ，你可以对其执行两种操作：

• 选中一个下标 i 并且反转从下标 0 到下标 i（包括下标 0 和下标 i ）的所有字符，成本为 i + 1 。
• 选中一个下标 i 并且反转从下标 i 到下标 n - 1（包括下标 i 和下标 n - 1 ）的所有字符，成本为 n - i

返回使字符串内所有字符 相等 需要的 最小成本 。

反转 字符意味着：如果原来的值是 ‘0’ ，则反转后值变为 ‘1’ ，反之亦然。

class Solution {
    long long max(long long x, long long y){
        return x > y ? x : y;
    }
public:
    long long minimumCost(string s) {
        int n = s.size();
        long long dp1[n+5][2];// 0 ~ x
        long long dp2[n+5][2];// x ~ n-1;
        memset(dp1, 0, sizeof(dp1));
        memset(dp2, 0, sizeof(dp2));
        for(int i = 0; i < n; ++i){
            if(i == 0){
                if(s[i] == '0'){
                    dp1[0][1] = 1;
                } else{
                    dp1[0][0] = 1;
                }
                continue;
            }
            if(s[i] == '1'){
                dp1[i][1] = dp1[i-1][1];
                dp1[i][0] = dp1[i-1][1] + i + 1; 
            } else{
                dp1[i][0] = dp1[i-1][0];
                dp1[i][1] = dp1[i-1][0] + i + 1;
            }
        }
        for(int i = n-1; i >= 0; --i){
            if(i == n - 1){
                if(s[i] == '0'){
                    dp2[n-1][1] = 1;
                } else{
                    dp2[n-1][0] = 1;
                }
                continue;
            }
            if(s[i] == '1'){
                dp2[i][0] = dp2[i+1][1] + n - i;
                dp2[i][1] = dp2[i+1][1];
            } else{
                dp2[i][0] = dp2[i+1][0];
                dp2[i][1] = dp2[i+1][0] + n - i;
            }
        }
        long long min0 = min(dp2[0][0], dp2[0][1]);
        for(int i = 0; i < n; ++i){
            if(i == n-1){
                min0 = min(dp1[n-1][0], min0);
                min0 = min(dp1[n-1][1], min0);
                continue;
            }
            min0 = min(dp1[i][0] + dp2[i+1][0], min0);
            min0 = min(dp1[i][1] + dp2[i+1][1], min0);
        }
    return min0;
    }
};

(1) 采用动态规划的方法，dp1[i][0] 表示下标从0_{i全变成0的最小成本，dp1[i][1]表示下标从0}i全变成1的最小成本。dp2[i][0]表示下标从i到n-1全变成0的最小成本，dp2[i][1]表示下标从i到n-1全变成1的最小成本。

(2) 状态转移方程与s[i]是0还是1有关，是0的话，想要变成全0就将前面的翻转成0，想要变成全1的一个思路。

(3) 最后再遍历每一个位置x，每次更新最小值，每次的可能性为两种将0~x全变成0，将x+1 ~ n - 1全变成0 和 将0 ~ x全变成1和将 x + 1 ~ n - 1全变成1。

给你一个下标从 1 开始、大小为 m x n 的整数矩阵 mat，你可以选择任一单元格作为 起始单元格 。

从起始单元格出发，你可以移动到 同一行或同一列 中的任何其他单元格，但前提是目标单元格的值 严格大于 当前单元格的值。

你可以多次重复这一过程，从一个单元格移动到另一个单元格，直到无法再进行任何移动。

请你找出从某个单元开始访问矩阵所能访问的 单元格的最大数量 。

返回一个表示可访问单元格最大数量的整数。

class Solution {
    map<int, vector<pair<int, int>> >mp;
public:
    int maxIncreasingCells(vector<vector<int>>& mat) {
        int m = mat.size();
        int n = mat[0].size();
        int dp[m+5][n+5];
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                mp[mat[i][j]].emplace_back(i ,j);
            }
        }
        vector<int> mx_row(m+1);
        vector<int> mx_line(n+1);
        for(auto iter = mp.begin(); iter != mp.end(); ++iter){
            int val = iter->first;
            vector<pair<int, int>> p = iter->second;
            for(int i = 0; i < p.size(); ++i){
                int x = p[i].first;
                int y = p[i].second;
                dp[x][y] = max(mx_row[x] + 1, mx_line[y] + 1);
            }
            for(int i = 0; i < p.size(); ++i){
                int x = p[i].first;
                int y = p[i].second;
                mx_row[x] = max(mx_row[x], dp[x][y]);
                mx_line[y] = max(mx_line[y], dp[x][y]);
            }
        }
        int max0 = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                max0 = max(max0, dp[i][j]);
            }
        }
    return max0;
    }
};

(1) 使用map，将所有点的值和位置存储起来。

(2) 运用动态规划，dp[i][j]表示在（i，j）处元素的单元格最大数量为多少。

(3) 按照值从小到大遍历，然后遍历相同值的方位，最大值为这一行的最大值+1或者这一列的最大值+1、然后再遍历一遍该值的所有位置，然后更新行最大值和列最大值。

(3) 最后返回dp[i][j]的最大值即可。

心若在，梦就在，只不过是从头再来。哪怕每次周赛一题都做不出来，都得努力去研究，因为未来的某一天一定能够进步的。