[朝花夕拾] LeetCode刷题记录

前言：

 

20220228

1. 两数之和

本来不想做的，无聊点开题解才发现竟然不是简单的 A + B Problem。

方法一：暴力枚举

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n - 1; i++)
            for (int j = i + 1; j < n; j++)
                if (nums[i] + nums[j] == target)
                    return {i, j}; 
        return {};
    }
};

注意：L9 的 return {} 不能省略，尽管题目说明了不会存在没有结果的情况，但对于编译器而言则必须要求在所有情况下都有返回值。

方法二：哈希表

由于答案对是唯一的，我们可以只扫描一次，用 target 减去当前值 nums[i]，再判断 nums 中是否有余下的数。由于数据范围远大于数据量，采用哈希表可节省大量空间。在 C++ 中一般使用 map 实现哈希表。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int t) {
        int n = nums.size();
        map<int, int> mp;
        for (int i = 0; i < n; i++) {
            auto it = mp.find(t - nums[i]);
            if (it != mp.end())
                return {it -> second, i};
            mp[nums[i]] = i;
        }
        return {};
    }
};

 

2. 两数相加

本质上考察链表的处理。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int c = 0;
        ListNode *h = NULL, *t = NULL;
        while (l1 || l2) {
            int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + c;
            if (!h)
                h = t = new ListNode(sum % 10);
            else {
                t->next = new ListNode(sum % 10);
                t = t->next;
            }
            c = sum / 10;
            if (l1)
                l1 = l1->next;
            if (l2)
                l2 = l2->next;
        }
        if (c > 0)
            t->next = new ListNode(c);
        return h;
    }
};

 

3. 无重复字符的最长子串

方法：双指针法（LC官方写的是滑动窗口）

设置左指针和右指针，右指针依次向右移动，如果指向字符之前出现在某个位置，且该位置在左指针的左侧，则说明为了维持无重复字符，则左指针需要跳到该位置的后一个位置；

所以这个过程中需要维护一个数组 a，a[i] 表示字符 i 上次出现的位置。两个指针在移动过程中，其间的区间大小一直在变化，而变化过程中的最大值即为答案。

（官方的题解的左指针是依次向右移动而非跳跃的，大概是因为使用的 set，这样相当于用更多时间换取了更少空间）

const int N = 130;

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int l = s.length(), h = 0, t = 0, ans = 0, a[N];
        memset(a, -1, sizeof(a));
        while (t < l) {
            if (a[s[t]] != -1)
            　　h = max(h, a[s[t]] + 1);
            a[s[t]] = t;
            ans = max(ans, t - h + 1);
            t++;
        }
        return ans;
    }
};

 

20220301

4. 不会做

5. 最长回文子串

方法一：枚举（LC官方写的中心扩展算法）

枚举每个字符，以其为回文串的中心点向左向右扩展，直到不满足回文串要求。偶回文串与奇回文串需要分开讨论。

class Solution {
public:
    string longestPalindrome(string s) {
        int l = s.length(), ans = 1, st = 0;
        for (int i = 0; i < l; i++) {
            int j = 0;
            while (j <= i && i + j < l && s[i - j] == s[i + j])
                j++;
            if (2 * j - 1 > ans)
                st = i - j + 1, ans = 2 * j - 1;
        }
        for (int i = 0; i < l - 1; i++) {
            if (s[i] != s[i + 1]) continue;
            int j = 1;
            while (j <= i && i + j - 1 < l && s[i - j] == s[i + j + 1])
                j++;
            if (2 * j > ans)
                st = i - j + 1, ans = 2 * j;
        }
        return s.substr(st, ans);
    }
};

P.S. string 的截取函数为 substr。

其他：时间复杂度 O(n) 的 Manacher 算法与 O(n ^ 2) 的动态规划。

 

7. 整数反转

class Solution {
public:
    int reverse(int x) {
        long long o = 0;
        while (x) o *= 10, o += x % 10, x /= 10;
        if (o < INT_MIN || o > INT_MAX) return 0;
        return o;
    }
};

 

8. 字符串转换整数（atoi）

class Solution {
public:
    int myAtoi(string s) {
        int o = 0, l = s.length(), f = 0;
        long long ans = 0;
        while (o < l && s[o] == ' ') o++;
        if (o < l && s[o] == '+') f = 0, o++;
        else if (o < l && s[o] == '-') f = 1, o++;
        while (o < l && s[o] == '0') o++;
        while (o < l && s[o] >= '0' && s[o] <= '9') {
            ans *= 10, ans += s[o] - '0', o++;
            if (ans > INT_MAX) return f ? INT_MIN : INT_MAX;
        }
        if (f) ans = -ans;
        return ans;
    }
};

 

