LeetCode on Lishengxie

LeetCode刷题 - KMP算法

Sun, 04 Feb 2024 18:48:10 +0800

KMP算法是一种高效的字符串匹配算法，但是之前每次学过之后都会忘记，这次做一下总结加深印象，主要参考了以下链接。

https://programmercarl.com/0028.%E5%AE%9E%E7%8E%B0strStr.html

问题

给定一个字符串 $s$ (长度为N)和一个模式串 $t$ (长度为M)，如果 $s$ 中存在 $t$ ，那么返回模式串第一次出现的起始索引；如果不存在返回-1。对应Leetcode 28. 找出字符串中第一个匹配项的下标

KMP算法

KMP算法是由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现的一种快速的字符串匹配算法，时间复杂度为 $O(M+N)$ 。KMP算法的核心思想是在字符串匹配失败时利用之前已经匹配的信息来做快速回退，避免从头再做匹配。KMP算法的核心函数是一个用于求解next数组的函数，next数组包含了模式串局部匹配的信息。

这里代码随想录中给出了关于next数组的详细解释。next数组对应自定义的前缀表，其中前缀表是一个和模式串长度相同的数组，前缀表第i个位置的值为[0,i]子字符串的最长相同前后缀的长度；

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串；
举例来说，“aab”的前缀有“a”和“aa”、后缀有“b”和“ab”，“aabaa”的最长相同前后缀长度为2，“aa”的最长相同前后缀长度为1。

以下图为例，假设文本串和模式串分别为aabaabaafa和aabaaf，前缀表如图中所示。那么在b和f不匹配时，此时寻找前缀表中前一位存储的值，查找得到值为2，该值的含义是“aabaa”的最长相同前后缀长度为2，即“aa”。此时我们可以不用从头开始重新匹配，文本串中的匹配指针可以不移动，将模式串中的匹配指针回退到索引2处重新开始匹配即可。

这里为什么可以不回退文本串的匹配指针？

因为这里通过回退j指针，找到了从文本串中该位置向前的最长相同前后缀，获得了类似下图的效果。

实际使用中常通过将前缀表统一减1得到next数组，那么如何计算next数组？

next数组的计算类似于移动模式串，在模式串和模式串之间做匹配，在移动的过程中计算next数组的值，next数组的计算代码如下所示：

void getNext(int* next, const string& s){
 int j = -1;
 next[0] = j;
 for(int i = 1; i < s.size(); i++) { // 注意i从1开始
 while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
 j = next[j]; // 向前回退
 }
 if (s[i] == s[j + 1]) { // 找到相同的前后缀
 j++;
 }
 next[i] = j; // 将j（前缀的长度）赋给next[i]
 }
}

基于next数组进行文本串和模式串的匹配代码如下：

void match(string s, string t) {
 int j = -1;
 int next[t.size()];
 getNext(next, t);

 for (int i = 0; i < s.size(); i++) {
 while (j >= 0 && s[i] != t[j+1]) {
 j = next[j];
 }
 if (s[i] == s[j+1]) {
 j++;
 }
 if (j == (t.size() - 1)) {
 return i - t.size() + 1;
 }
 }
 return -1;
}

算法学习-差分数组

Sat, 23 Dec 2023 23:05:16 +0800

差分数组

参考教程：https://wansuanfa.com/index.php/589
leetcode题目：1109. 航班预订统计

问题描述

给定一个数组，需要频繁地对某个区间内的元素做加减操作，并获取最后的操作结果。常规做法是每次都遍历整个区间然后修改区间内的元素，但是元素的访问需要时间、频繁访问元素会减慢程序的运行时间。因此，可以使用差分数组来进行优化。

一维差分数组定义

一维差分数组 $d[n]$ 定义为原始数组 $nums$ 相邻元素之间的差，即 $d[i]=nums[i]-nums[i-1]$ ，其中 $d[0]=nums[0]$ 。这样原数组就是差分数组的前缀和

nums[i] = \sum_{k=0}^i d[k].

由此，我们可以改进原来的区间操作，如对区间 $[a,b]$ 内每个元素加3，那么只需要在区间的两端进行操作即可，即

d[a] += 3, d[b+1] -= 3

