学习算法思想一

适合打劫银行的日子–2100–中等

这道题用到了前缀和的思想

为了方便，我们令 nn 为 securitysecurity 长度。

根据题目对「适合打劫银行的日子」的定义，首先我们可以确定答案落在 [time, n - time)[time,n−time) 范围内，另外规定了「适合打劫银行的日子」左右侧需要满足「非递增」和「非递减」的性质。

首先我们可以预处理 g 数组，g[i] 代表当前时间 security[i]与前一时间 security[i - 1]的大小关系，当 security[i] > security[i - 1] 时有 g[i] = 1g[i]=1，当 security[i] < security[i - 1]时有 g[i] = -1，否则 g[i] = 0，另外我们特别的有 g[0] = 0的边界情况。然后我们对 g 应

用 [前缀和] 思想：使用 a 数组记录前缀 1的数量，使用 b 数组记录前缀 -1的数量。最终，如果 i为适合打劫银行的日子，那么满足 time <= i < n - time，且满足 (i - time, i](i−time,i] 范围前缀 1数量为 0，(i, i + time](i,i+time] 范围前缀 -1数量为 0。C:

int* goodDaysToRobBank(int* security, int securitySize, int time, int* returnSize) {
    int * left = (int *)malloc(sizeof(int) * securitySize);
    int * right = (int *)malloc(sizeof(int) * securitySize);
    memset(left, 0, sizeof(int) * securitySize);
    memset(right, 0, sizeof(int) * securitySize);
    for (int i = 1; i < securitySize; i++) {
        if (security[i] <= security[i - 1]) {
            left[i] = left[i - 1] + 1;
        }
        if (security[securitySize - i - 1] <= security[securitySize - i]) {
            right[securitySize - i - 1] = right[securitySize - i] + 1;
        }
    }//根据题目统计符合的前缀

    int * ans = (int *)malloc(sizeof(int) * securitySize);
    int pos = 0;
    for (int i = time; i < securitySize - time; i++) {
        if (left[i] >= time && right[i] >= time) {
            ans[pos++] = i;
        }
    }
    free(left);
    free(right);
    *returnSize = pos;
    return ans;
}

长度为三的不同回文子序列–1930–中等

我们可以枚举回文序列两侧的字符种类。对于每种字符，如果它在字符串 ss中出现，我们记录它第一次出现的下标 l 与最后一次出现的下标 r。那么，以该字符为两侧的回文子序列，它中间的字符只可能在 s[l+1…r-1]中选取；且以该字符为两侧的回文子序列的种数即为 s[l+1…r-1] 中的字符种数。

我们遍历 s[l+1…r-1] 子串计算该子串中的字符种数。在遍历时，我们可以使用哈希集合来维护该子串中的字符种类；当遍历完成后，哈希集合内元素的数目即为该子串中的字符总数。

在枚举两侧字符种类时，我们维护这些回文子序列种数之和，并最终作为答案返回。C++:

class Solution {
public:
    int countPalindromicSubsequence(string s) {
        int n = s.size();
        int res = 0;
        // 枚举两侧字符
        for (char ch = 'a'; ch <= 'z'; ++ch){
            int l = 0, r = n - 1;
            // 寻找该字符第一次出现的下标
            while (l < n && s[l] != ch){
                ++l;
            }
            // 寻找该字符最后一次出现的下标
            while (r >= 0 && s[r] != ch){
                --r;
            }
            if (r - l < 2){
                // 该字符未出现，或两下标中间的子串不存在
                continue;
            }
            // 利用哈希集合统计 s[l+1..r-1] 子串的字符总数，并更新答案
            unordered_set<char> charset;
            for (int k = l + 1; k < r; ++k){
                charset.insert(s[k]);
            }
            res += charset.size();
        }
        return res;
    }
};

各位相加–258–简单

最直观的方法是模拟各位相加的过程，直到剩下的数字是一位数。

计算一个整数的各位相加的做法是，每次计算当前整数除以 10 的余数得到最低位数，将最低位数加到总和中，然后将当前整数除以 10。重复上述操作直到当前整数变成 0，此时的总和即为原整数各位相加的结果。C:

int addDigits(int num){
    while (num >= 10) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }
        num = sum;
    }
    return num;
}

加一–66–简单

当我们对数组 \textit{digits}digits 加一时，我们只需要关注 \textit{digits}digits 的末尾出现了多少个 9 即可。我们可以考虑如下的三种情况：

如果 \textit{digits}digits 的末尾没有 9，例如 [1, 2, 3][1,2,3]，那么我们直接将末尾的数加一，得到 [1, 2, 4][1,2,4] 并返回；

如果 \textit{digits}digits 的末尾有若干个 9，例如 [1, 2, 3, 9, 9][1,2,3,9,9]，那么我们只需要找出从末尾开始的第一个不为 9 的元素，即 3，将该元素加一，得到 [1, 2, 4, 9, 9][1,2,4,9,9]。随后将末尾的 99全部置零，得到 [1, 2, 4, 0, 0][1,2,4,0,0] 并返回。

如果 \textit{digits}digits 的所有元素都是 9，例如 [9, 9, 9, 9, 9][9,9,9,9,9]，那么答案为 [1, 0, 0, 0, 0, 0][1,0,0,0,0,0]。我们只需要构造一个长度比 \textit{digits}digits 多 1 的新数组，将首元素置为 1，其余元素置为 0 即可。

我们只需要对数组 \textit{digits}digits 进行一次逆序遍历，找出第一个不为 9 的元素，将其加一并将后续所有元素置零即可。如果 \textit{digits}digits 中所有的元素均为 9，那么对应着「思路」部分的第三种情况，我们需要返回一个新的数组。

C++:

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int n = digits.size();
        for (int i = n - 1; i >= 0; --i) {
            if (digits[i] != 9) {
                ++digits[i];
                for (int j = i + 1; j < n; ++j) {
                    digits[j] = 0;
                }
                return digits;
            }
        }

        // digits 中所有的元素均为 9
        vector<int> ans(n + 1);
        ans[0] = 1;
        return ans;
    }
};

有效的括号–20–简单

判断括号的有效性可以使用「栈」这一数据结构来解决。

我们遍历给定的字符串 s。当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。

当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么字符串 ss 无效，返回 \text{False}False。为了快速判断括号的类型，我们可以使用哈希表存储每一种括号。哈希表的键为右括号，值为相同类型的左括号。

在遍历结束后，如果栈中没有左括号，说明我们将字符串 s中的所有左括号闭合，返回 \text{True}True，否则返回 \text{False}False。

注意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，我们可以直接返回 \text{False}False，省去后续的遍历判断过程。C:

char pairs(char a) {
    if (a == '}') return '{';
    if (a == ']') return '[';
    if (a == ')') return '(';
    return 0;
}

bool isValid(char* s) {
    int n = strlen(s);
    if (n % 2 == 1) {
        return false;
    }
    int stk[n + 1], top = 0;
    for (int i = 0; i < n; i++) {
        char ch = pairs(s[i]);
        if (ch) {
            if (top == 0 || stk[top - 1] != ch) {
                return false;
            }
            top--;
        } else {
            stk[top++] = s[i];
        }
    }
    return top == 0;
}