20220302

剑指 Offer 3. 数组中重复的数字

方法一：排序

将数组排序，然后查找是否存在相邻且相等的元素。

class Solution {
public:
    int findRepeatNumber(vector<int>& a) {
        int l = a.size();
        sort(a.begin(), a.end());
        for (int i = 1; i < l; i++)
            if (a[i] == a[i - 1])
                return a[i];
        return 0;
    }
};

方法二：枚举查重

把读入的元素进行记录（使用数组、map、set均可），出现记录过的数字即表示重复元素。

class Solution {
public:
    int findRepeatNumber(vector<int>& a) {
        int l = a.size();
        set <int> s;
        for (int i = 0; i < l; i++) {
            if (s.count(a[i])) return a[i];
            s.insert(a[i]);
        }
        return 0;
    }
};

优化：

题目有个限定，即值域与定义域均为 n，当且仅当没有重复数字时，元素与其索引编号为一一对应的，均为 0 ~ n - 1；

于是可以把读入的元素 i 放入大小为 n 的另一个数组 b 的第 i 个位置，如果有两个元素需要放到同一个位置，则说明为重复元素。

class Solution {
public:
    int findRepeatNumber(vector<int>& a) {
        map <int, bool> mp;
        for (int i : a) {
            if (mp[i]) return i;
            mp[i] = 1;
        }
        return 0;
    }
};

方法三：原地哈希

在上述优化的基础上，我们发现多开一个数组其实是赘余的：我们可以把上述过程理解成，将打乱的全排列重新排序，通过不停交换元素位置来实现，而唯一不同的是它实际上并非全排列，当且仅当交换过程中出现冲突，即找到了重复元素。

以样例为例，[2, 3, 1, 0, 2, 5, 3]，第一个元素 2 理应放在第 2 个位置，于是将其与第 2 个位置的元素交换，得 [1, 3, 2, 0, 2, 5, 3]，同理再将 1 与第 1 个位置元素交换，得 [3, 1, 2, 0, 2, 5, 3]，再得 [0, 1, 2, 3, 2, 5, 3]，第 0 个位置满足条件；

依次往后遍历，0, 1, 2, 3 均已就位，第 4 个位置为 2，其理应放在第 2 个位置，但是我们发现第 2 个位置已经有 2 了，说明数组里有多个 2，输出 2 即可。

class Solution {
public:
    int findRepeatNumber(vector<int>& a) {
        int l = a.size();
        for (int i = 0; i < l; i++)
            while (i != a[i]) {
                if (a[a[i]] == a[i]) return a[i];
                swap(a[i], a[a[i]]);
            } 
        return 0;
    } 
};

 

剑指 Offer 4. 二维数组中的查找

方法一：DFS + 简单优化

剪枝剪掉了反向查找，但最坏复杂度依旧是 O(nm)

class Solution {
public:
    bool dfs(int x, int y, vector<vector<int>>& a, int target) {
        if (x >= a.size() || y >= a[0].size() || x < 0 || y < 0 || f[x][y]) return 0;
        f[x][y] = 1;
        if (a[x][y] == target) return 1;
        if (a[x][y] < target)
            return dfs(x + 1, y, a, target) || dfs(x, y + 1, a, target);
        else
            return dfs(x - 1, y, a, target) || dfs(x, y - 1, a, target);
    }
    bool findNumberIn2DArray(vector<vector<int>>& a, int target) {
        return dfs(0, 0, a, target);
    }
};

方法二：线性查找

看了题解之后明白了，从左上角出发真是个新奇的思路，大了往左走，小了往下走，必然会找到答案，这样就降到了 O(n + m)。

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& a, int target) {
        if (!a.size() || !a[0].size()) return 0;
        int x = 0, y = a[0].size() - 1;
        while (x < a.size() && y >= 0) {
            if (a[x][y] == target) return 1;
            if (a[x][y] < target) x++;
            else y--;
        }
        return 0;
    }
};

注意边界条件。

其他：直接暴力找

 

20220303

剑指 Offer 5. 替换空格

class Solution {
public:
    string replaceSpace(string s) {
        int l = s.length();
        string ans;
        for (auto& c : s)
            if (s == ' ') ans += "%20";
            else ans += s;
        return ans;
    }
};

 

剑指 Offer 6. 从尾到头打印链表