证明

假设 $nums1$ 是修改后的数组， $d1$ 是修改后的差分数组，其中 $d1[a]=d[a]+3, d1[b+1]=d[b+1]-3$ .

hugo里面换行公式需要\\\\四个反斜杠

对于 $0\leq i \lt a$ , $nums1[i] = \sum_{k=0}^i d1[k] = \sum_{k=0}^i d[k] = nums[i]$ .
对于 $a\leq i \leq b$ , $\begin{aligned} nums1[i] & = \sum_{k=0}^i d1[k] \\\\ & = \sum_{k=0}^{a-1}d[k] + \sum_{k=a+1}^{b}d[k] + d[a] + 3 \\\\ & = \sum_{k=0}^i d[k] + 3 \\\\ & = nums[i]+3 \end{aligned}$
对于 $i \gt b$ , $\begin{align} nums1[i] &= \sum_{k=0}^i d1[k]\\\\ &= \sum_{k=0}^{a-1}d[k] + \sum_{k=a+1}^{b}d[k] + \sum_{k=b+1}^{i}d[k] + d[a] + 3 + d[b] - 3\\\\ &= \sum_{k=0}^i d[k] + 3 - 3\\\\ &= nums[i]. \end{align}$ 由此，可以证明只修改差分数组的两端即可以修改原数组的整个区间。

代码

class Solution {
public:
 vector<int> diff;
 vector<int> nums;

 void diffNums() {
 diff[0] = nums[0];
 for(int i = 1; i < nums.size(); ++i) {
 diff[i] = nums[i] - nums[i-1];
 }
 }

 void increment(int a, int b, int val) {
 diff[a] += val;
 if (b + 1 < diff.size())
 diff[b + 1] -= val;
 }

 void result() {
 nums[0] = diff[0];
 for (int i = 1; i < diff.size(); i++)
 nums[i] = diff[i] + nums[i - 1];
 }

 vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
 nums.resize(n, 0);
 diff.resize(n, 0);
 diffNums();
 for (int i = 0; i < bookings.size(); ++i) {
 increment(bookings[i][0]-1, bookings[i][1]-1, bookings[i][2]);
 }
 result();
 return nums;
 }
};

拓展 - 二维差分数组

二维差分数组可以在一维差分数组的基础上进行拓展，视为一个平面，定义如下

LeetCode刷题-二叉树遍历迭代法

Tue, 17 Oct 2023 20:15:23 +0800

LeetCode题目链接

二叉树的前序遍历：https://leetcode.cn/problems/binary-tree-preorder-traversal/ 二叉树的中序遍历：https://leetcode.cn/problems/binary-tree-inorder-traversal/ 二叉树的后序遍历：https://leetcode.cn/problems/binary-tree-postorder-traversal/

二叉树的遍历方法有两种，分别是递归法和迭代法；实际使用中由于系统调用栈有限制，使用递归法可能会导致栈溢出，这里记录三种遍历的迭代做法。最后，介绍二叉树层序遍历的两种方法。

迭代遍历法借助辅助栈实现，下面是二叉树节点的定义，使用链表实现。

 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> preorderTraversal(TreeNode* root) {
 vector<int> res;
 stack<TreeNode*> st;
 if (root == NULL) {
 return res;
 }

 st.push(root);
 while (!st.empty()) {
 TreeNode *cur = st.top();
 st.pop();
 res.push_back(cur->val);
 if (cur->right) st.push(cur->right);
 if (cur->left) st.push(cur->left);
 }

 return res;
 }
};

中序遍历

中序遍历处理顺序为左中右，先访问二叉树顶部的节点，随后逐层向下访问直到树最左侧的节点，再开始处理节点，这导致处理节点的顺序和访问节点的顺序不一致。中序遍历的迭代法如下所示：

LeetCode刷题 - 滑动窗口最大值

Tue, 17 Oct 2023 20:11:52 +0800

LeetCode刷题 - 滑动窗口最大值

参考链接:https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html

leetcode题目链接：https://leetcode.cn/problems/sliding-window-maximum/

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3 输出：[3,3,5,5,6,7] 解释：滑动窗口的位置最大值

[1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7