leetcode周赛347前三题题解

1.移除字符串中的尾随零

题目描述

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

示例 1：

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

示例 2：

输入：num = "123"
输出："123"
解释：整数 "123" 不含尾随零，返回整数 "123" 。

提示：

• 1 <= num.length <= 1000
• num 仅由数字 0 到 9 组成
• num 不含前导零

思路: 从末尾遍历,发现为0就去除掉,时间复杂度$O(n)$,注意可以直接从num.back()开始判断

class Solution {
public:
    string removeTrailingZeros(string num) {
        while(num.back() == '0')
        {
            num.pop_back();
        }
        return num;
    }
};

2.对角线上不同值的数量差

给你一个下标从 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

思路:我们可以构造题目中的top数组和bot数组,然后对这两个数组取差值绝对值就行.构造数组可以看看下面的几个技巧,可以在主函数中用lambda函数实现check函数,这样就方便很多了.还有沿着对角线构造,我们可以考虑x=i, y=j可以直接判断x和y的合法性即可.

时间复杂度$O(n\ast m)$只是遍历了数组

class Solution {
public:
    vector<vector<int>> differenceOfDistinctValues(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<int>> top(n, vector<int>(m, 0));
        vector<vector<int>> bot(n, vector<int>(m, 0));
        auto check = [n, m](int a, int b){
            return a >= 0 && a < n && b >= 0 && b < m;
        };
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
            {
                unordered_set<int> hash;
                int x = i, y = j;
                while(check(x + 1, y + 1))
                {
                    hash.insert(grid[x + 1][y + 1]);
                    x ++;
                    y ++;
                }
                top[i][j] = (int)hash.size();
            }
        }
        //return top;
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
            {
                unordered_set<int> hash;
                int x = i, y = j;
                while(check(x - 1, y - 1))
                {
                    hash.insert(grid[x - 1][y - 1]);
                    x --;
                    y --;
                }
                bot[i][j] = (int)hash.size();
            }
        }
        
        vector<vector<int>> res(n, vector<int>(m, 0));
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
            {
                res[i][j] = abs(top[i][j] - bot[i][j]);
            }
        }
        return res;


    }
};

3.使所有字符相等的最小成本

给你一个下标从 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 <= 105
• s[i] 为 '0' 或 '1'

算法1

思路:动态规划,可以通过动态规划预处理所有前缀位置变更的成本.设$f_0(i)$表示将前i个字符都变更成0所需要成本,$f_1(i)$表示将前i个字符都变更成1所需要的成本.$i$的有效下标从$1$开始

初始时$f_0(0)=f_1(0)=0$,其余待定

转移时:假设当前位置为$0$,则$f_0(i)=min(f_0(i-1),f_1(i-1)+i-1)$

简单解释:如果前i-1个已经为0了,则不需要新加成本,如果前(i-1)个变成1了,则需要将这些重新变成0需要i-1的成本

同理当前位置为0, $f_1(i)=min(f_0(i-1)+i,f_1(i-1)+i-1+i)$

简单解释:如果前i-1个已经为0了,需要把当前这个也加上即i个变成1,如果前(i-1)个变成1了,则需要将这些重新变成0,再重新变成1,总共需要i-1 + 1的成本

如果当前位置为1,转移方程类似.

然后，从后往前遍历字符串，遍历过程中，仿照上述过程处理每个后缀变更所需要的成本，然后前后缀两个成本累加更新答案。

时间复杂度:每一轮动态规划的状态数为$O(n)$,转移时间为常数,故时间复杂度为$O(n)$

#define LL long long

class Solution {
public:
    LL minimumCost(string s) {
        const int n = s.size();
        vector<LL> f0(n + 1), f1(n + 1);

        f0[0] = f1[0] = 0;
        for (int i = 1; i <= n; i++) {
            if (s[i - 1] == '0') {
                f0[i] = min(f0[i - 1], f1[i - 1] + i - 1);
                f1[i] = min(f0[i - 1] + i, f1[i - 1] + 2 * i - 1);
            } else {
                f0[i] = min(f0[i - 1] + 2 * i - 1, f1[i - 1] + i);
                f1[i] = min(f0[i - 1] + i - 1, f1[i - 1]);
            }
        }

        LL ans = min(f0[n], f1[n]);
        LL g0 = 0, g1 = 0;

        for (int i = n; i >= 1; i--) {
            LL t0 = g0, t1 = g1;
            if (s[i - 1] == '0') {
                g0 = min(t0, t1 + n - i);
                g1 = min(t0 + n - i + 1, t1 + 2 * (n - i) + 1);
            } else {
                g0 = min(t0 + 2 * (n - i) + 1, t1 + n - i + 1);
                g1 = min(t0 + n - i, t1);
            }

            ans = min(ans, min(f0[i - 1] + g0, f1[i - 1] + g1));
        }

        return ans;
    }
};

算法2

思路:思维题

注意到,每一次出现$s[i]!=s[i-1]$的位置,必定前缀变动i,或者后缀变动i + 1,注意到,变动后,会使得$s[i]=s[i+1]$,且其他相邻位置的相等关系不受任何影响.可以看看下面的例子.

10110 00110 11110 11111

从前往后遍历字符串，遇到每一个上述位置，比较两次变动的代价，取最小的代价累加。

时间复杂度$O(n)$

#define LL long long

class Solution {
public:
    LL minimumCost(string s) {
        const int n = s.size();

        LL ans = 0;
        for (int i = 0; i < n - 1; i++)
            if (s[i] != s[i + 1])
                ans += min(i + 1, n - i - 1);

        return ans;
    }
};