方法：栈

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        stack<int> s;
        vector<int> a;
        ListNode* p = head;
        while (p)
            s.push(p->val), p = p->next;
        while (!s.empty())
            a.push_back(s.top()), s.pop();
        return a;
    }
};

 

剑指 Offer 7. 重建二叉树

方法：递归

利用前序遍历与中序遍历之间的关系：每从前序遍历中读到一个结点，便在中序遍历中找到该结点（用 map 预处理索引），该结点在中序遍历位置的左侧为以该结点为根的子树的左子树，右侧为右子树，依次构造即可。

class Solution {
private:
    map<int, int> ind;
public:
    TreeNode* build(vector<int>& p, vector<int>& i, int pl, int pr, int il, int ir) {
        if (pl > pr) return nullptr;
        int root_p = pl, root_i = ind[p[pl]];
        TreeNode* root = new TreeNode(p[pl]);
        int size = root_i - il;
        root->left = build(p, i, pl + 1, pl + size, il, root_i - 1);
        root->right = build(p, i, pl + size + 1, pr, root_i + 1, ir);
        return root;
    }
    
    TreeNode* buildTree(vector<int>& p, vector<int>& i) {
        int n = p.size();
        for (int o = 0; o < n; o++)
            ind[i[o]] = o; 
        return build(p, i, 0, n - 1, 0, n - 1);
    }
};

 

20220304

剑指 Offer 9. 用两个栈实现队列

考研的时候看到过这道题。栈 A 用来入队；出队时，将栈 A 的元素倒入栈 B，再出栈（出队）。

class CQueue {
    stack<int> s1, s2;
public:
    CQueue() {
        while (!s1.empty())
            s1.pop();
        while (!s2.empty())
            s2.pop();    
    }
    
    void appendTail(int value) {
        s1.push(value);
    }
    
    int deleteHead() {
        if (s2.empty())
            while (!s1.empty())
                s2.push(s1.top()), s1.pop();
        if (s2.empty())
            return -1;
        int res = s2.top();
        s.pop();
        return res;        
    }
};

 

剑指 Offer 10. 斐波那契数列 + 青蛙跳台阶问题

const int MOD = 1e9 + 7;

class Solution {
public:
    int fib(int n) {
        int a = 0, b = 1;
        for (int i = 1; i <= n; i++)
            ((i & 1) ? a : b) = (a + b) % MOD;
        return n & 1 ? b : a;
    }
};

 

20220305

剑指 Offer 11. 旋转数组的最小数字

方法一：暴力

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int mi = INT_MAX;
        for (int i : numbers)
            mi = min(mi, i);
        return mi;
    }
};

方法二：二分查找

根据题意，序列基本是升序的，只有最小值出现的一个位置是降序的，而我们需要找的就是这个位置，不难想到用二分来做。

class Solution {
public:
    int minArray(vector<int>& a) {
        int n = a.size();
        int l = 0, r = n - 1;
        while (l < r) {
            int m = (l + r) >> 1;
            if (a[m] < a[r]) r = m;
            else if (a[m] > a[r]) l = m + 1;
            else r--;
        }
        return a[l];
    }
};

 

剑指 Offer 12. 矩阵中的路径

方法：DFS + 剪枝

const int vx[4] = {0, 0, 1, -1}, vy[4] = {1, -1, 0, 0};

class Solution {
public:
    bool dfs(vector<vector<char>>& b, vector<vector<char>>& f, int n, int m, string word, int l, int x, int y, int d) {
        f[x][y] = 1;
        if (d == l - 1)
            return 1;
        bool res = 0;
        for (int i = 0; i < 4; i++) {
            int tx = x + vx[i], ty = y + vy[i];
            if (tx >= 0 && tx < n && ty >= 0 && ty < m && !f[tx][ty] && b[tx][ty] == word[d + 1])
                res = dfs(b, f, n, m, word, l, tx, ty, d + 1);
            if (res) return 1;
        }
        f[x][y] = 0;
        return 0;
    }
    bool exist(vector<vector<char>>& b, string word) {
        int n = b.size(), m = b[0].size(), l = word.length();
        vector<vector<char>> f(n, vector<char>(m));
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (b[i][j] == word[0]) {
                    for (int k = 0; k < n; k++)
                        f[k].assign(m, 0);
                    if (dfs(b, f, n, m, word, l, i, j, 0)) return 1;
                }
        return 0;
    }
};

 

20220307 剑指 Offer 13. 机器人的运动范围

方法：DFS + 剪枝

const int vx[4] = {0, 0, 1, -1}, vy[4] = {1, -1, 0, 0};
const int N = 1e2 + 5;

class Solution {
    int ans = 0, f[N][N];
public:
    int calc(int o) {
        return o < 10 ? o : o == 100 ? 1 : o % 10 + o / 10;
    }
    void dfs(int x, int y, int m, int n, int k) {
        f[x][y] = 1, ans++;
        for (int i = 0; i < 4; i++) {
            int tx = x + vx[i], ty = y + vy[i];
            if (tx >= 0 && ty >= 0 && tx < m && ty < n && !f[tx][ty] && calc(tx) + calc(ty) <= k)
                dfs(tx, ty, m, n, k);
        }
    }
    int movingCount(int m, int n, int k) {
        dfs(0, 0, m, n, k);
        return ans;
    }
};

其实还可以剪，对于 > k 的情况在 f 数组中标记个 -1，后面也无需再次判断，不过数据范围太小，影响较小。

 

20220310 剑指 Offer 14. 剪绳子

方法：数学推导

有意思的数学推导，简而言之就是：求 a = (n / m) ^ m 的最大值，可证明 m = n / e 时有最大值，即长度为 n / m = n / (n / e) = e。又 2 < e < 3，而 2 ^ (1/2) < 3 ^ (1/3)，则切分长度为 3 时最优，其次为 2。

class Solution {
public:
    int cuttingRope(int n) {
        if (n <= 3) return n - 1;
        int a = n / 3, b = n % 3;
        return !b ? pow(3, a) : b == 1 ? pow(3, a - 1) * 4 : pow(3, a) * 2;
    }
};

进阶：数据扩大到 n <= 1000，且对答案取余。需要用到大数取余。

方法一：暴力

已知 xy % p = (x % p) * (y % p) % p，故可以直接循环取余。

方法二：快速幂

const int MOD = 1e9 + 7;

class Solution {
public:
    long long mypow(int a, int b) {
        long long o = a, res = 1;
        while (b) {
            if (b & 1) (res *= o) %= MOD;
            (o *= o) %= MOD;
            b >>= 1;
        }
        return res;
    }
    int cuttingRope(int n) {
        if (n <= 3) return n - 1;
        int a = n / 3, b = n % 3;
        return !b ? mypow(3, a) : b == 1 ? (mypow(3, a - 1) * 4) % MOD: (mypow(3, a) * 2) % MOD;
    }
};

 

20220329 剑指 Offer 63. 股票的最大利润

class Solution {
public:
    int maxProfit(vector<int>& a) {
        int n = a.size();
        if (!n) return 0;
        int mi = a[0], ans = 0;
        for (int i = 1; i < n; i++)
            if (a[i] < mi) mi = a[i];
            else ans = max(ans, a[i] - mi);
        return ans;
    }
};

 

122. 买卖股票的最佳时机 II

class Solution {
public:
    int maxProfit(vector<int>& a) {
        int n = a.size(), ans= 0;
        for (int i = 1; i < n; i++)
            ans += a[i] > a[i - 1] ? a[i] - a[i - 1];
        return ans;
    }
};

 

123. 买卖股票的最佳时机 III

方法：动态规划

由于需要买卖两次，直接贪心找最优解不可取，这时候往往是考虑动态规划：

每天的可选状态很直白：没买；买了 1 次；买了 1 次又卖了；卖了 1 次后又买了第 2 次；买了第 2 次又卖了；

设 f[i][j] 为前 i 天可能获得的最大利润，状态的转移很直白：买第 i 天的股票即是在原基础上减去 price[i]，卖则是加上；

而由于可以买多次，还需要加上表示已经买了 j 次的一维，那么就是设 f[i][j] 为前 i 天买了 j 次可能获得的最大利润；

当然这道题限定了 2 次，那么可以简单地设计成多个变量而无需加上一维。

class Solution {
public:
    int maxProfit(vector<int>& a) {
        int n = a.size();
        int b1 = -a[0], s1 = 0, b2 = -a[0], s2 = 0;
        for (int i = 1; i < n; i++) {
            b1 = max(b1, -a[i]), s1 = max(s1, b1 + a[i]);
            b2 = max(b2, s1 - a[i]), s2 = max(s2, b2 + a[i]);
        }
        return s2;
    }
};

 

124. 买卖股票的最佳时机 III

方法：动态规划

在第 123 题的基础上扩展为二维动态规划数组，用 b[i][j] 和 s[i][j] 分别表示第 i 天买/卖了第 j 次时获得的最大利润，思路同理。

typedef vector<int> arr;
typedef vector<arr> arr2;

class Solution {
public:
    int maxProfit(int k, arr& a) {
        if (a.empty()) return 0;
        int n = a.size();
        k = min(k, n / 2);
        arr2 b(n, arr(k + 1));
        arr2 s(n, arr(k + 1));
        b[0][0] = -a[0], s[0][0] = 0;
        for (int i = 1; i <= k; ++i)
            b[0][i] = s[0][i] = INT_MIN / 2;
        for (int i = 1; i < n; ++i) {
            b[i][0] = max(b[i - 1][0], s[i - 1][0] - a[i]);
            for (int j = 1; j <= k; ++j) {
                b[i][j] = max(b[i - 1][j], s[i - 1][j] - a[i]);
                s[i][j] = max(s[i - 1][j], b[i - 1][j - 1] + a[i]);   
            }
        }
        return *max_element(s[n - 1].begin(), s[n - 1].end());
    }
};

 

20220409

144. 二叉树的前序遍历

方法一：递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> res;
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == nullptr)
            return res;
        res.emplace_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        return res;
    }
};

方法二：迭代法

class Solution {
public:
    vector<int> res;
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* node = root;
        while (!st.empty() || node) {
            while (node) {
                st.push(node);
                res.emplace_back(node->val);
                node = node->left;
            }
            node = st.top();
            st.pop();
            node = node->right;
        }
        return res;
    }
};

 

94. 二叉树的中序遍历

和前序遍历大同小异。

方法一：递归法

class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        if (root == nullptr)
            return res;
        inorderTraversal(root->left);
        res.emplace_back(root->val);
        inorderTraversal(root->right);
        return res;
    }
};

方法二：迭代法

class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* node = root;
        while (!st.empty() || node) {
            while (node) {
                st.push(node);
                node = node->left;
            }
            node = st.top();
            res.emplace_back(node->val);
            st.pop();
            node = node->right;
        }
        return res;
    }
};

 

145. 二叉树的后序遍历

方法一：递归法

class Solution {
public:
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
        if (root == nullptr)
            return res;
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        res.emplace_back(root->val);
        return res;
    }
};

方法二：迭代法

和前序、中序有不同，因为遍历只能自上而下遍历，但输出又需要自下而上输出，所以需要两个栈，分别用来遍历和输出。

class Solution {
public:
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st1, st2;
        if (!root) return res;
        TreeNode* node = root;
        st1.push(root);
        while (!st1.empty()){
            TreeNode* node = st1.top();
            st1.pop();
            st2.push(node);
            if (node->left) st1.push(node->left);
            if (node->right) st1.push(node->right);
        }
        while (!st2.empty()) {
            res.push_back(st2.top()->val);
            st2.pop();
        }
        return res;
    }
};

 

20220412

剑指 Offer 26. 树的子结构

class Solution {
public:
    bool cmp(TreeNode* A, TreeNode* B) {
        if (B == nullptr) return true;
        if (A == nullptr || A->val != B->val) return false;
        return cmp(A->left, B->left) && cmp(A->right, B->right);
    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if (A == nullptr || B == nullptr) return false;
        if (A->val == B->val && cmp(A, B))
            return true;
        return isSubStructure(A->left, B) || isSubStructure(A->right, B);
    }
};

 

20220416

剑指 Offer 17. 打印从1到最大的n位数

class Solution {
    vector<int> ans;
public:
    void add(string &s) {
        int l = s.length() - 1;
        s[l]++;
        while (l) {
            if (s[l] > '9')
                s[l] = '0', s[l - 1]++;
            l--;
        }
    }
    void work(int o) {
        string s = "1";
        for (int i = 1; i < o; i++)
            s += '0';
        ans.push_back(stoi(s));
        int x = 9 * (int)pow(10, o - 1);
        for (int i = 1; i < x; i++)
            add(s), ans.push_back(stoi(s));
    }
    vector<int> printNumbers(int n) {
        for (int i = 1; i <= n; i++)
            work(i);
        return ans;
    }
};

在 Dev-c++ 中编译选项加上了-std=c++11，但依旧不识别 stol 函数，不知道为什么。

 

1944. 队列中可以看到的人

方法：单调栈

class Solution {
public:
    vector<int>canSeePersonsCount(vector<int>& a) {
        int n = a.size();
        vector<int> ans(n);
        stack<int> s;
        for (int i = n - 1; i >= 0; --i) {
            while (!s.empty()) {
                ans[i]++;
                if (a[i] > a[s.top()]) s.pop();
                else break;
            }
            s.push(i);
        }
        return ans;
    }
};