file_path
stringlengths 27
66
| url_title
stringlengths 6
38
| url
stringlengths 60
237
⌀ | difficulty
stringclasses 3
values | tags
sequencelengths 1
8
| question
stringlengths 107
2.73k
| solution
stringlengths 163
28.6k
| final
stringlengths 308
330
|
|---|---|---|---|---|---|---|---|
LeetCode/1-10/1. 两数之和（简单）.md | 1. 两数之和 | https://leetcode-cn.com/problems/two-sum/solution/po-su-jie-fa-ha-xi-biao-jie-fa-by-ac_oie-yf7o/ | 简单 | [
"哈希表",
"模拟"
] | 给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出「和为目标值」的那「两个」整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
```
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
```
示例 2:
```
输入:nums = [3,2,4], target = 6
输出:[1,2]
```
示例 3:
```
输入:nums = [3,3], target = 6
输出:[0,1]
```
提示:
* $2 <= nums.length <= 10^3$
* -$10^9 <= nums[i] <= 10^9$
* -$10^9 <= target <= 10^9$
* 只会存在一个有效答案 | ### 朴素解法
由于我们每次要从数组中找两个数。
因此一个很简单的思路是:使用两重循环枚举下标 $i$ 和 $j$ ,分别代表要找的两个数。
然后判断 $nums[i] + nums[j] = target$ 是否成立。
另外为了防止得到重复的解,我们需要在第一层循环中让 $i$ 从 $0$ 开始,到 $n - 2$ 结束(确保能取到下一位数作为 j );在第二层循环中让 $j$ 从 $i + 1$ 开始,到 $n - 1$ 结束。
代码:
```Java
class Solution {
public int[] twoSum(int[] nums, int t) {
int n = nums.length;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (t == nums[i] + nums[j]) return new int[]{i,j};
}
}
return new int[]{};
}
}
```
* 时间复杂度:两重循环,以复杂度是 $O(n^2)$
* 空间复杂度:$O(1)$
---
### 哈希表
首先,任何优化的思路都不外乎「减少重复」。
从朴素解法中可以知道,逻辑上我们是先定下来一个数,然后从数组中往后找另外一个值是否存在。但其实我们在找第二个数的过程中是重复扫描了数组多次。
举个例子,对于 `nums = [2,3,8,4], target = 9` 的样例,我们先确定下来第一个数是 `2`,然后从后扫描到最后一个数,检查是否有 `7`。发现没有,再决策第一个数为 `3` 的情况,这时候我们应该利用前一次扫描的结果来帮助我们快速判断是否存在 `6`,而不是再重新进行一次扫描。
这是直观的优化思路,不难想到可以使用哈希表进行存储。以数值为 `key`,数值的下标为 `value`。
当动手将想法转化为代码时,会发现如果先敲定第一个数,将后面的数加入哈希表,再进行下一位的遍历的时候,还需要将该数值从哈希表中进行删除。
代码:
```Java
class Solution {
public int[] twoSum(int[] nums, int t) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) map.put(nums[i], i);
for (int i = 0; i < nums.length; i++) {
int a = nums[i], b = t - a;
if (map.get(a) == i) map.remove(a);
if (map.containsKey(b)) return new int[]{i, map.get(b)};
}
return new int[]{};
}
}
```
最坏情况下,每个数会对应一次哈希表的插入和删除。该解法本质是在循环过程中敲定第一个数,在哈希表中找该数后面是否存在第二个数。
这时候不妨将思路转换过来,遍历过程中敲定第二个数,使用哈希表在第二个数的前面去找第一个数。
具体的做法是,边遍历边存入哈希表,遍历过程中使用的下标 i 用作敲定第二个数,再从现有的哈希表中去找另外一个目标数(由于下标 $i$ 前面的数都被加入哈希表了,即在下标 $i$ 前面去找第一个数)。
```Java
class Solution {
public int[] twoSum(int[] nums, int t) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int a = nums[i], b = t - a;
if (map.containsKey(b)) return new int[]{map.get(b), i};
map.put(a, i);
}
return new int[]{};
}
}
```
从 LeetCode 上的执行时间来看,第一种哈希表做法是 4ms,而第二种哈希表的做法是 0ms(不足 1ms 的意思),快在了我们减少了哈希表的插入和删除操作。
但这只是常数级别上的优化,LeetCode 上的执行时间建议只作普通参考,还是要从算法的时空复杂度来分析快慢。
* 时间复杂度:第一种哈希表的做法会扫描数组两次,复杂度是 $O(n)$(忽略常数);第二种做法只会对数组进行一遍扫描,复杂度是 $O(n)$
* 空间复杂度:两种做法都使用了哈希表进行记录,复杂度是 $O(n)$
---
### 其他
可以看到,我将原题目的入参 `target` 替换成了 `t`,但并不影响正确性,目的是为了提高编码速度。如果你也经常参与 LeetCode 周赛,就会发现这是一个常用的小技巧。
这个技巧,我希望你在第一题就掌握。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/10. 正则表达式匹配（困难）.md | 10. 正则表达式匹配 | https://leetcode-cn.com/problems/regular-expression-matching/solution/shua-chuan-lc-dong-tai-gui-hua-jie-fa-by-zn9w/ | 困难 | [
"动态规划",
"序列 DP"
] | 给你一个字符串 `s` 和一个字符规律 `p`,请你来实现一个支持 `'.'` 和 `'*'` 的正则表达式匹配。
* `'.'` 匹配任意单个字符
* `'*'` 匹配零个或多个前面的那一个元素
所谓匹配,是要涵盖整个字符串 `s` 的,而不是部分字符串。
示例 1:
```
输入:s = "aa" p = "a"
输出:false
解释:"a" 无法匹配 "aa" 整个字符串。
```
示例 2:
```
输入:s = "aa" p = "a*"
输出:true
解释:因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
```
示例 3:
```
输入:s = "ab" p = ".*"
输出:true
解释:".*" 表示可匹配零个或多个('*')任意字符('.')。
```
示例 4:
```
输入:s = "aab" p = "c*a*b"
输出:true
解释:因为 '*' 表示零个或多个,这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
```
示例 5:
```
输入:s = "mississippi" p = "mis*is*p*."
输出:false
```
提示:
* $0 <= s.length <= 20$
* $0 <= p.length <= 30$
* `s` 可能为空,且只包含从 `a-z` 的小写字母。
* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `.` 和 `*`。
* 保证每次出现字符 `*` 时,前面都匹配到有效的字符 | ### 动态规划
整理一下题意,对于字符串 `p` 而言,有三种字符:
* 普通字符:需要和 `s` 中同一位置的字符完全匹配
* `'.'`:能够匹配 `s` 中同一位置的任意字符
* `'*'`:不能够单独使用 `'*'`,必须和前一个字符同时搭配使用,数据保证了 `'*'` 能够找到前面一个字符。能够匹配 `s` 中同一位置字符任意次。
所以本题关键是分析当出现 `a*` 这种字符时,是匹配 $0$ 个 `a`、还是 $1$ 个 `a`、还是 $2$ 个 `a` ...
本题可以使用动态规划进行求解:
* 状态定义:`f(i,j)` 代表考虑 `s` 中以 `i` 为结尾的子串和 `p` 中的 `j` 为结尾的子串是否匹配。最终我们要求的结果为 `f[n][m]` 。
* 状态转移:也就是我们要考虑 `f(i,j)` 如何求得,前面说到了 `p` 有三种字符,所以这里的状态转移也要分三种情况讨论:
1. `p[j]` 为普通字符:匹配的条件是前面的字符匹配,同时 `s` 中的第 `i` 个字符和 `p` 中的第 `j` 位相同。
`f(i,j) = f(i - 1, j - 1) && s[i] == p[j]` 。
2. `p[j]` 为 `'.'`:匹配的条件是前面的字符匹配, `s` 中的第 `i` 个字符可以是任意字符。
`f(i,j) = f(i - 1, j - 1) && p[j] == '.'`。
3. `p[j]` 为 `'*'`:读得 `p[j - 1]` 的字符,例如为字符 `a`。 然后根据 `a*` 实际匹配 `s` 中 `a` 的个数是 $0$ 个、$1$ 个、$2$ 个 ...
3.1. 当匹配为 $0$ 个:`f(i,j) = f(i, j - 2)`
3.2. 当匹配为 $1$ 个:`f(i,j) = f(i - 1, j - 2) && (s[i] == p[j - 1] || p[j - 1] == '.')`
3.3. 当匹配为 $2$ 个:`f(i,j) = f(i - 2, j - 2) && ((s[i] == p[j - 1] && s[i - 1] == p[j - 1]) || p[j] == '.')`
**我们知道,通过「枚举」来确定 `*` 到底匹配多少个 `a` 这样的做法,算法复杂度是很高的。**
**我们需要挖掘一些「性质」来简化这个过程。**
代码:
```Java
class Solution {
public boolean isMatch(String ss, String pp) {
// 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始,而且可以使得 f[0][0] = true,可以将 true 这个结果滚动下去
int n = ss.length(), m = pp.length();
ss = " " + ss;
pp = " " + pp;
char[] s = ss.toCharArray();
char[] p = pp.toCharArray();
// f(i,j) 代表考虑 s 中的 1~i 字符和 p 中的 1~j 字符 是否匹配
boolean[][] f = new boolean[n + 1][m + 1];
f[0][0] = true;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= m; j++) {
// 如果下一个字符是 '*',则代表当前字符不能被单独使用,跳过
if (j + 1 <= m && p[j + 1] == '*' && p[j] != '*') continue;
// 对应了 p[j] 为普通字符和 '.' 的两种情况
if (i - 1 >= 0 && p[j] != '*') {
f[i][j] = f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.');
}
// 对应了 p[j] 为 '*' 的情况
else if (p[j] == '*') {
f[i][j] = (j - 2 >= 0 && f[i][j - 2]) || (i - 1 >= 0 && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));
}
}
}
return f[n][m];
}
}
```
* 时间复杂度:$n$ 表示 `s` 的长度,$m$ 表示 `p` 的长度,总共 $n \times m$ 个状态。复杂度为 $O(n \times m)$
* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n \times m)$
**动态规划本质上是枚举(不重复的暴力枚举),因此其复杂度很好分析,有多少个状态就要被计算多少次,复杂度就为多少。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/2. 两数相加（中等）.md | 2. 两数相加 | https://leetcode-cn.com/problems/add-two-numbers/solution/po-su-jie-fa-shao-bing-ji-qiao-by-ac_oie-etln/ | 中等 | [
"递归",
"链表",
"数学",
"模拟"
] | 给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 $0$ 之外,这两个数都不会以 $0$ 开头。
示例 1:
```
输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.
```
示例 2:
```
输入:l1 = [0], l2 = [0]
输出:[0]
```
示例 3:
```
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]
```
提示:
* 每个链表中的节点数在范围 $[1, 100]$ 内
* $0 <= Node.val <= 9$
* 题目数据保证列表表示的数字不含前导零 | ### 朴素解法(哨兵技巧)
这是道模拟题,模拟人工竖式做加法的过程:
从最低位至最高位,逐位相加,如果和大于等于 $10$,则保留个位数字,同时向前一位进 1 如果最高位有进位,则需在最前面补 $1$。
做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。
代码:
```Java
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(0);
ListNode tmp = dummy;
int t = 0;
while (l1 != null || l2 != null) {
int a = l1 != null ? l1.val : 0;
int b = l2 != null ? l2.val : 0;
t = a + b + t;
tmp.next = new ListNode(t % 10);
t /= 10;
tmp = tmp.next;
if (l1 != null) l1 = l1.next;
if (l2 != null) l2 = l2.next;
}
if (t > 0) tmp.next = new ListNode(t);
return dummy.next;
}
}
```
* 时间复杂度:$m$ 和 $n$ 分别代表两条链表的长度,则遍历到的最远位置为 $max(m,n)$,复杂度为 $O(max(m,n))$
* 空间复杂度:创建了 $max(m,n) + 1$ 个节点(含哨兵),复杂度为 $O(max(m,n))$(忽略常数)
**注意:事实上还有可能创建 $max(m + n) + 2$ 个节点,包含哨兵和最后一位的进位。但复杂度仍为 $O(max(m,n))$。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/3. 无重复字符的最长子串（中等）.md | 3. 无重复字符的最长子串 | https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/shua-chuan-lc-shuang-zhi-zhen-ha-xi-biao-q08m/ | 中等 | [
"哈希表",
"双指针",
"滑动窗口"
] | 给定一个字符串,请你找出其中不含有重复字符的「最长子串」的长度。
示例 1:
```
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
```
示例 2:
```
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
```
示例 3:
```
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
```
示例 4:
```
输入: s = ""
输出: 0
```
提示:
* $0 <= s.length <= 5 \times 10^4$
* `s` 由英文字母、数字、符号和空格组成 | ### 滑动窗口
定义两个指针 `start` 和 `end`, `[start:end]` 表示当前处理到的子串。
子串 `[start:end]` 始终满足要求:无重复字符。
从前往后进行扫描 `s`,用哈希表记录 `[start:end]` 中每字符的出现次数。
遍历过程中,`end` 不断自增,将第 `end` 个字符在哈希表中出现的次数加一。
令 `right` 为下标 `end` 对应的字符,当满足 `map.get(right) > 1` 时,代表此前出现过第 `end` 位对应的字符。
此时更新 `start` 的位置(使其右移),直到不满足 `map.get(right) > 1` (代表 `[start:end]` 恢复满足无重复字符的条件),再用 `[start:end]` 长度更新答案。
Java 代码:
```Java
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character, Integer> map = new HashMap<>();
int ans = 0;
for (int start = 0, end = 0; end < s.length(); end++) {
char right = s.charAt(end);
map.put(right, map.getOrDefault(right, 0) + 1);
while (map.get(right) > 1) {
char left = s.charAt(start);
map.put(left, map.get(left) - 1);
start++;
}
ans = Math.max(ans, end - start + 1);
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
map = {}
ans = 0
start = 0
for end in range(len(s)):
right = s[end]
map[right] = map.get(right, 0) + 1
while map[right] > 1:
left = s[start]
map[left] = map[left] - 1
start += 1
ans = max(ans, end - start + 1)
return ans
```
C++ 代码:
```C++
class Solution {
public:
int lengthOfLongestSubstring(string s) {
unordered_map<char, int> map;
int ans = 0;
for (int start = 0, end = 0; end < s.length(); end++) {
char right = s[end];
map[right] = map[right] + 1;
while (map[right] > 1) {
char left = s[start];
map[left] = map[left] - 1;
start++;
}
ans = max(ans, end - start + 1);
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function lengthOfLongestSubstring(s: string): number {
const map: { [key: string]: number } = {};
let ans = 0;
let start = 0;
for (let end = 0; end < s.length; end++) {
const right = s.charAt(end);
map[right] = (map[right] || 0) + 1;
while (map[right] > 1) {
const left = s.charAt(start);
map[left] = (map[left] || 0) - 1;
start++;
}
ans = Math.max(ans, end - start + 1);
}
return ans;
};
```
* 时间复杂度:虽然有两层循环,但每个字符在哈希表中最多只会被插入和删除一次,复杂度为 $O(n)$
* 空间复杂度:使用了哈希表进行字符记录,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.3` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/4. 寻找两个正序数组的中位数（困难）.md | 4. 寻找两个正序数组的中位数 | https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/shua-chuan-lc-po-su-jie-fa-fen-zhi-jie-f-wtu2/ | 困难 | [
"二分",
"分治"
] | 给定两个大小分别为 $m$ 和 $n$ 的正序(从小到大)数组 `nums1` 和 `nums2`。
请你找出并返回这两个正序数组的「中位数」。
示例 1:
```
输入:nums1 = [1,3], nums2 = [2]
输出:2.00000
解释:合并数组 = [1,2,3] ,中位数 2
```
示例 2:
```
输入:nums1 = [1,2], nums2 = [3,4]
输出:2.50000
解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
```
示例 3:
```
输入:nums1 = [0,0], nums2 = [0,0]
输出:0.00000
```
示例 4:
```
输入:nums1 = [], nums2 = [1]
输出:1.00000
```
示例 5:
```
输入:nums1 = [2], nums2 = []
输出:2.00000
```
提示:
* $nums1.length == m$
* $nums2.length == n$
* $0 <= m <= 1000$
* $0 <= n <= 1000$
* $1 <= m + n <= 2000$
* $-10^6 <= nums1[i], nums2[i] <= 10^6$
进阶:你能设计一个时间复杂度为 $O(\log (m+n))$ 的算法解决此问题吗? | ### 朴素解法
如果忽略进阶的 $O(\log{(m + n)})$ 要求,这道题就非常简单。
一个比较直观的做法:将两个数组合并,排序,然后分别取得 `total / 2` 和 `(total - 1) / 2` 两个位置的数,取两者平均值。
这样做的目的是为了避免分情况讨论:合并后的数组长度是奇数还是偶数。
```Java
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
int[] arr = new int[n + m];
int idx = 0;
for (int i : nums1) arr[idx++] = i;
for (int i : nums2) arr[idx++] = i;
Arrays.sort(arr);
int l = arr[(n + m) / 2], r = arr[(n + m - 1) / 2];
return (l + r) / 2.0;
}
```
* 时间复杂度:合并两个数组的复杂度是 $O(m + n)$,对合并数组进行排序的复杂度是 $O((m + n)\log{(m + n)})$。整体复杂度是 $O((m + n)\log{(m + n)})$
* 空间复杂度:$O(1)$
**注意:`Arrays.sort()` 不只有双轴快排实现,这里的复杂度分析是假定其使用双轴快排。**
---
### 分治解法
首先可以将原问题等效为:从两个有序数组中找第 k 小的数。
分两种情况讨论:
1. 总个数为偶数:找到 `第 (total / 2) 个小的数` 和 `第 (total / 2 + 1) 个小的数`,结果为两者的平均值。
2. 总个数为奇数:结果为 `第 (total / 2 + 1) 个小的数` 。
具体思路为:
* 默认第一个数组比第二个数组的有效长度短,如果不满足,则调换两个数组(这也是一个常用技巧,目的是减少边界处理工作:原本需要对两个数组做越界检查,现在只需要对短的数组做越界检查)
* 第一个数组的有效长度从 `i` 开始,第二个数组的有效长度从 `j` 开始,其中 `[i,si - 1]` 是第一个数组的前 `k / 2` 个元素,`[j,sj - 1]` 是第二个数组的前 `k - k / 2` 个元素(为了确保 k 为奇数的时候正确)
* 当 `nums1[si - 1] > nums2[sj - 1]`:则表示第 `k` 小一定不在 `[j,sj - 1]` 中,即在 `[i,n]` 或 `[sj,m]` 中
* 当 `nums1[si - 1] <= nums2[sj - 1]`:则表示第 `k` 小一定不在 `[i,si - 1]` 中,即在 `[si,n]` 或 `[j,m]` 中
```Java
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int tot = nums1.length + nums2.length;
if (tot % 2 == 0) {
int left = find(nums1, 0, nums2, 0, tot / 2);
int right = find(nums1, 0, nums2, 0, tot / 2 + 1);
return (left + right) / 2.0;
} else {
return find(nums1, 0, nums2, 0, tot / 2 + 1);
}
}
int find(int[] n1, int i, int[] n2, int j, int k) {
if (n1.length - i > n2.length - j) return find(n2, j, n1, i, k);
if (i >= n1.length) return n2[j + k - 1];
if (k == 1) {
return Math.min(n1[i], n2[j]);
} else {
int si = Math.min(i + (k / 2), n1.length), sj = j + k - (k / 2);
if (n1[si - 1] > n2[sj - 1]) {
return find(n1, i, n2, sj, k - (sj - j));
} else {
return find(n1, si, n2, j, k - (si - i));
}
}
}
}
```
* 时间复杂度:每次递归 k 的规模都减少一半,复杂度为 $O(\log{(m + n)})$
* 空间复杂度:$O(1)$
---
### 总结
今天这道题,我给你介绍了两种技巧:
1. 在机试或者竞赛中,目的是尽可能快的 AC,所以 Java 可以直接不写 `private` 的修饰符(不写代表使用默认的包权限),这没有问题,不用纠结
2. 在机试或者竞赛中,遇到一些是从文字上限制我们的题目,例如本题限制我们使用 $O(\log{(m+n)})$ 算法。可以分析是否能够不按照限制要求来做,具体分析思路为:
1. 先有一个很容易实现的算法思路。例如本题很容易就想到直接使用双指针找第 k 个小的数,复杂度为 $O(n)$。
2. 看题目的数据规模 1 是否支撑我们使用限制以外的算法。例如本题数据规模只有 1000 + 1000 = 2000。
3. 根据数据规模,判断我们的朴素算法计算机是否可以在 1s 内处理完 2 ,即判断运算次数是否在 $10^7$ 以内 3 。例如本题使用双指针算法,指针移动和判断大小算一次运行,由于数据只有 2000,距离 $10^7$ 还很远,所以完全足够了
说明 1:正规的算法题目都会提供数据规模,LeetCode 上一些旧题目没有提供,是因为当时出的时候不太规范,LeetCode 新题、其他 OJ 平台题目,算法竞赛题目都会有。
说明 2:即使是最严格的 OJ 中最简单的题目,也会提供 1s 的运行时间,超过这个时间才算超时。
说明 3:计算器 1s 内极限的处理速度是 $10^8$ ,但为了尽可能不出现错误提交,使用技巧时尽量和 $10^7$ 进行比较。
**注意:这两个技巧,我只推荐在机试或者竞赛(尽可能快 AC 的场景)中使用。平时练习或者和面试的时候必须老实按照题目要求来。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.4` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/5. 最长回文子串（中等）.md | 5. 最长回文子串 | https://leetcode-cn.com/problems/longest-palindromic-substring/solution/shua-chuan-lc-po-su-jie-fa-manacher-suan-i2px/ | 中等 | [
"模拟",
"回文串"
] | 给你一个字符串 `s`,找到 `s` 中最长的回文子串。
示例 1:
```
输入:s = "babad"
输出:"bab"
解释:"aba" 同样是符合题意的答案。
```
示例 2:
```
输入:s = "cbbd"
输出:"bb"
```
示例 3:
```
输入:s = "a"
输出:"a"
```
示例 4:
```
输入:s = "ac"
输出:"a"
```
提示:
* $1 <= s.length <= 1000$
* `s` 仅由数字和英文字母(大写和/或小写)组成 | ### 朴素解法
这道题有一个很容易就能想到的简单做法:枚举字符串 `s` 中的每一位,作为回文串的中心点,左右进行扩展,直到达到边界或者不满足回文串定义为止。
这样做的思路必然是正确的。
但很显然这是一个朴素(暴力)做法,那么我们如何确定这一做法是否可行呢?
还记得我们上一节的分析思路吗?当我们有了一个简单的实现方法之后,需要从**题目的数据规模**、**计算机的处理速度**和**实现方法的计算量**出发,判断这样的做法是否不会超时。
由于字符串长度最多只有 1000,而我们的实现方法是 $O(n^2)$,因此我们算法的计算量应该在 $10^6$ 以内,是在计算机每秒的处理范围内的。
首先枚举回文串的中心 i,然后分两种情况向两边扩展边界,直到达到边界或者不满足回文串定义为止:
* 回文串长度是奇数,则依次判断 `s[i − k] == s[i + k], k = 1,2,3...`
* 回文串长度是偶数,则依次判断 `s[i − k] == s[i + k − 1], k = 1,2,3...`
代码:
```Java
class Solution {
public String longestPalindrome(String s) {
String ans = "";
for (int i = 0; i < s.length(); i++) {
// 回文串为奇数
int l = i - 1, r = i + 1;
String sub = getString(s, l, r);
if (sub.length() > ans.length()) ans = sub;
// 回文串为偶数
l = i - 1;
r = i + 1 - 1;
sub = getString(s, l, r);
if (sub.length() > ans.length()) ans = sub;
}
return ans;
}
String getString(String s, int l, int r) {
while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
l--;
r++;
}
return s.substring(l + 1, r);
}
}
```
* 时间复杂度:先枚举了 `s` 中的每个字符作为回文串的中心点,再从中心点出发左右扩展,最多扩展到边界。复杂度是 $O(n^2)$
* 空间复杂度:$O(1)$
---
### Manacher 算法
这是一个比较冷门的算法,使用范围也比较单一,只能用于解决「回文串」问题。
Manacher 确实是「回文串」问题的最优解。
但事实上我还没有见过必须使用 Manacher 算法才能过的回文串题。
因此我这里直接给解决方案(可以直接当做模板来使用),而不再讨论算法的具体实现原理。
Manacher 算法较长,为了避免回文串长度奇偶问题的分情况讨论,我会对原字符进行处理,在边界和字符之间插入占位符。
使用了这样的技巧之后,**当非占位字符作为回文串的中心时,对应了回文串长度为奇数的情况;当占位字符作为回文串的中心时,对应了回文串长度为偶数的情况。**。
举个例子:
> 原字符:"babad",转换后:"\*b\*a\*b\*a\*d\*",得到的回文串:"\*b\*a\*b\*",然后再去除占位符输出:"bab"。
*解释:"aba" 同样是符合题意的答案。*
代码:
```Java
class Solution {
public String longestPalindrome(String s) {
if (s.length() == 1) return s;
char[] chars = manacherString(s);
int n = chars.length;
int[] pArr = new int[n];
int C = -1, R = -1, pos = -1;
int max = Integer.MIN_VALUE;
for (int i = 0; i < n; i++) {
pArr[i] = i < R ? Math.min(pArr[C * 2 - i], R - i) : 1;
while (i + pArr[i] < n && i - pArr[i] > -1) {
if (chars[i + pArr[i]] == chars[i - pArr[i]]) {
pArr[i]++;
} else {
break;
}
}
if (i + pArr[i] > R) {
R = i + pArr[i];
C = i;
}
if (pArr[i] > max) {
max = pArr[i];
pos = i;
}
}
int offset = pArr[pos];
StringBuilder sb = new StringBuilder();
for (int i = pos - offset + 1; i <= pos + offset - 1; i++) {
if (chars[i] != '#') sb.append(chars[i]);
}
return sb.toString();
}
char[] manacherString(String s) {
char[] chars = new char[s.length() * 2 + 1];
for (int i = 0, idx = 0; i < chars.length; i++) {
chars[i] = (i & 1) == 0 ? '#' : s.charAt(idx++);
}
return chars;
}
}
```
* 时间复杂度:只对字符串进行了一次扫描。复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 总结
今天这道题目,三叶除了提供常规的、时间复杂度为 $O(n^2)$ 的朴素解法以外,还给你提供了关于「回文串」的最优解 Manacher 算法模板,建议有余力的同学可以背过。
背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个字符串,返回该字符串的最大回文子串。
同时借助 Manacher 算法,还给大家介绍了如何避免回文串长度的分情况讨论,这个技巧只要涉及「回文串」问题都适用(无论是否使用 Manacher 算法)。
对于想要背过 Manacher 算法的同学,建议先敲 3 遍,默写 2 遍,然后过了 24 小时,再默写 2 遍,一周后,再进行重复,直到熟练。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.5` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/6. Z 字形变换（中等）.md | 6. Z 字形变换 | https://leetcode-cn.com/problems/zigzag-conversion/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-naz6/ | 中等 | [
"模拟",
"数学"
] | 将一个给定字符串 `s` 根据给定的行数 `numRows` ,以从上往下、从左到右进行 `Z` 字形排列。
比如输入字符串为 `"PAYPALISHIRING"` 行数为 $3$ 时,排列如下:
```
P A H N
A P L S I I G
Y I R
```
之后,你的输出需要从左往右逐行读取,产生出一个新的字符串,比如 `"PAHNAPLSIIGYIR"` 。
请你实现这个将字符串进行指定行数变换的函数:`string convert(string s, int numRows);`
示例 1:
```
输入:s = "PAYPALISHIRING", numRows = 3
输出:"PAHNAPLSIIGYIR"
```
示例 2:
```
输入:s = "PAYPALISHIRING", numRows = 4
输出:"PINALSIGYAHRPI"
解释:
P I N
A L S I G
Y A H R
P I
```
示例 3:
```
输入:s = "A", numRows = 1
输出:"A"
```
提示:
* $1 <= s.length <= 1000$
* `s` 由英文字母(小写和大写)、`','` 和 `'.'` 组成
* $1 <= numRows <= 1000$ | ### 模拟
由于最终是要我们对 `Z` 型矩阵进行从上往下、从左往右的构建输出。
因此可以构建一个矩阵 `g` 存储 `Z` 型中的每行字符(忽略 `Z` 中的空格间隙),同时使用 `idxs` 存储 `Z` 型中每行用到的下标。
目标 `Z` 型 和 矩阵 `g` 以及 `idxs` 三者关系:
```
P I N PIN 3
A L S I G => ALSIG => 5
Y A H R YAHR 4
P I PI 2
```
代码:
```Java
class Solution {
static int N = 1010;
static char[][] g = new char[N][N];
static int[] idxs = new int[N];
public String convert(String s, int m) {
if (m == 1) return s;
int n = s.length();
Arrays.fill(idxs, 0);
for (int i = 0, j = 0, k = 1; i < n; i++) {
g[j][idxs[j]++] = s.charAt(i);
j += k;
if (j < 0) {
j += 2; k = 1;
} else if (j == m) {
j -= 2; k = -1;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < m; i++) {
for (int j = 0; j < idxs[i]; j++) {
sb.append(g[i][j]);
}
}
return sb.toString();
}
}
```
* 时间复杂度:创建数组的工作只会发生一次,清空 `idxs` 数组操作会发生在每个样例中,复杂度为 $O(m)$;将 `s` 的每个字符填入矩阵的复杂度为 $O(n)$;从矩阵中取出字符构建答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$
* 空间复杂度:$O(n \times m)$
---
### 数学规律
对于本题,我们可以不失一般性的将规律推导为「首项」和「公差公式」。
这通常能够有效减少一些判断。
分情况讨论:
* 对于第一行和最后一行:公差为 `2 * (n − 1)` 的等差数列,首项是 `i`
* 对于其他行:两个公差为 `2 * (n − 1)` 的等差数列交替排列,首项分别是 `i` 和 `2 * n − i − 2`
代码:
```Java
class Solution {
public String convert(String s, int r) {
int n = s.length();
if (n == 1 || r == 1) return s;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < r; i++) {
if (i == 0 || i == r - 1) {
int pos = i, offset = 2 * (r - 1);
while (pos < n) {
sb.append(s.charAt(pos));
pos += offset;
}
} else {
int pos1 = i, pos2 = 2 * r - i - 2;
int offset = 2 * (r - 1);
while (pos1 < n || pos2 < n) {
if (pos1 < n) {
sb.append(s.charAt(pos1));
pos1 += offset;
}
if (pos2 < n) {
sb.append(s.charAt(pos2));
pos2 += offset;
}
}
}
}
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.6` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/7. 整数反转（简单）.md | 7. 整数反转 | https://leetcode-cn.com/problems/reverse-integer/solution/shua-chuan-lc-bu-wan-mei-jie-fa-wan-mei-919rd/ | 简单 | [
"数学",
"模拟"
] | 给你一个 $32$ 位的有符号整数 `x` ,返回将 `x` 中的数字部分反转后的结果。
如果反转后整数超过 $32$ 位的有符号整数的范围 $[−2^{31}, 2^{31} − 1]$ ,就返回 $0$。
假设环境不允许存储 $64$ 位整数(有符号或无符号)。
示例 1:
```
输入:x = 123
输出:321
```
示例 2:
```
输入:x = -123
输出:-321
```
示例 3:
```
输入:x = 120
输出:21
```
示例 4:
```
输入:x = 0
输出:0
```
提示:
* -$2^{31} <= x <= 2^{31}$ - 1 | ### 不完美解法
在机试或者周赛这种需要快速 AC 的场景中,遇到这种从文字上进行限制的题目,可以选择性的忽略限制。
对于本题,题目从文字上限制我们只能使用 $32$ 位的数据结构(`int`)。
但由于数据范围过大,使用 `int` 会有溢出的风险,所以我们使用 `long` 来进行计算,在返回再转换为 `int`。
代码:
```Java
class Solution {
public int reverse(int x) {
long ans = 0;
while (x != 0) {
ans = ans * 10 + x % 10;
x = x / 10;
}
return (int)ans == ans ? (int)ans : 0;
}
}
```
* 时间复杂度:数字 $x$ 的位数,数字大约有 $\log{x}$ 位。复杂度为 $O(\log{x})$
* 空间复杂度:$O(1)$
---
### 完美解法
在「不完美解法」中,我们使用了不符合文字限制的 `long` 数据结构。
接下来我们看看,不使用 `long` 该如何求解。
从上述解法来看,我们在循环的 `ans = ans * 10 + x % 10` 这一步会有溢出的风险,因此我们需要边遍历边判断是否溢出:
* 对于正数而言:溢出意味着 `ans * 10 + x % 10 > Integer.MAX_VALUE`,对等式进行变化后可得 `ans > (Integer.MAX_VALUE - x % 10) / 10)`。所以我们可以根据此变形公式进行预判断
* 对于负数而言:溢出意味着 `ans * 10 + x % 10 < Integer.MIN_VALUE`,对等式进行变化后可得 `ans < (Integer.MIN_VALUE - x % 10) / 10)`。所以我们可以根据此变形公式进行预判断
代码:
```Java
class Solution {
public int reverse(int x) {
int ans = 0;
while (x != 0) {
if (x > 0 && ans > (Integer.MAX_VALUE - x % 10) / 10) return 0;
if (x < 0 && ans < (Integer.MIN_VALUE - x % 10) / 10) return 0;
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
}
```
* 时间复杂度:数字 $x$ 的位数,数字大约有 $\log{x}$ 位。复杂度为 $O(\log{x})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.7` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/8. 字符串转换整数 (atoi)（中等）.md | 8. 字符串转换整数 (atoi) | https://leetcode-cn.com/problems/string-to-integer-atoi/solution/shua-chuan-lc-jian-ji-jie-fa-by-ac_oier-69tp/ | 中等 | [
"模拟"
] | 请你来实现一个 `myAtoi(string s)` 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。
函数 `myAtoi(string s)` 的算法如下:
* 读入字符串并丢弃无用的前导空格
* 检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。 确定最终结果是负数还是正数。 如果两者都不存在,则假定结果为正。
* 读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
* 将前面步骤读入的这些数字转换为整数(即,`"123" -> 123`, `"0032" -> 32`)。如果没有读入数字,则整数为 $0$ 。必要时更改符号(从步骤 $2$ 开始)。
* 如果整数数超过 $32$ 位有符号整数范围 [−$2^{31}$, $2^{31}$ − 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 −$2^{31}$ 的整数应该被固定为 −$2^{31}$ ,大于 $2^{31}$ − 1 的整数应该被固定为 $2^{31}$ − 1 。
* 返回整数作为最终结果。
注意:
* 本题中的空白字符只包括空格字符 `' '` 。
* 除前导空格或数字后的其余字符串外,请勿忽略 任何其他字符。
示例 1:
```
输入:s = "42"
输出:42
解释:加粗的字符串为已经读入的字符,插入符号是当前读取的字符。
第 1 步:"42"(当前没有读入字符,因为没有前导空格)
^
第 2 步:"42"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
^
第 3 步:"42"(读入 "42")
^
解析得到整数 42 。
由于 "42" 在范围 [-231, 231 - 1] 内,最终结果为 42 。
```
示例 2:
```
输入:s = " -42"
输出:-42
解释:
第 1 步:" -42"(读入前导空格,但忽视掉)
^
第 2 步:" -42"(读入 '-' 字符,所以结果应该是负数)
^
第 3 步:" -42"(读入 "42")
^
解析得到整数 -42 。
由于 "-42" 在范围 [-231, 231 - 1] 内,最终结果为 -42 。
```
示例 3:
```
输入:s = "4193 with words"
输出:4193
解释:
第 1 步:"4193 with words"(当前没有读入字符,因为没有前导空格)
^
第 2 步:"4193 with words"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
^
第 3 步:"4193 with words"(读入 "4193";由于下一个字符不是一个数字,所以读入停止)
^
解析得到整数 4193 。
由于 "4193" 在范围 [-231, 231 - 1] 内,最终结果为 4193 。
```
示例 4:
```
输入:s = "words and 987"
输出:0
解释:
第 1 步:"words and 987"(当前没有读入字符,因为没有前导空格)
^
第 2 步:"words and 987"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
^
第 3 步:"words and 987"(由于当前字符 'w' 不是一个数字,所以读入停止)
^
解析得到整数 0 ,因为没有读入任何数字。
由于 0 在范围 [-231, 231 - 1] 内,最终结果为 0 。
```
示例 5:
```
输入:s = "-91283472332"
输出:-2147483648
解释:
第 1 步:"-91283472332"(当前没有读入字符,因为没有前导空格)
^
第 2 步:"-91283472332"(读入 '-' 字符,所以结果应该是负数)
^
第 3 步:"-91283472332"(读入 "91283472332")
^
解析得到整数 -91283472332 。
由于 -91283472332 小于范围 [-231, 231 - 1] 的下界,最终结果被截断为 -231 = -2147483648 。
```
提示:
* $0 <= s.length <= 200$
* `s` 由英文字母(大写和小写)、数字(`0-9`)、`' '`、`'+'`、`'-'` 和 `'.'` 组成 | ### 朴素解法
这是道模拟题。
一看这题目描述,多少有点做工程项目各种判断的意思了。
但对于这类题目,切忌一上来直接写代码,很容易会陷入各种边界判断。
这时候一个比较推荐的做法是先对要求进行提炼整理:
1. 忽略前导空格
2. 首字符只能是 正号/负号/数字,否则不合法(返回 0)
3. 继续往后匹配字符,直到结尾或不为数字为止(匹配过程中如果出现溢出,根据正负直接返回 `Integer.MAX_VALUE` 或 `Integer.MIN_VALUE`)。
当整理出来具体的逻辑之后,记得再次检查是否有遗漏掉某些边界情况。
确定逻辑之后,代码就好写了。
代码:
```Java
class Solution {
public int myAtoi(String s) {
int n = s.length();
char[] chars = s.toCharArray();
int idx = 0;
// 去除前导空格,如果去完前导空格后无字符了,返回 0
while (idx < n && chars[idx] == ' ') idx++;
if (idx == n) return 0;
// 检查第一个字符:可以为正负号/数字
boolean isNeg = false;
if (chars[idx] == '-') {
idx++;
isNeg = true;
} else if (chars[idx] == '+') {
idx++;
} else if (!Character.isDigit(chars[idx])) {
return 0;
}
int ans = 0;
while (idx < n && Character.isDigit(chars[idx])) {
int cur = chars[idx++] - '0';
// 和上一题的“【刷穿 LeetCode】7. 整数反转”一样,防止 ans = ans * 10 + cur 溢出
// 等价变形为 ans > (Integer.MAX_VALUE - cur) / 10 进行预判断
if (ans > (Integer.MAX_VALUE - cur) / 10) {
return isNeg ? Integer.MIN_VALUE : Integer.MAX_VALUE;
}
ans = ans * 10 + cur;
}
return isNeg ? -ans : ans;
}
}
```
* 时间复杂度:会对整个字符串 `s` 扫描一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.8` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/9. 回文数（简单）.md | 9. 回文数 | https://leetcode-cn.com/problems/palindrome-number/solution/shua-chuan-lc-zi-fu-chuan-fei-zi-fu-chua-e8l0/ | 简单 | [
"数学",
"回文串"
] | 给你一个整数 `x` ,如果 `x` 是一个回文整数,返回 `true` ;否则,返回 `false` 。
回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
例如,$121$ 是回文,而 $123$ 不是。
示例 1:
```
输入:x = 121
输出:true
```
示例 2:
```
输入:x = -121
输出:false
解释:从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
```
示例 3:
```
输入:x = 10
输出:false
解释:从右向左读, 为 01 。因此它不是一个回文数。
```
示例 4:
```
输入:x = -101
输出:false
```
提示:
* -$2^{31} <= x <= 2^{31}$ - 1
进阶:你能不将整数转为字符串来解决这个问题吗? | ### 字符串解法
虽然进阶里提到了不能用字符串来解决,但还是提供一下吧。
代码:
```Java
class Solution {
public boolean isPalindrome(int x) {
String s = String.valueOf(x);
StringBuilder sb = new StringBuilder(s);
sb.reverse();
return sb.toString().equals(s);
}
}
```
* 时间复杂度:数字 $n$ 的位数,数字大约有 $\log_{10}^n$ 位,翻转操作要执行循环。复杂度为 $O(\log_{10}^n)$
* 空间复杂度:使用了字符串作为存储。复杂度为 $O(\log_{10}^n)$
---
### 非字符串解法(完全翻转)
原数值 `x` 的不超过 int 的表示范围,但翻转后的值会有溢出的风险,所以这里使用 `long` 进行接收,最后对比两者是否相等。
代码:
```Java
class Solution {
public boolean isPalindrome(int x) {
if (x < 0) return false;
long ans = 0;
int t = x;
while (x > 0) {
ans = ans * 10 + x % 10;
x /= 10;
}
return ans - t == 0;
}
}
```
* 时间复杂度:数字 $n$ 的位数,数字大约有 $\log_{10}^n$ 位。复杂度为 $O(\log_{10}^n)$
* 空间复杂度:$O(1)$
---
### 非字符串解法(部分翻转)
如果在进阶中增加一个我们熟悉的要求:环境中只能存储得下 $32$ 位的有符号整数。
那么我们就连 `long` 也不能用了,这时候要充分利用「回文」的特性:前半部分和后半部分(翻转)相等。
这里的前半部分和后半部分(翻转)需要分情况讨论:
* 回文长度为奇数:回文中心是一个独立的数,即 `忽略回文中心后,前半部分 == 后半部分(翻转)`。如 1234321 回文串
* 回文长度为偶数:回文中心在中间两个数中间,即 `前半部分 == 后半部分(翻转)`。如 123321
代码:
```Java
class Solution {
public boolean isPalindrome(int x) {
// 对于 负数 和 x0、x00、x000 格式的数,直接返回 flase
if (x < 0 || (x % 10 == 0 && x != 0)) return false;
int t = 0;
while (x > t) {
t = t * 10 + x % 10;
x /= 10;
}
// 回文长度的两种情况:直接比较 & 忽略中心点(t 的最后一位)进行比较
return x == t || x == t / 10;
}
}
```
* 时间复杂度:数字 $n$ 的位数,数字大约有 $\log_{10}^n$ 位。复杂度为 $O(\log_{10}^n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.9` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1001. 网格照明（困难）.md | 1001. 网格照明 | https://leetcode-cn.com/problems/grid-illumination/solution/gong-shui-san-xie-ha-xi-biao-xian-ying-s-s48d/ | 困难 | [
"模拟",
"哈希表"
] | 在大小为 `n x n` 的网格 `grid` 上,每个单元格都有一盏灯,最初灯都处于 关闭 状态。
给你一个由灯的位置组成的二维数组 `lamps`,其中 $lamps[i] = [row_i, col_i]$ 表示 打开 位于 `grid[rowi][coli]` 的灯。即便同一盏灯可能在 `lamps` 中多次列出,不会影响这盏灯处于 打开 状态。
当一盏灯处于打开状态,它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。
另给你一个二维数组 `queries`,其中 $queries[j] = [row_j, col_j]$ 。对于第 $j$ 个查询,如果单元格 $[row_j, col_j]$ 是被照亮的,则查询结果为 $1$ ,否则为 $0$ 。
在第 `j` 次查询之后 [按照查询的顺序] ,关闭 位于单元格 $grid[row_j][col_j]$ 上及相邻 $8$ 个方向上(与单元格 $grid[row_i][col_i]$ 共享角或边)的任何灯。
返回一个整数数组 `ans` 作为答案, `ans[j]` 应等于第 `j` 次查询 `queries[j]` 的结果,$1$ 表示照亮,$0$ 表示未照亮。
示例 1:
```
输入:n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
输出:[1,0]
```
```
解释:最初所有灯都是关闭的。在执行查询之前,打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮(蓝色方框)。该单元格被照亮,所以 ans[0] = 1 。然后,关闭红色方框中的所有灯。
```
```
第 1 次查询检查 grid[1][0] 是否被照亮(蓝色方框)。该单元格没有被照亮,所以 ans[1] = 0 。然后,关闭红色矩形中的所有灯。
```
示例 2:
```
输入:n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]
输出:[1,1]
```
示例 3:
```
输入:n = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]
输出:[1,1,0]
```
提示:
* $1 <= n <= 10^9$
* $0 <= lamps.length <= 20000$
* $0 <= queries.length <= 20000$
* $lamps[i].length == 2$
* $0 <= row_i, col_i < n$
* $queries[j].length == 2$
* $0 <= row_j, col_j < n$ | ### 哈希表 + 线映射
棋盘大小的数据范围为 $n = 10^9$,硬模拟「亮灯」的操作必然会 `TLE`,而 `lamps` 和 `queries` 数据范围为 $20000$ 是一个较为常见的突破口。
由于点亮每一盏灯,可以使得当前 **行、列 和 对角线** 的位置被照亮,行列可直接使用棋盘坐标的 $(x, y)$ 来代指,而对角线则可以使用「截距」来进行代指,即使用 $x + y$ 和 $x - y$ 进行代指。
分别使用四个「哈希表」`row`、`col`、`left` 和 `right` 来记录 **行、列 和 对角线** 的点亮情况(`key` 为线编号,`value` 为点亮次数)。
这样我们可以在 $O(1)$ 的复杂度处理掉所有的 $lamps[i]$,某个位置被照亮的充要条件为:**「当前位置所在行被点亮」或「当前位置所在列被点亮」或「当前位置所处的对角线被点亮」。**
同时,由于每次查询后要进行「灭灯」操作(注意:灭灯只能灭有灯的位置,而不是灭有光的位置 🤣),因此我们还需要另外记录每个灯的位置,可以使用利用「二维转一维」的技巧进行编号:$idx = x * n + y$,并使用 `HashSet` 进行记录(忽略重复的 $lamps[i]$)。
由于询问次数最多为 $20000$,因此直接在查询完成后模拟「灭灯」即可(访问自身及相邻格子,共 $9$ 个),计算量为 $2 * 10^5$ 以内,可以接受。若某个位置存在灯,将其从 `HashSet` 中移除,并更新对应线的点亮情况。
代码:
```Java
class Solution {
int[][] dirs = new int[][]{{0,0},{0,-1},{0,1},{-1,0},{-1,-1},{-1,1},{1,0},{1,-1},{1,1}};
public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
long N = n;
Map<Integer, Integer> row = new HashMap<>(), col = new HashMap<>();
Map<Integer, Integer> left = new HashMap<>(), right = new HashMap<>();
Set<Long> set = new HashSet<>();
for (int[] l : lamps) {
int x = l[0], y = l[1];
int a = x + y, b = x - y;
if (set.contains(x * N + y)) continue;
increment(row, x); increment(col, y);
increment(left, a); increment(right, b);
set.add(x * N + y);
}
int m = queries.length;
int[] ans = new int[m];
for (int i = 0; i < m; i++) {
int[] q = queries[i];
int x = q[0], y = q[1];
int a = x + y, b = x - y;
if (row.containsKey(x) || col.containsKey(y) || left.containsKey(a) || right.containsKey(b)) ans[i] = 1;
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
int na = nx + ny, nb = nx - ny;
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
if (set.contains(nx * N + ny)) {
set.remove(nx * N + ny);
decrement(row, nx); decrement(col, ny);
decrement(left, na); decrement(right, nb);
}
}
}
return ans;
}
void increment(Map<Integer, Integer> map, int key) {
map.put(key, map.getOrDefault(key, 0) + 1);
}
void decrement(Map<Integer, Integer> map, int key) {
if (map.get(key) == 1) map.remove(key);
else map.put(key, map.get(key) - 1);
}
}
```
* 时间复杂度:令 $lamps$ 长度为 $a$,$queries$ 长度为 $b$,处理所有的 $lamp[i]$ 复杂度为 $O(a)$,处理所有的 $queries[j]$ 复杂度为 $O(C * b)$,其中 $C$ 为模拟灭灯时所联通的格子数量,固定为 $9$。整体复杂度为 $O(a + C * b)$
* 空间复杂度:$O(a)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1001` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1004. 最大连续1的个数 III（中等）.md | 1004. 最大连续1的个数 III | https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/san-chong-jie-fa-cong-dong-tai-gui-hua-d-gxks/ | 中等 | [
"双指针",
"滑动窗口",
"二分",
"前缀和"
] | 给定一个由若干 $0$ 和 $1$ 组成的数组 `A`,我们最多可以将 $K$ 个值从 $0$ 变成 $1$ 。
返回仅包含 $1$ 的最长(连续)子数组的长度。
示例 1:
```
输入:A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出:6
解释:
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1,最长的子数组长度为 6。
```
示例 2:
```
输入:A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出:10
解释:
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1,最长的子数组长度为 10。
```
提示:
* $1 <= A.length <= 20000$
* $0 <= K <= A.length$
* $A[i]$ 为 $0$ 或 $1$ | ### 动态规划(TLE)
看到本题,其实首先想到的是 DP,但是 DP 是 $O(nk)$ 算法。
看到了数据范围是 $10^4$,那么时空复杂度应该都是 $10^8$。
空间可以通过「滚动数组」优化到 $10^4$,但时间无法优化,会超时。
**PS. 什么时候我们会用 DP 来解本题?通过如果 K 的数量级不超过 1000 的话,DP 应该是最常规的做法。**
定义 $f[i,j]$ 代表考虑前 $i$ 个数(并以 $A[i]$ 为结尾的),最大翻转次数为 $j$ 时,连续 $1$ 的最大长度。
* 如果 $A[i]$ 本身就为 1 的话,无须消耗翻转次数,$f[i][j] = f[i - 1][j] + 1$。
* 如果 $A[i]$ 本身不为 1 的话,由于定义是必须以 $A[i]$ 为结尾,因此必须要选择翻转该位置,$f[i][j] = f[i - 1][j - 1] + 1$。
代码:
```Java
class Solution {
public int longestOnes(int[] nums, int k) {
int n = nums.length;
int[][] f = new int[2][k + 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
if (nums[i - 1] == 1) {
f[i & 1][j] = f[(i - 1) & 1][j] + 1;
} else {
f[i & 1][j] = j == 0 ? 0 : f[(i - 1) & 1][j - 1] + 1;
}
ans = Math.max(ans, f[i & 1][j]);
}
}
return ans;
}
}
```
* 时间复杂度:$O(nk)$
* 空间复杂度:$O(k)$
---
### 前缀和 + 二分
从数据范围上分析,**平方级别**的算法过不了,往下优化就应该是**对数级别**的算法。
因此,很容易我们就会想到「二分」。
当然还需要我们对问题做一下等价变形。
**最大替换次数不超过 `k` 次,可以将问题转换为找出连续一段区间 `[l,r]`,使得区间中出现 0 的次数不超过 `k` 次。**
我们可以枚举区间 左端点/右端点 ,然后找到其满足「出现 0 的次数不超过 `k` 次」的最远右端点/最远左端点。
为了快速判断 `[l,r]` 之间出现 0 的个数,我们需要用到前缀和。
假设 `[l,r]` 的区间长度为 `len`,区间和为 `tot`,那么出现 0 的格式为 `len - tol`,再与 `k` 进行比较。
由于数组中不会出现负权值,因此前缀和数组具有「单调性」,那么必然满足「其中一段满足 $len - tol <= k$,另外一段不满足 $len - tol <= k$」。
**因此,对于某个确定的「左端点/右端点」而言,以「其最远右端点/最远左端点」为分割点的前缀和数轴,具有「二段性」。可以通过二分来找分割点。**
代码:
```Java
class Solution {
public int longestOnes(int[] nums, int k) {
int n = nums.length;
int ans = 0;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
for (int i = 0; i < n; i++) {
int l = 0, r = i;
while (l < r) {
int mid = l + r >> 1;
if (check(sum, mid, i, k)) {
r = mid;
} else {
l = mid + 1;
}
}
if (check(sum, r, i, k)) ans = Math.max(ans, i - r + 1);
}
return ans;
}
boolean check(int[] sum, int l, int r, int k) {
int tol = sum[r + 1] - sum[l], len = r - l + 1;
return len - tol <= k;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
**关于二分结束后再次 `check` 的说明:由于「二分」本质是找满足某个性质的分割点,通常我们的某个性质会是「非等值条件」,不一定会取得 `=`。**
**例如我们很熟悉的:从某个非递减数组中找目标值,找到返回下标,否则返回 -1。**
**当目标值不存在,「二分」找到的应该是数组内比目标值小或比目标值大的最接近的数。因此二分结束后先进行 `check` 再使用是一个好习惯。**
---
### 双指针
由于我们总是比较 `len`、`tot` 和 `k` 三者的关系。
因此我们可以使用「滑动窗口」的思路,动态维护一个左右区间 `[j, i]` 和维护窗口内和 `tot`。
右端点一直右移,左端点在窗口不满足「`len - tol <= k`」的时候进行右移,即可做到线程扫描的复杂度。
代码:
```Java
class Solution {
public int longestOnes(int[] nums, int k) {
int n = nums.length;
int ans = 0;
for (int i = 0, j = 0, tot = 0; i < n; i++) {
tot += nums[i];
while ((i - j + 1) - tot > k) tot -= nums[j++];
ans = Math.max(ans, i - j + 1);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 总结
**除了掌握本题解法以外,我还希望你能理解这几种解法是如何被想到的(特别是如何从「动态规划」想到「二分」)。**
**根据数据范围(复杂度)调整自己所使用的算法的分析能力,比解决该题本身更加重要。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1004` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1005. K 次取反后最大化的数组和（简单）.md | 1005. K 次取反后最大化的数组和 | https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/solution/gong-shui-san-xie-jian-dan-fen-qing-kuan-6qwu/ | 简单 | [
"优先队列(堆)",
"模拟",
"贪心"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,按以下方法修改该数组:
* 选择某个下标 `i` 并将 `nums[i]` 替换为 `-nums[i]` 。
重复这个过程恰好 `k` 次。可以多次选择同一个下标 `i` 。
以这种方式修改数组后,返回数组 可能的最大和 。
示例 1:
```
输入:nums = [4,2,3], k = 1
输出:5
解释:选择下标 1 ,nums 变为 [4,-2,3] 。
```
示例 2:
```
输入:nums = [3,-1,0,2], k = 3
输出:6
解释:选择下标 (1, 2, 2) ,nums 变为 [3,1,0,2] 。
```
示例 3:
```
输入:nums = [2,-3,-1,5,-4], k = 2
输出:13
解释:选择下标 (1, 4) ,nums 变为 [2,3,-1,5,4] 。
```
提示:
* $1 <= nums.length <= 10^4$
* $-100 <= nums[i] <= 100$
* $1 <= k <= 10^4$ | ### 贪心 + 分情况讨论 + 模拟
假设取反前的总和为 $sum$,取反一个任意值 $x$ 后,对 $sum$ 的影响为 $- 2 * x$。
即取反一个负数会使得结果变大,取反正数会使结果变小,取反 $0$ 值对结果没有影响。
因此,为了让取反后的结果尽可能的大,我们应当取反 $-2*x$ 尽可能大的数值。即按照「负数从小到大的顺序进行取反」。
对取反次数 $k$ 和 负数个数 $cnt$ 进行分情况讨论:
* $k <= cnt$:按照负数从小到大的顺序进行取反即可;
* $k > cnt$:按照负数从小到大的顺序进行取反后,根据「是否存在 $0$ 值」和「剩余取反次数的奇偶性」进行分情况讨论:
* 存在 $0$ 值 或 剩余取反次数为偶数:直接返回当前取反数组的总和( $0$ 值可抵消任意次数的取反操作,将偶数次的取反操作应用在同一数值上,结果不变);
* 不存在 $0$ 值且剩余取反次数为奇数:此时从当前数值中取一个绝对值最小值(使用 $idx$ 记录该值下标)进行取反,得到最终的取反数组。
最后对取反数组进行求和操作即可。
代码:
```Java
class Solution {
public int largestSumAfterKNegations(int[] nums, int k) {
int n = nums.length, idx = 0;
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->nums[a]-nums[b]);
boolean zero = false;
for (int i = 0; i < n; i++) {
if (nums[i] < 0) q.add(i);
if (nums[i] == 0) zero = true;
if (Math.abs(nums[i]) < Math.abs(nums[idx])) idx = i;
}
if (k <= q.size()) {
while (k-- > 0) nums[q.peek()] = -nums[q.poll()];
} else {
while (!q.isEmpty() && k-- > 0) nums[q.peek()] = -nums[q.poll()];
if (!zero && k % 2 != 0) nums[idx] = -nums[idx];
}
int ans = 0;
for (int i : nums) ans += i;
return ans;
}
}
```
* 时间复杂度:对 $nums$ 进行遍历,得到 $idx$ 以及优先队列的复杂度为 $O(n\log{n})$;从优先队列中取出元素进行取反操作的复杂度为 $O(k\log{n})$;对取反数组进行求和复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 优化优先队列
由于 $nums$ 长度范围为 $10000$,但值域范围在 $[-100, 100]$,因此我们可以使用计数数组 $cnt$ 来替代优先队列的作用。
注意由于 $nums[i]$ 存在负数,因此需要增 $100$ 的偏移量。同时对于翻转操作,仅需要修改相应计数即可。
代码:
```Java
class Solution {
public int largestSumAfterKNegations(int[] nums, int k) {
int[] cnts = new int[210];
for (int i : nums) cnts[i + 100]++;
for (int i = -100; i < 0 && k > 0; i++) {
while (cnts[i + 100] != 0 && k-- > 0) {
cnts[i + 100]--; cnts[-i + 100]++;
}
}
if (cnts[0 + 100] == 0 && k > 0 && k % 2 != 0) {
int val = 1;
while (cnts[val + 100] == 0) val++;
cnts[val + 100]--; cnts[-val + 100]++;
}
int ans = 0;
for (int i = -100; i <= 100; i++) ans += i * cnts[i + 100];
return ans;
}
}
```
* 时间复杂度:需要对 $nums$ 以及大小为 $C = 210$ 的计数数组进行常数次扫描,复杂度为 $O(n + C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1006. 笨阶乘（中等）.md | 1006. 笨阶乘 | https://leetcode-cn.com/problems/clumsy-factorial/solution/gong-shui-san-xie-tong-yong-biao-da-shi-nngfp/ | 中等 | [
"数学",
"栈"
] | 通常,正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。
例如,factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。
相反,我们设计了一个笨阶乘 clumsy:在整数的递减序列中,我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符:乘法(*),除法(/),加法(+)和减法(-)。
例如,clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而,这些运算仍然使用通常的算术运算顺序:我们在任何加、减步骤之前执行所有的乘法和除法步骤,并且按从左到右处理乘法和除法步骤。
另外,我们使用的除法是地板除法(floor division),所以 10 * 9 / 8 等于 11。这保证结果是一个整数。
实现上面定义的笨函数:给定一个整数 N,它返回 N 的笨阶乘。
示例 1:
```
输入:4
输出:7
解释:7 = 4 * 3 / 2 + 1
```
示例 2:
```
输入:10
输出:12
解释:12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
```
提示:
* 1 <= N <= 10000
* -$2^{31}$ <= answer <= $2^{31}$ - 1 (答案保证符合 32 位整数) | ### 通用表达式解法
第一种解法是我们的老朋友解法了,使用「双栈」来解决通用表达式问题。
**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`([224. 基本计算器](https://leetcode-cn.com/problems/basic-calculator/)) 或者 `+ - * /`([227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/)) 的表达式问题,还能能解决 `+ - * / ^ % ( )` 的完全表达式问题。**
甚至支持自定义运算符,只要在运算优先级上进行维护即可。
**对于「表达式计算」这一类问题,你都可以使用这套思路进行解决。我十分建议你加强理解这套处理逻辑。**
对于「任何表达式」而言,我们都使用两个栈 `nums` 和 `ops`:
* `nums` : 存放所有的数字
* `ops` :存放所有的数字以外的操作
然后从前往后做,对遍历到的字符做分情况讨论:
* 空格 : 跳过
* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`
* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`
* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`
* `+ - * / ^ %` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉(只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算)**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`
我们可以通过 🌰 来理解 **只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算** 是什么意思:
因为我们是从前往后做的,假设我们当前已经扫描到 `2 + 1` 了(此时栈内的操作为 `+` )。
1. 如果后面出现的 `+ 2` 或者 `- 1` 的话,满足「栈内运算符」比「当前运算符」优先级高/同等,可以将 `2 + 1` 算掉,把结果放到 `nums` 中;
2. 如果后面出现的是 `* 2` 或者 `/ 1` 的话,不满足「栈内运算符」比「当前运算符」优先级高/同等,这时候不能计算 `2 + 1`。
更为详细的讲解可以看这篇题解 :[使用「双栈」解决「究极表达式计算」问题](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/)
代码:
```Java
class Solution {
public int clumsy(int n) {
Deque<Integer> nums = new ArrayDeque<>();
Deque<Character> ops = new ArrayDeque<>();
// 维护运算符优先级
Map<Character, Integer> map = new HashMap<>(){{
put('*', 2);
put('/', 2);
put('+', 1);
put('-', 1);
}};
char[] cs = new char[]{'*', '/', '+', '-'};
for (int i = n, j = 0; i > 0; i--, j++) {
char op = cs[j % 4];
nums.addLast(i);
// 如果「当前运算符优先级」不高于「栈顶运算符优先级」,说明栈内的可以算
while (!ops.isEmpty() && map.get(ops.peekLast()) >= map.get(op)) {
calc(nums, ops);
}
if (i != 1) ops.add(op);
}
// 如果栈内还有元素没有算完,继续算
while (!ops.isEmpty()) calc(nums, ops);
return nums.peekLast();
}
void calc(Deque<Integer> nums, Deque<Character> ops) {
int b = nums.pollLast(), a = nums.pollLast();
int op = ops.pollLast();
int ans = 0;
if (op == '+') ans = a + b;
else if (op == '-') ans = a - b;
else if (op == '*') ans = a * b;
else if (op == '/') ans = a / b;
nums.addLast(ans);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 数学解法(打表技巧分析)
这次在讲【证明】之前,顺便给大家讲讲找规律的题目该怎么做。
由于是按照特定顺序替换运算符,因此应该是有一些特性可以被我们利用的。
通常我们需要先实现一个**可打表的算法(例如上述的解法一,这是为什么掌握「通用表达式」解法具有重要意义)**,将连续数字的答案打印输出,来找找规律:
```Java
Solution solution = new Solution();
for (int i = 1; i <= 10000; i++) {
int res = solution.clumsy(i);
System.out.println(i + " : " + res);
}
```
似乎 $n$ 与 答案比较接近,我们考虑将两者的差值输出:
```Java
Solution solution = new Solution();
for (int i = 1; i <= 10000; i++) {
int res = solution.clumsy(i);
System.out.println(i + " : " + res + " : " + (res - i));
}
```
咦,好像发现了什么不得了的东西。似乎每四个数,差值都是 [1, 2, 2, -1]
再修改我们的打表逻辑,来验证一下(只输出与我们猜想不一样的数字):
```Java
Solution solution = new Solution();
int[] diff = new int[]{1,2,2,-1};
for (int i = 1; i <= 10000; i++) {
int res = solution.clumsy(i);
int t = res - i;
if (t != diff[i % 4]) {
System.out.println(i + " : " + res);
}
}
```
只有前四个数字被输出,其他数字都是符合我们的猜想规律的。
**到这里我们已经知道代码怎么写可以 AC 了,十分简单。**
代码:
```java
class Solution {
public int clumsy(int n) {
int[] special = new int[]{1,2,6,7};
int[] diff = new int[]{1,2,2,-1};
if (n <= 4) return special[(n - 1) % 4];
return n + diff[n % 4];
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
***
### 证明
讲完我们的【实战技巧】之后,再讲讲如何证明。
**上述的做法比较适合于笔试或者比赛,但是面试,通常还需要证明做法为什么是正确的。**
我们不失一般性的分析某个 `n`,当然这个 `n` 必须是大于 4,不属于我们的特判值。
然后对 `n` 进行讨论(**根据我们的打表猜想去证明规律是否可推广**):
1. `n % 4 == 0` : $f(n) = n * (n - 1) / (n - 2) + ... + 5 - 4 * 3 / 2 + 1 = n + 1$,即 `diff = 1`
2. `n % 4 == 1` : $f(n) = n * (n - 1) / (n - 2) + ... + 6 - 5 * 4 / 3 + 2 - 1 = n + 2$,即 `diff = 2`
3. `n % 4 == 2` : $f(n) = n * (n - 1) / (n - 2) + ... + 7 - 6 * 5 / 4 + 3 - 2 * 1 = n + 2$,即 `diff = 2`
4. `n % 4 == 3` : $f(n) = n * (n - 1) / (n - 2) + ... + 8 - 7 * 6 / 5 + 4 - 3 * 2 / 1 = n - 1$,即 `diff = -1`
**上述的表达式展开过程属于小学数学内容,省略号部分的项式的和为 0,因此你只需要关注我写出来的那部分。**
**至此,我们证明了我们的打表猜想具有「可推广」的特性。**
**甚至我们应该学到:证明可以是基于猜想去证明,而不必从零开始进行推导。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/101-110/108. 将有序数组转换为二叉搜索树（简单）.md | 108. 将有序数组转换为二叉搜索树 | https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/ | 简单 | [
"二叉树",
"树的搜索",
"分治"
] | 给你一个整数数组 `nums`,其中元素已经按 升序 排列,请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 $1$ 」的二叉树。
示例 1:
```
输入:nums = [-10,-3,0,5,9]
输出:[0,-3,9,-10,null,5]
解释:[0,-10,5,null,-3,null,9] 也将被视为正确答案:
```
示例 2:
```
输入:nums = [1,3]
输出:[3,1]
解释:[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。
```
提示:
* $1 <= nums.length <= 10^4$
* $-10^4 <= nums[i] <= 10^4$
* `nums` 按严格递增顺序排列 | ### 递归分治
题目给定的 `nums` 严格有序,为满足构造出来的 `BST` 整体平衡,我们需要保证每个子树的构造也是平衡的。
一个容易想到的思路:使用 `nums` 中最靠近中心的位置作为整棵 `BST` 的根节点,例如下标 $mid = \left \lfloor \frac{l + r}{2} \right \rfloor$ 的位置,确保左右子树节点数量平衡。随后递归构造 `nums` 中下标范围为 $[0, mid - 1]$ 作为左子树,递归构造 `nums` 中下标范围为 $[mid + 1, n - 1]$ 作为右子树。
Java 代码:
```Java
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return build(nums, 0, nums.length - 1);
}
TreeNode build(int[] nums, int l, int r) {
if (l > r) return null;
int mid = l + r >> 1;
TreeNode ans = new TreeNode(nums[mid]);
ans.left = build(nums, l, mid - 1);
ans.right = build(nums, mid + 1, r);
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
return self.build(nums, 0, len(nums) - 1)
def build(self, nums, l, r):
if l > r:
return None
mid = l + r >> 1
ans = TreeNode(nums[mid])
ans.left = self.build(nums, l, mid - 1)
ans.right = self.build(nums, mid + 1, r)
return ans
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* sortedArrayToBST(vector<int>& nums) {
return build(nums, 0, nums.size() - 1);
}
TreeNode* build(vector<int>& nums, int l, int r) {
if (l > r) return nullptr;
int mid = l + r >> 1;
TreeNode* ans = new TreeNode(nums[mid]);
ans->left = build(nums, l, mid - 1);
ans->right = build(nums, mid + 1, r);
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function sortedArrayToBST(nums: number[]): TreeNode | null {
const build = function (nums: number[], l: number, r: number): TreeNode | null {
if (l > r) return null;
const mid = l + r >> 1;
const ans = new TreeNode(nums[mid]);
ans.left = build(nums, l, mid - 1);
ans.right = build(nums, mid + 1, r);
return ans;
}
return build(nums, 0, nums.length - 1);
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/101-110/109. 有序链表转换二叉搜索树（中等）.md | 109. 有序链表转换二叉搜索树 | https://leetcode.cn/problems/convert-sorted-list-to-binary-search-tree/solutions/2436644/gong-shui-san-xie-jian-dan-di-gui-fen-zh-6t1x/ | 中等 | [
"二叉树",
"树的搜索",
"分治",
"中序遍历"
] | 给定一个单链表的头节点 `head`,其中的元素 按升序排序 ,将其转换为高度平衡的二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 $1$。
示例 1:
```
输入: head = [-10,-3,0,5,9]
输出: [0,-3,9,-10,null,5]
解释: 一个可能的答案是[0,-3,9,-10,null,5],它表示所示的高度平衡的二叉搜索树。
```
示例 2:
```
输入: head = []
输出: []
```
提示:
* `head` 中的节点数在 $[0, 2 \times 10^4]$ 范围内
* $-10^5 <= Node.val <= 10^5$ | ### 递归分治
与上一题 [108. 将有序数组转换为二叉搜索树](https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/) 类似,但链表相对于数组,无法 $O(1)$ 找到构建当前 `BST` 根节点的“中点”下标。
一个仍可确保 $O(n)$ 时间复杂度(瓶颈在于需要创建 $n$ 个节点),但需要 $O(n)$ 空间复杂度的做法是:对链表进行一次遍历,转成数组后套用上一题的做法。
一个不使用 $O(n)$ 空间复杂度的做法,需要每次遍历来找“中点”下标:起始我们先对 `head` 进行一次遍历,得到链表长度 $n$,随后仍然利用递归分治的思路进行构造,每次对入参的左右端点找“中点”,先通过直接结算的方式定位到偏移量 $t = l + \left \lfloor \frac{l + r}{2} \right \rfloor$,然后再通过从入参节点 `head` 出发往前走 $t$ 的做法找到“中点”节点。
该做法每个节点的访问次数为在递归过程中被 $[l, r]$ 所覆盖的次数,我们知道一个节点数量为 $n$ 的平衡 `BST` 树高为 $\log{n}$,因此整体复杂度为 $O(n\log{n})$。
Java 代码:
```Java
class Solution {
public TreeNode sortedListToBST(ListNode head) {
int n = 0;
ListNode cur = head;
while (cur != null && ++n >= 0) cur = cur.next;
return build(head, 0, n - 1);
}
TreeNode build(ListNode head, int l, int r) {
if (l > r) return null;
int mid = l + r >> 1, t = mid - l;
ListNode cur = head;
while (t-- > 0) cur = cur.next;
TreeNode ans = new TreeNode(cur.val);
ans.left = build(head, l, mid - 1);
ans.right = build(cur.next, mid + 1, r);
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:
n = 0
cur = head
while cur:
n += 1
cur = cur.next
return self.build(head, 0, n - 1)
def build(self, head: ListNode, l: int, r: int) -> TreeNode:
if l > r:
return None
mid = l + r >> 1
t = mid - l
cur = head
while t > 0:
cur = cur.next
t -= 1
ans = TreeNode(cur.val)
ans.left = self.build(head, l, mid - 1)
ans.right = self.build(cur.next, mid + 1, r)
return ans
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* sortedListToBST(ListNode* head) {
int n = 0;
ListNode* cur = head;
while (cur && ++n >= 0) cur = cur->next;
return build(head, 0, n - 1);
}
TreeNode* build(ListNode* head, int l, int r) {
if (l > r) return nullptr;
int mid = l + r >> 1, t = mid - l;
ListNode* cur = head;
while (t-- > 0) cur = cur->next;
TreeNode* ans = new TreeNode(cur->val);
ans->left = build(head, l, mid - 1);
ans->right = build(cur->next, mid + 1, r);
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function sortedListToBST(head: ListNode | null): TreeNode | null {
const build = function (head: ListNode | null, l: number, r: number): TreeNode | null {
if (l > r) return null;
let mid = l + r >> 1, t = mid - l;
let cur = head;
while (t-- > 0) cur = cur.next;
const ans = new TreeNode(cur!.val);
ans.left = build(head, l, mid - 1);
ans.right = build(cur!.next, mid + 1, r);
return ans;
}
let n = 0;
let cur = head;
while (cur != null && ++n >= 0) cur = cur.next;
return build(head, 0, n - 1);
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 递归分治 - 中序遍历
由于给定的 `nums` 本身严格有序,而 `BST` 的中序遍历亦是有序。因此我们可以一边遍历链表,一边对 `BST` 进行构造。
具体的,我们仍然先对链表进行遍历,拿到链表长度 `n`。递归构造过程中传入左右端点 `l` 和 `r`,含义为使用链表中 $[l, r]$ 部分节点,但不再在每次递归中传入当前头结点,而是使用全局变量 `head` 来记录。
递归构造过程中,计算“中点”位置 $mid = \left \lfloor \frac{l + r}{2} \right \rfloor$,并根据如下流程进行构造:
1. 使用 $[l, mid - 1]$ 构建左子树,使用变量 `left` 保存当前左子树的根节点
2. 构建完左子树后,全局变量 `head` 必然来到了“中点”位置,用其构建根节点 `ans`,并将根节点与此前构造的 `left` 关联。同时让链表节点 `head` 后移
3. 使用 $[mid + 1, r]$ 构建右子树,并将其挂载到根节点 `ans` 中
如此一来,即可确保「链表遍历」和「`BST` 构造」的同步性。
Java 代码:
```Java
class Solution {
ListNode head;
public TreeNode sortedListToBST(ListNode _head) {
head = _head;
int n = 0;
ListNode cur = head;
while (cur != null && ++n >= 0) cur = cur.next;
return build(0, n - 1);
}
TreeNode build(int l, int r) {
if (l > r) return null;
int mid = l + r >> 1;
TreeNode left = build(l, mid - 1);
TreeNode ans = new TreeNode(head.val);
head = head.next;
ans.left = left;
ans.right = build(mid + 1, r);
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:
self.head = head
n = 0
cur = self.head
while cur is not None:
n += 1
cur = cur.next
return self.build(0, n - 1)
def build(self, l: int, r: int) -> TreeNode:
if l > r:
return None
mid = l + r >> 1
left = self.build(l, mid - 1)
ans = TreeNode(self.head.val)
ans.left = left
self.head = self.head.next
ans.right = self.build(mid + 1, r)
return ans
```
C++ 代码:
```C++
class Solution {
public:
ListNode* head;
TreeNode* sortedListToBST(ListNode* _head) {
head = _head;
int n = 0;
ListNode* cur = head;
while (cur && n++ >= 0) cur = cur->next;
return build(0, n - 1);
}
TreeNode* build(int l, int r) {
if (l > r) return nullptr;
int mid = l + r >> 1;
TreeNode* left = build(l, mid - 1);
TreeNode* ans = new TreeNode(head->val);
ans->left = left;
head = head->next;
ans->right = build(mid + 1, r);
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function sortedListToBST(_head: ListNode | null): TreeNode | null {
const build =function(l: number, r: number): TreeNode | null {
if (l > r) return null;
const mid = l + r >> 1;
const left = build(l, mid - 1);
const ans = new TreeNode(head.val);
ans.left = left;
head = head.next;
ans.right = build(mid + 1, r);
return ans;
}
let head = _head;
let n = 0, cur = head;
while (cur && n++ >= 0) cur = cur.next;
return build(0, n - 1);
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1011. 在 D 天内送达包裹的能力（中等）.md | 1011. 在 D 天内送达包裹的能力 | https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/ | 中等 | [
"二分"
] | 传送带上的包裹必须在 `D` 天内从一个港口运送到另一个港口。
传送带上的第 `i` 个包裹的重量为 $weights[i]$。
每一天,我们都会按给出重量的顺序往传送带上装载包裹。
我们装载的重量不会超过船的最大运载重量。
返回能在 `D` 天内将传送带上的所有包裹送达的船的最低运载能力。
示例 1:
```
输入:weights = [1,2,3,4,5,6,7,8,9,10], D = 5
输出:15
解释:
船舶最低载重 15 就能够在 5 天内送达所有包裹,如下所示:
第 1 天:1, 2, 3, 4, 5
第 2 天:6, 7
第 3 天:8
第 4 天:9
第 5 天:10
请注意,货物必须按照给定的顺序装运,因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。
```
示例 2:
```
输入:weights = [3,2,2,4,1,4], D = 3
输出:6
解释:
船舶最低载重 6 就能够在 3 天内送达所有包裹,如下所示:
第 1 天:3, 2
第 2 天:2, 4
第 3 天:1, 4
```
示例 3:
```
输入:weights = [1,2,3,1,1], D = 4
输出:3
解释:
第 1 天:1
第 2 天:2
第 3 天:3
第 4 天:1, 1
```
提示:
* $1 <= D <= weights.length <= 5 \times 10^4$
* $1 <= weights[i] <= 500$ | ### 二分解法(精确边界)
假定「`D` 天内运送完所有包裹的最低运力」为 `ans`,那么在以 `ans` 为分割点的数轴上具有「二段性」:
* 数值范围在 $(-\infty, ans)$ 的运力必然「不满足」 `D` 天内运送完所有包裹的要求
* 数值范围在 $[ans, +\infty)$ 的运力必然「满足」 `D`天内运送完所有包裹的要求
**我们可以通过「二分」来找到恰好满足 `D`天内运送完所有包裹的分割点 `ans`。**
接下来我们要确定二分的范围,由于不存在包裹拆分的情况,考虑如下两种边界情况:
* 理论最低运力:只确保所有包裹能够被运送,自然也包括重量最大的包裹,此时理论最低运力为 `max`,`max` 为数组 `weights` 中的最大值
* 理论最高运力:使得所有包裹在最短时间(一天)内运送完成,此时理论最高运力为 `sum`,`sum` 为数组 `weights` 的总和
**由此,我们可以确定二分的范围为 $[max, sum]$。**
Java 代码:
```Java
class Solution {
public int shipWithinDays(int[] weights, int days) {
int max = 0, sum = 0;
for (int w : weights) {
max = Math.max(max, w);
sum += w;
}
int l = max, r = sum;
while (l < r) {
int mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int[] weights, int t, int days) {
int n = weights.length, cnt = 1;
for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int shipWithinDays(vector<int>& weights, int days) {
int maxv = 0, sum = 0;
for (int w : weights) {
maxv = max(maxv, w);
sum += w;
}
int l = maxv, r = sum;
while (l < r) {
int mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
}
bool check(vector<int>& weights, int t, int days) {
int n = weights.size(), cnt = 1;
for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
};
```
Python 代码:
```Python
class Solution:
def shipWithinDays(self, weights: List[int], days: int) -> int:
def check(weights: List[int], t: int, days: int) -> bool:
n, cnt = len(weights), 1
i, sumv = 1, weights[0]
while i < n:
while i < n and sumv + weights[i] <= t:
sumv += weights[i]
i += 1
cnt += 1
sumv = 0
return cnt - 1 <= days
maxv, sumv = max(weights), sum(weights)
l, r = maxv, sumv
while l < r:
mid = l + r >> 1
if check(weights, mid, days):
r = mid
else:
l = mid + 1
return r
```
TypeScript 代码:
```TypeScript
function shipWithinDays(weights: number[], days: number): number {
const check = function(weights: number[], t: number, days: number): boolean {
let n = weights.length, cnt = 1;
for (let i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
let maxv = 0, sumv = 0;
for (const w of weights) {
maxv = Math.max(maxv, w);
sumv += w;
}
let l = maxv, r = sumv;
while (l < r) {
const mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
};
```
* 时间复杂度:二分范围为 $[max, sum]$,`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\log({\sum_{i= 0}^{n - 1}ws[i]}))$
* 空间复杂度:$O(1)$
---
### 二分解法(粗略边界)
当然,一个合格的「二分范围」只需要确保包含分割点 `ans` 即可。因此我们可以利用数据范围来确立粗略的二分范围(从而少写一些代码):
* 利用运力必然是正整数,从而确定左边界为 $1$
* 根据 $1 \leqslant D \leqslant weights.length \leqslant 50000$ 和 $1 \leqslant weights[i] \leqslant 500$,从而确定右边界为 $1e8$
*PS. 由于二分查找具有折半效率,因此「确立粗略二分范围」不会比「通过循环取得精确二分范围」效率低。*
Java 代码:
```Java
class Solution {
public int shipWithinDays(int[] weights, int days) {
int l = 1, r = (int)1e8;
while (l < r) {
int mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int[] weights, int t, int days) {
if (weights[0] > t) return false;
int n = weights.length, cnt = 1;
for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
if (weights[i] > t) return false;
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int shipWithinDays(vector<int>& weights, int days) {
int l = 1, r = 1e8;
while (l < r) {
int mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
}
bool check(vector<int>& weights, int t, int days) {
if (weights[0] > t) return false;
int n = weights.size(), cnt = 1;
for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
if (weights[i] > t) return false;
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
};
```
Python 代码:
```Python
class Solution:
def shipWithinDays(self, weights: List[int], days: int) -> int:
def check(weights: List[int], t: int, days: int) -> bool:
if weights[0] > t: return False
n, cnt = len(weights), 1
i, sumv = 1, weights[0]
while i < n:
if weights[i] > t: return False
while i < n and sumv + weights[i] <= t:
sumv += weights[i]
i += 1
cnt += 1
sumv = 0
return cnt - 1 <= days
l, r = 1, 10**8
while l < r:
mid = l + r >> 1
if check(weights, mid, days):
r = mid
else:
l = mid + 1
return r
```
TypeScript 代码:
```TypeScript
function shipWithinDays(weights: number[], days: number): number {
const check = function(weights: number[], t: number, days: number): boolean {
if (weights[0] > t) return false;
let n = weights.length, cnt = 1;
for (let i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {
if (weights[i] > t) return false;
while (i < n && sum + weights[i] <= t) sum += weights[i++];
}
return cnt - 1 <= days;
}
let l = 0, r = 1e8;
while (l < r) {
const mid = l + r >> 1;
if (check(weights, mid, days)) r = mid;
else l = mid + 1;
}
return r;
};
```
* 时间复杂度:二分范围为 $[1, 1e8]$,`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\log{1e8})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1012. 至少有 1 位重复的数字（困难）.md | 1012. 至少有 1 位重复的数字 | https://leetcode-cn.com/problems/numbers-with-repeated-digits/solution/by-ac_oier-2szj/ | 困难 | [
"动态规划",
"数位 DP",
"容斥原理"
] | 给定正整数 $n$,返回在 $[1, n]$ 范围内具有 至少 1 位 重复数字的正整数的个数。
示例 1:
```
输入:n = 20
输出:1
解释:具有至少 1 位重复数字的正数(<= 20)只有 11 。
```
示例 2:
```
输入:n = 100
输出:10
解释:具有至少 1 位重复数字的正数(<= 100)有 11,22,33,44,55,66,77,88,99 和 100 。
```
示例 3:
```
输入:n = 1000
输出:262
```
提示:
* $1 <= n <= 10^9$ | ### 数位 DP
**首先 $[1, n]$ 共有 $n$ 个数,而求解 $[1, n]$ 范围内有多少个「至少有 $1$ 位重复数字」的数的个数,等价于「总数 $n$」减去「没有重复数的数的个数」。**
于是问题转换为:**如何求解「没有重复数」的数的个数,同时为了更具一般性,我们将求解 $[1, n]$ 范围内「没有重复数」的数的个数,修改为求解 $[0, n]$ 范围内「没有重复数」的数的个数**。
>即将问题转换为 [(题解) 357. 统计各位数字都不同的数字个数](https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/by-ac_oier-6tfl/) 中的进阶部分。
假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[0, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:
$$
ans_{(l, r)} = dp(r) - dp(l - 1)
$$
然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[0, x]$ 的合法数分成三类:
* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;
* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;
* 位数比 $x$ 少,这部分统计为 `res3`。
其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。
**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[0, cur - 1]$ 范围内取数,同时为了满足「相同数字只能使用一次」的限制,我们需要使用一个 `int` 变量 $s$ 来记录使用情况(用 $s$ 的低十位来代指数字 $[0, 9]$ 是否被使用),统计 $[0, cur - 1]$ 范围内同时符合两个限制条件的数的个数,记为 $cnt$。**
**当第 $k$ 位有 $cnt$ 种合法选择之后,后面的位数可以在满足「相同数字只能使用一次」的限制条件下任意选择(因为大小关系已经由第 $k$ 位保证),为了快速知道剩下的 $n - k$ 位有多少种方案,我们还需要预处理乘积数组,其中 $f[l][r]$ 代表 $l * (l + 1) * ... * (j - 1) * j$ 的乘积之和。**
> 上述讲解若是觉得抽象,我们可以举个 🌰,假设 $x = 678$,我们该如何求解 `res2`:由于限定了 `res2` 为「位数和 $x$ 相同,且最高位与 $x$ 最高位相同的」的合法数个数,因此最高位没有选,只能是 $6$,然后考虑处理次高位,次高位在 $x$ 中为 $7$,为了满足大小关系,我们只能在 $[0, 6]$ 范围内做限制,同时由于 $6$ 已用过,因此次高位实际只有 $[0, 5]$,共 $6$ 种选择,当确定次高位后,后面的位数任意取,由于前面已经填充了 $p = 2$ 位(即消耗了 $p$ 个不同数字),因此从后面的位数开始应该是 $a = 10 - p$ 开始往后自减累乘到 $b = (10 - p) - (n - p) + 1$ 为止,即此时方案数为 $cnt * f[b][a]$(当前位不是最低位)或者 $cnt$(当前位是最低位)。按照此逻辑循环处理所有位数即可,直到遇到重复数值或正常结束。
需要说明的是,上述的举例部分只是为方便大家理解过程,看懂了举例部分不代表理解了数位 DP 做法成立的内在条件,阅读的重点还是要放在前面加粗字体部分,只会使用样例理解算法永远不是科学的做法。
其他细节:乘积数组的预处理与样例无关,我们可以使用 `static` 进行打表优化,同时可以将 `res1` 和 `res2` 两种情况进行合并。
代码:
```Java
class Solution {
// f[l][r] 代表 i * (i + 1) * ... * (j - 1) * j
static int[][] f = new int[10][10];
static {
for (int i = 1; i < 10; i++) {
for (int j = i; j < 10; j++) {
int cur = 1;
for (int k = i; k <= j; k++) cur *= k;
f[i][j] = cur;
}
}
}
int dp(int x) {
int t = x;
List<Integer> nums = new ArrayList<>();
while (t != 0) {
nums.add(t % 10);
t /= 10;
}
int n = nums.size();
if (n <= 1) return x + 1; // [0, 9]
// 位数和 x 相同(res1 + res2)
int ans = 0;
for (int i = n - 1, p = 1, s = 0; i >= 0; i--, p++) {
int cur = nums.get(i), cnt = 0;
for (int j = cur - 1; j >= 0; j--) {
if (i == n - 1 && j == 0) continue;
if (((s >> j) & 1) == 0) cnt++;
}
int a = 10 - p, b = a - (n - p) + 1;
ans += b <= a ? cnt * f[b][a] : cnt;
if (((s >> cur) & 1) == 1) break;
s |= (1 << cur);
if (i == 0) ans++;
}
// 位数比 x 少(res3)
ans += 10;
for (int i = 2, last = 9; i < n; i++) {
int cur = last * (10 - i + 1);
ans += cur; last = cur;
}
return ans;
}
public int numDupDigitsAtMostN(int n) {
return (n + 1) - dp(n);
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1012` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1020. 飞地的数量（中等）.md | 1020. 飞地的数量 | 中等 | [
"DFS",
"并查集"
] | 给你一个大小为 $m x n$ 的二进制矩阵 $grid$ ,其中 $0$ 表示一个海洋单元格、$1$ 表示一个陆地单元格。
一次 移动 是指从一个陆地单元格走到另一个相邻(上、下、左、右)的陆地单元格或跨过 $grid$ 的边界。
返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。
示例 1:
```
输入:grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出:3
解释:有三个 1 被 0 包围。一个 1 没有被包围,因为它在边界上。
```
示例 2:
```
输入:grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
输出:0
解释:所有 1 都在边界上或可以到达边界。
```
提示:
* $m == grid.length$
* $n == grid[i].length$
* $1 <= m, n <= 500$
* $grid[i][j]$ 的值为 $0$ 或 $1$ | ### 并查集 + DFS
根据题目定义,我们知道需要统计所有不和「边缘陆地」相连通的「普通陆地」数量。
我们可以用「并查集」来维护连通块,使用 `DFS` 对所有「边缘陆地连通块」进行标记(设定编号为 $0$ 的超级源点,对于所有的「边缘陆地连通块」,将其与超级源点联通)。
具体的,我们按照如下流程进行处理:
* 初始化并查集:起始让每个单元格独立作为一个连通块;
* 使用 `DFS` 标记所有「边缘陆地连通块」:从位于边缘的「边缘陆地」进行出发,将其所在连通块与超级源点 $0$ 进行联通标记(同时为了确保复杂度,我们在进行 `DFS` 前需要先检查当前陆地与超级源点的联通关系,如果已联通,说明当前陆地隶属于之前的某个连通块,已被整体标记过,进行跳过即可);
* 统计答案:遍历整个棋盘,统计所有不与超级源点 $0$ 联通的陆地数量。
> 一些细节:由于我们人为规定了超级源点编号为 $0$,同时棋盘下标从 $0$ 开始,因此对某个点 $(x, y)$ 的编号,我们需要增加一个偏移量,例如 $idx = x * n + y + 1$。
代码:
```Java
class Solution {
int N = 550;
int[] p = new int[N * N];
int m, n;
int[][] g;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
boolean query(int a, int b) {
return find(a) == find(b);
}
void union(int a, int b) {
p[find(a)] = find(b);
}
public int numEnclaves(int[][] grid) {
g = grid;
m = g.length; n = g[0].length;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
p[getIdx(i, j)] = getIdx(i, j);
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 || j == 0 || i == m - 1 || j == n - 1) {
if (g[i][j] != 1 || query(getIdx(i, j), 0)) continue;
dfs(i, j);
}
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 1 && !query(getIdx(i, j), 0)) ans++;
}
}
return ans;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
void dfs(int x, int y) {
union(getIdx(x, y), 0);
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (g[nx][ny] != 1 || query(getIdx(nx, ny), 0)) continue;
dfs(nx, ny);
}
}
int getIdx(int x, int y) {
return x * n + y + 1;
}
}
```
* 时间复杂度:初始化并查集复杂度为 $O(m * n)$;使用 `DFS` 对边缘陆地连通块进行标记复杂度为 $O(m * n)$;统计答案复杂度为 $O(m * n)$。整体复杂度为 $O(m * n)$
* 空间复杂度:$O(m * n)$
---
### 多源 BFS
也可以使用「多源 `BFS`」进行求解。
将所有「边缘陆地」看做与超级源点相连,起始将所有「边缘陆地」进行入队(等价于只将超级源点入队,然后取出超级源点并进行拓展)。
然后是常规的 `BFS` 过程,所有能够出队/入队的陆地格子,都代表与「边缘陆地」联通,都不属于「飞地」,对其进行标记。
最后遍历整个棋盘,统计所有未被标记的「陆地」格子数量即是答案。
不熟悉「多源 `BFS`」的同学可以看前置 🧀 :[多源 BFS 入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&token=1222269277&lang=zh_CN#rd)。
代码:
```Java
class Solution {
public int numEnclaves(int[][] g) {
int m = g.length, n = g[0].length;
boolean[][] vis = new boolean[m][n];
Deque<int[]> d = new ArrayDeque<>();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 || j == 0 || i == m - 1 || j == n - 1) {
if (g[i][j] == 0) continue;
vis[i][j] = true;
d.addLast(new int[]{i, j});
}
}
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int x = poll[0], y = poll[1];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (g[nx][ny] != 1) continue;
if (vis[nx][ny]) continue;
vis[nx][ny] = true;
d.addLast(new int[]{nx, ny});
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 1 && !vis[i][j]) ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
|
LeetCode/1021-1030/1021. 删除最外层的括号（简单）.md | 1021. 删除最外层的括号 | https://leetcode.cn/problems/remove-outermost-parentheses/solution/by-ac_oier-jmxi/ | 简单 | [
"模拟",
"双指针"
] | 有效括号字符串为空 `""`、`"(" + A + ")"` 或 `A + B` ,其中 `A` 和 `B` 都是有效的括号字符串,`+` 代表字符串的连接。
例如,`""`,`"()"`,`"(())()"` 和 `"(()(()))"` 都是有效的括号字符串。
如果有效字符串 `s` 非空,且不存在将其拆分为 `s = A + B` 的方法,我们称其为原语(`primitive`),其中 `A` 和 `B` 都是非空有效括号字符串。
给出一个非空有效字符串 `s`,考虑将其进行原语化分解,使得:`s = P_1 + P_2 + ... + P_k`,其中 `P_i` 是有效括号字符串原语。
对 `s` 进行原语化分解,删除分解中每个原语字符串的最外层括号,返回 s 。
示例 1:
```
输入:s = "(()())(())"
输出:"()()()"
解释:
输入字符串为 "(()())(())",原语化分解得到 "(()())" + "(())",
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。
```
示例 2:
```
输入:s = "(()())(())(()(()))"
输出:"()()()()(())"
解释:
输入字符串为 "(()())(())(()(()))",原语化分解得到 "(()())" + "(())" + "(()(()))",
删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。
```
示例 3:
```
输入:s = "()()"
输出:""
解释:
输入字符串为 "()()",原语化分解得到 "()" + "()",
删除每个部分中的最外层括号后得到 "" + "" = ""。
```
提示:
* $1 <= s.length <= 10^5$
* `s[i]` 为 `'('` 或 `')'`
* `s` 是一个有效括号字符串 | ### 双指针模拟
和其他「有效括号」问题一样,我们将 `(` 记为 $1$ 分,将 `)` 记为 $-1$。
由于 `s` 本身为有效字符串,因此我们可以从前往后进行处理,每一次找到符合 $socre = 0$ 的连续段 $[i, j)$,然后再结合题意,删掉外层括号,即将 $[i + 1, j - 1)$ 加入答案。
代码:
```Java
class Solution {
public String removeOuterParentheses(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
StringBuilder sb = new StringBuilder();
for (int i = 0, score = 0; i < n; ) {
int j = i;
while (i == j || score != 0) score += cs[j++] == '(' ? 1 : -1;
sb.append(s.substring(i + 1, j - 1));
i = j;
score = 0;
}
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1021-1030/1022. 从根到叶的二进制数之和（简单）.md | 1022. 从根到叶的二进制数之和 | https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers/solution/by-ac_oier-1905/ | 简单 | [
"DFS",
"BFS",
"二叉树",
"树的遍历"
] | 给出一棵二叉树,其上每个结点的值都是 $0$ 或 $1$ 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。
例如,如果路径为 `0 -> 1 -> 1 -> 0 -> 1`,那么它表示二进制数 `01101`,也就是 $13$ 。
对树上的每一片叶子,我们都要找出从根到该叶子的路径所表示的数字。
返回这些数字之和。题目数据保证答案是一个 $32$ 位 整数。
示例 1:
```
输入:root = [1,0,1,0,1,0,1]
输出:22
解释:(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
```
示例 2:
```
输入:root = [0]
输出:0
```
提示:
* 树中的节点数在 $[1, 1000]$ 范围内
* `Node.val` 仅为 $0$ 或 $1$ | ### 递归
容易想到「递归」进行求解,在 `DFS` 过程中记录下当前的值为多少,假设遍历到当前节点 $x$ 前,记录的值为 $cur$,那么根据题意,我们需要先将 $cur$ 进行整体左移(腾出最后一位),然后将节点 $x$ 的值放置最低位来得到新的值,并继续进行递归。
递归有使用「函数返回值」和「全局变量」两种实现方式。
代码:
```Java
class Solution {
public int sumRootToLeaf(TreeNode root) {
return dfs(root, 0);
}
int dfs(TreeNode root, int cur) {
int ans = 0, ncur = (cur << 1) + root.val;
if (root.left != null) ans += dfs(root.left, ncur);
if (root.right != null) ans += dfs(root.right, ncur);
return root.left == null && root.right == null ? ncur : ans;
}
}
```
-
```Java
class Solution {
int ans = 0;
public int sumRootToLeaf(TreeNode root) {
dfs(root, 0);
return ans;
}
void dfs(TreeNode root, int cur) {
int ncur = (cur << 1) + root.val;
if (root.left != null) dfs(root.left, ncur);
if (root.right != null) dfs(root.right, ncur);
if (root.left == null && root.right == null) ans += ncur;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 迭代
自然也可以使用「迭代」进行求解。
为了不引入除「队列」以外的其他数据结构,当我们可以把某个节点 $x$ 放出队列时,先将其的值修改为当前遍历路径对应的二进制数。
代码:
```Java
class Solution {
public int sumRootToLeaf(TreeNode root) {
int ans = 0;
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
if (poll.left != null) {
poll.left.val = (poll.val << 1) + poll.left.val;
d.addLast(poll.left);
}
if (poll.right != null) {
poll.right.val = (poll.val << 1) + poll.right.val;
d.addLast(poll.right);
}
if (poll.left == null && poll.right == null) ans += poll.val;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1022` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1032. 字符流（困难）.md | 1032. 字符流 | https://leetcode.cn/problems/stream-of-characters/solution/by-ac_oier-ihd4/ | 困难 | [
"字典树",
"枚举",
"剪枝"
] | 设计一个算法:接收一个字符流,并检查这些字符的后缀是否是字符串数组 `words` 中的一个字符串。
例如,`words = ["abc", "xyz"]` 且字符流中逐个依次加入 $4$ 个字符 `'a'`、`'x'`、`'y'` 和 `'z'` ,你所设计的算法应当可以检测到 `"axyz"` 的后缀 `"xyz"` 与 `words` 中的字符串 `"xyz"` 匹配。
按下述要求实现 `StreamChecker` 类:
* `StreamChecker(String[] words)` :构造函数,用字符串数组 `words` 初始化数据结构。
* `boolean query(char letter)`:从字符流中接收一个新字符,如果字符流中的任一非空后缀能匹配 `words` 中的某一字符串,返回 `true`;否则,返回 `false`。
示例:
```
输入:
["StreamChecker", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query"]
[[["cd", "f", "kl"]], ["a"], ["b"], ["c"], ["d"], ["e"], ["f"], ["g"], ["h"], ["i"], ["j"], ["k"], ["l"]]
输出:
[null, false, false, false, true, false, true, false, false, false, false, false, true]
解释:
StreamChecker streamChecker = new StreamChecker(["cd", "f", "kl"]);
streamChecker.query("a"); // 返回 False
streamChecker.query("b"); // 返回 False
streamChecker.query("c"); // 返回n False
streamChecker.query("d"); // 返回 True ,因为 'cd' 在 words 中
streamChecker.query("e"); // 返回 False
streamChecker.query("f"); // 返回 True ,因为 'f' 在 words 中
streamChecker.query("g"); // 返回 False
streamChecker.query("h"); // 返回 False
streamChecker.query("i"); // 返回 False
streamChecker.query("j"); // 返回 False
streamChecker.query("k"); // 返回 False
streamChecker.query("l"); // 返回 True ,因为 'kl' 在 words 中
```
提示:
* $1 <= words.length <= 2000$
* $1 <= words[i].length <= 200$
* `words[i]` 由小写英文字母组成
* `letter` 是一个小写英文字母
* 最多调用查询 $4 \times 10^4$ 次 | ### Trie + 枚举
先考虑最为简单的做法:将给定的所有 $words[i]$ 顺序插入字典树,根据数据范围可知这一步计算量为 $2000 \times 200$,其中最大的 $words[i]$ 长度只有 $200$。
然后利用$words[i]$ 长度只有 $200$ 这一条件,直接使用「枚举」的方式来实现 `query`。
具体的,我们可以先使用一个字符串 `s` 来记录 `query` 操作产生的数据流,然后实现一个 `boolean query(int start, int end)` 方法,该方法会检查字典树中是否存在 $s[i...j]$ 子串。
由于 $words[i]$ 长度只有 $200$(假设当前 `s` 的长度为 $n$),因此我们只需要枚举「$\max(0, n - 200)$ 作为子串左端点,$n - 1$ 作为子串右端点」是否存在字典树中(是否存在 $words[i]$ 中)即可,最坏情况下,单次 `query` 操作计算量为 $200 \times 200$。
> 一些细节:为了避免每个样例都 `new` 大数组,我们可以使用 `static` 优化。
Java 代码:
```Java
class StreamChecker {
static int N = 2010 * 200, idx = 0;
static int[][] tr = new int[N][26];
static boolean[] isEnd = new boolean[N * 26];
StringBuilder sb = new StringBuilder();
void add(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
boolean query(int start, int end) {
int p = 0;
for (int i = start; i <= end; i++) {
int u = sb.charAt(i) - 'a';
if (tr[p][u] == 0) return false;
p = tr[p][u];
}
return isEnd[p];
}
public StreamChecker(String[] words) {
for (int i = 0; i <= idx; i++) {
Arrays.fill(tr[i], 0);
isEnd[i] = false;
}
idx = 0;
for (String s : words) add(s);
}
public boolean query(char c) {
sb.append(c);
int n = sb.length(), min = Math.max(0, n - 200);
for (int i = n - 1; i >= min; i--) {
if (query(i, n - 1)) return true;
}
return false;
}
}
```
C++ 代码:
```C++
class StreamChecker {
public:
static const int N = 2010 * 200;
int tr[N][26];
bool isEnd[N];
string sb;
int idx = 0;
void add(const string &s) {
int p = 0;
for (char c : s) {
int u = c - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
bool query(int start, int end) {
int p = 0;
for (int i = start; i <= end; i++) {
int u = sb[i] - 'a';
if (tr[p][u] == 0) return false;
p = tr[p][u];
}
return isEnd[p];
}
StreamChecker(const vector<string>& words) {
memset(tr, 0, sizeof(tr));
memset(isEnd, 0, sizeof(isEnd));
for (const string &s : words) add(s);
}
bool query(char c) {
sb.push_back(c);
int n = sb.length(), min = max(0, n - 200);
for (int i = n - 1; i >= min; i--) {
if (query(i, n - 1)) return true;
}
return false;
}
};
```
* 时间复杂度:`StreamChecker` 初始化复杂度为 $O(n)$,其中 $n$ 为 `words` 字符总数;`query` 操作复杂度为 $O(m^2)$,其中 $m = 200$ 为最大 `words[i]` 长度
* 空间复杂度:$O(n \times C)$,其中 $n$ 为 `words` 字符总数,$C = 26$ 为字符集大小
---
### Trie(优化)
初始化将所有的 $words[i]$ 存入 `Trie` 是必然的,我们只能考虑如何优化 `query` 操作。
在解法一中,我们需要对新数据流对应的字符串的每个后缀进行搜索,同时每次搜索是相互独立的,即本次匹配不会对下一次匹配产生贡献。
**实际上,我们可以通过「倒序建 `Trie`」的方式,将「枚举检查多个后缀」的操作变为「匹配一次后缀」操作。**
具体的,我们可以在初始化 `StreamChecker` 时,将每个 $words[i]$ 翻转(倒序)加入 `Trie` 中;然后在 `query` 操作时(假设当前数据流对应的字符串为 `s`,长度为 $n$),从 `s` 的尾部开始在 `Trie` 中进行检索(即从 $s[n - 1]$ 开始往回找)。
若在某个位置 `idx` 时匹配成功,意味着 $s[idx ... (n-1)]$ 的翻转子串在字典树中,同时我们又是将每个 `words[i]` 进行倒序插入,即意味着 $s[idx ... (n - 1)]$ 的正向子串在 `words` 中,即满足 `s` 的某个后缀出现在 `words` 中。
同理,我们可以利用最大的 `words[i]` 长度为 $200$ 来控制从 $s[n - 1]$ 开始往回找的最远距离,同时利用当某个短后缀不在 `Trie` 中,则其余长度更大的后缀必然不在 `Trie` 中进行剪枝操作。
Java 代码:
```Java
class StreamChecker {
static int N = 2010 * 200, idx = 0;
static int[][] tr = new int[N][26];
static boolean[] isEnd = new boolean[N * 26];
StringBuilder sb = new StringBuilder();
void add(String s) {
int p = 0;
for (int i = s.length() - 1; i >= 0; i--) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
public StreamChecker(String[] words) {
for (int i = 0; i <= idx; i++) {
Arrays.fill(tr[i], 0);
isEnd[i] = false;
}
idx = 0;
for (String s : words) add(s);
}
public boolean query(char c) {
sb.append(c);
int n = sb.length(), min = Math.max(0, n - 200), p = 0;
for (int i = n - 1; i >= min; i--) {
if (isEnd[p]) return true;
int u = sb.charAt(i) - 'a';
if (tr[p][u] == 0) return false;
p = tr[p][u];
}
return isEnd[p];
}
}
```
C++ 代码:
```C++
class StreamChecker {
public:
static const int N = 2010 * 200;
static const int ALPHABET_SIZE = 26;
vector<vector<int>> tr;
vector<bool> isEnd;
string sb;
int idx = 0;
void add(const string &s) {
int p = 0;
for (int i = s.length() - 1; i >= 0; i--) {
int u = s[i] - 'a';
if (tr[p].size() <= u) tr[p].resize(u + 1, 0);
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
StreamChecker(const vector<string>& words) {
tr.resize(N);
isEnd.resize(N);
fill(isEnd.begin(), isEnd.end(), false);
for (const auto &s : words) {
add(s);
}
}
bool query(char c) {
sb.push_back(c);
int n = sb.length(), min = max(0, n - 200), p = 0;
for (int i = n - 1; i >= min; i--) {
if (isEnd[p]) return true;
int u = sb[i] - 'a';
if (tr[p].size() <= u || tr[p][u] == 0) return false;
p = tr[p][u];
}
return isEnd[p];
}
};
```
* 时间复杂度:`StreamChecker` 初始化复杂度为 $O(n)$,其中 $n$ 为 `words` 字符总数;`query` 操作复杂度为 $O(m)$,其中 $m = 200$ 为最大 `words[i]` 长度
* 空间复杂度:$O(n \times C)$,其中 $n$ 为 `words` 字符总数,$C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1032` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1034. 边界着色（中等）.md | 1034. 边界着色 | https://leetcode-cn.com/problems/coloring-a-border/solution/gong-shui-san-xie-tu-lun-sou-suo-zhuan-t-snvw/ | 中等 | [
"图论 DFS",
"图论 BFS"
] | 给你一个大小为 `m x n` 的整数矩阵 `grid`,表示一个网格。另给你三个整数 `row`、`col` 和 `color` 。网格中的每个值表示该位置处的网格块的颜色。
当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一 连通分量 。
连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻(四个方向上)的所有网格块,或者在网格的边界上(第一行/列或最后一行/列)的所有网格块。
请你使用指定颜色 `color` 为所有包含网格块 `grid[row][col]` 的 连通分量的边界 进行着色,并返回最终的网格 `grid` 。
示例 1:
```
输入:grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
输出:[[3,3],[3,2]]
```
示例 2:
```
输入:grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
输出:[[1,3,3],[2,3,3]]
```
示例 3:
```
输入:grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
输出:[[2,2,2],[2,1,2],[2,2,2]]
```
提示:
* $m == grid.length$
* $n == grid[i].length$
* $1 <= m, n <= 50$
* $1 <= grid[i][j], color <= 1000$
* $0 <= row < m$
* $0 <= col < n$ | ### 基本分析
这是一道结合「阅读理解」的常规图论搜索题。
基本题意为:从题目给定的 $(row, col)$ 进行出发,如果遍历到「**连通分量的边界**」格子,则使用 $color$ 进行上色。
同一「连通分量」的「非边界」格子满足:**当前格子的四联通方向均存在相邻格子,且当前格子与四联通相邻格子颜色一致。**
也就是说,我们从 $(row, col)$ 进行出发,遍历 $(row, col)$ 所在的「连通分量」,如果遍历到的「连通分量」格子不满足上述条件(边界格子),则进行上色。
---
### BFS
具体的,我们可以使用 `BFS` 进行求解:
* 构造 $ans$ 矩阵作为答案,同时 $ans$ 也作为判重数组使用(通过判断 $ans[i][j]$ 是否为 $0$ 来得知是否被处理);
* 起始时,将 $(row, col)$ 位置进行入队,每次从队列中取出元素进行「四联通拓展」:
* 拓展格子必须与起点格子处于同一「连通分量」,即满足两者起始颜色相同;
* 进行「四联通拓展」的同时,记录当前出队是否为边界格子。若为边界格子,则使用 $color$ 进行上色;
* 跑完 `BFS` 后,对 $ans$ 进行遍历,将未上色($ans[i][j] = 0$)的位置使用原始色($grid[i][j]$)进行上色。
代码:
```Java
class Solution {
public int[][] colorBorder(int[][] grid, int row, int col, int color) {
int m = grid.length, n = grid[0].length;
int[][] ans = new int[m][n];
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{row, col});
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int x = poll[0], y = poll[1], cnt = 0;
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (grid[x][y] != grid[nx][ny]) continue;
else cnt++;
if (ans[nx][ny] != 0) continue;
d.addLast(new int[]{nx, ny});
}
ans[x][y] = cnt == 4 ? grid[x][y] : color;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (ans[i][j] == 0) ans[i][j] = grid[i][j];
}
}
return ans;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(m * n)$
---
### DFS
同理,可以使用 `DFS` 进行求解。
由于使用 `DFS` 搜索时,我们使用「栈帧压栈/弹栈」作为拓展联通节点的容器,且仅在出队时进行上色。为防止「重复入队」问题,我们需要先在对节点 $(nx, ny)$ 入队时,先设置将 $ans[nx][ny]$ 设置为 $-1$ 标识位,以作为判重依据。
代码:
```Java
class Solution {
int m, n, c;
int[][] grid, ans;
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
public int[][] colorBorder(int[][] _grid, int row, int col, int color) {
grid = _grid; c = color;
m = grid.length; n = grid[0].length;
ans = new int[m][n];
dfs(row, col);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (ans[i][j] == 0) ans[i][j] = grid[i][j];
}
}
return ans;
}
void dfs(int x, int y) {
int cnt = 0;
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (grid[x][y] != grid[nx][ny]) continue;
else cnt++;
if (ans[nx][ny] != 0) continue;
ans[nx][ny] = -1;
dfs(nx, ny);
}
ans[x][y] = cnt == 4 ? grid[x][y] : c;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(m * n)$
---
### 其他「图论搜索」相关内容
题太简单?不如来学习热乎的 [常规 BFS 搜索题(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)
* [常规 BFS 搜索题(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)
* [多源 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)
* [双向 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&scene=178&cur_album_id=1917113998693449732#rd)
* [双向 BFS II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&scene=178&cur_album_id=1917113998693449732#rd)
* [灵活运用多种搜索方式(含启发式搜索)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489560&idx=2&sn=bb966d868c18d656620a20d31a425b23&chksm=fd9cb307caeb3a11424428f0a88e7f0cb86bb53b3e5a2b9e28683a24bcb3ac151655d2b6419e&scene=178&cur_album_id=1917113998693449732#rd)
* [灵活运用多种搜索方式 II(含启发式搜索)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64&chksm=fd9cb32bcaeb3a3d4f0bd73f023a92a165edabf212af1db9672a55bed1af7d4e32e8af9964c3&scene=178&cur_album_id=1917113998693449732#rd) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1035. 不相交的线（中等）.md | 1035. 不相交的线 | https://leetcode-cn.com/problems/uncrossed-lines/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bkaas/ | 中等 | [
"最长公共子序列",
"序列 DP",
"LCS"
] | 在两条独立的水平线上按给定的顺序写下 `s1` 和 `s2` 中的整数。
现在,可以绘制一些连接两个数字 $s1[i]$ 和 $s2[j]$ 的直线,这些直线需要同时满足满足:
* $s1[i] = s2[j]$
* 且绘制的直线不与任何其他连线(非水平线)相交。
请注意,连线即使在端点也不能相交:每个数字只能属于一条连线。
以这种方法绘制线条,并返回可以绘制的最大连线数。
示例 1:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/28/142.png" style="zoom:18%;" />
```
输入:s1 = [1,4,2], s2 = [1,2,4]
输出:2
解释:可以画出两条不交叉的线,如上图所示。
但无法画出第三条不相交的直线,因为从 s1[1]=4 到 s2[2]=4 的直线将与从 s1[2]=2 到 s2[1]=2 的直线相交。
```
示例 2:
```
输入:s1 = [2,5,1,2,5], s2 = [10,5,2,1,5,2]
输出:3
```
示例 3:
```
输入:s1 = [1,3,7,1,7,5], s2 = [1,9,2,5,1]
输出:2
```
提示:
* $1 <= s1.length <= 500$
* $1 <= s2.length <= 500$
* $1 <= s1[i], s2[i] <= 2000$ | ### 动态规划
这是一道「[最长公共子序列(LCS)](https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/)」的轻度变形题。
对于这类题都使用如下「状态定义」即可:
**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**
然后不失一般性的考虑 $f[i][j]$ 如何转移。
**由于我们的「状态定义」只是说「考虑前 $i$ 个和考虑前 $j$ 个字符」,并没有说「一定要包含第 $i$ 个或者第 $j$ 个字符」(这也是「最长公共子序列 LCS」与「最长上升子序列 LIS」状态定义上的最大不同)。**
我们需要考虑「不包含 $s1[i]$,不包含 $s2[j]$」、「不包含 $s1[i]$,包含 $s2[j]$」「包含 $s1[i]$,不包含 $s2[j]$」、「包含 $s1[i]$,包含 $s2[j]$」四种情况:
* 不包含 $s1[i]$,不包含 $s2[j]$:结合状态定义,可以使用 $f[i - 1][j - 1]$ 进行精确表示。
* 包含 $s1[i]$,包含 $s2[j]$:前提是 $s1[i] = s2[j]$,可以使用 $f[i - 1][j - 1] + 1$ 进行精确表示。
* 不包含 $s1[i]$,包含 $s2[j]$:结合状态定义,我们无法直接将该情况表示出来。
**注意 $f[i - 1][j]$ 只是表示「必然不包含 $s1[i]$,但可能包含$s2[j]$」的情况,也就是说 $f[i - 1][j]$ 其实是该情况与情况 $1$ 的合集**。
但是由于我们求的是「最大值」,只需要确保「不漏」即可保证答案的正确(某些情况被重复参与比较不影响正确性),因此这里直接使用 $f[i - 1][j]$ 进行表示没有问题。
* 包含 $s1[i]$,不包含 $s2[j]$:与情况 $3$ 同理,直接使用 $f[i][j - 1]$ 表示没有问题。
$f[i][j]$ 就是在上述所有情况中取 $max$ 而来,由于情况 $1$ 被 情况 $3$ 和 情况 $4$ 所包含,因此我们只需要考虑 $f[i - 1][j]$、$f[i][j -1]$ 和 $f[i - 1][j - 1] + 1$ 三种状态即可,其中最后一种状态需要满足 $s1[i] = s2[j]$ 前提条件。
因此我们最后的状态转移方程为:
$$
f[i][j]=\begin{cases}
\max(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1] + 1) & s1[i] = s2[j] \\
\max(f[i - 1][j], f[i][j - 1]) & s1[i] \neq s2[j] \\
\end{cases}
$$
上述分析过程建议加深理解,估计很多同学能 AC 但其实并不知道 LCS 问题的状态转移是包含了「重复状态比较」的。
Java 代码:
```Java
class Solution {
public int maxUncrossedLines(int[] s1, int[] s2) {
int n = s1.length, m = s2.length;
int[][] f = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
if (s1[i - 1] == s2[j - 1]) {
f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
}
}
}
return f[n][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxUncrossedLines(vector<int>& s1, vector<int>& s2) {
int n = s1.size(), m = s2.size();
vector<vector<int>> f(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
if (s1[i - 1] == s2[j - 1]) {
f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
}
}
}
return f[n][m];
}
};
```
Python 代码:
```Python
class Solution:
def maxUncrossedLines(self, s1: List[int], s2: List[int]) -> int:
n, m = len(s1), len(s2)
f = [[0] * (m + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(1, m + 1):
f[i][j] = max(f[i - 1][j], f[i][j - 1])
if s1[i - 1] == s2[j - 1]:
f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1)
return f[n][m]
```
TypeScript 代码:
```TypeScript
function maxUncrossedLines(s1: number[], s2: number[]): number {
const n = s1.length, m = s2.length;
const f = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
for (let i = 1; i <= n; ++i) {
for (let j = 1; j <= m; ++j) {
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
if (s1[i - 1] === s2[j - 1]) {
f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
}
}
}
return f[n][m];
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1035` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1036. 逃离大迷宫（困难）.md | 1036. 逃离大迷宫 | https://leetcode-cn.com/problems/escape-a-large-maze/solution/gong-shui-san-xie-bfs-gei-ding-zhang-ai-8w63o/ | 困难 | [
"几何",
"BFS"
] | 在一个 $10^6 \times 10^6$ 的网格中,每个网格上方格的坐标为 $(x, y)$ 。
现在从源方格 $source = [s_x, s_y]$ 开始出发,意图赶往目标方格 $target = [t_x, t_y]$ 。
数组 $blocked$ 是封锁的方格列表,其中每个 $blocked[i] = [x_i, y_i]$ 表示坐标为 $(x_i, y_i)$ 的方格是禁止通行的。
每次移动,都可以走到网格中在四个方向上相邻的方格,只要该方格 不 在给出的封锁列表 $blocked$ 上。同时,不允许走出网格。
只有在可以通过一系列的移动从源方格 $source$ 到达目标方格 $target$ 时才返回 $true$。否则,返回 $false$。
示例 1:
```
输入:blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
输出:false
解释:
从源方格无法到达目标方格,因为我们无法在网格中移动。
无法向北或者向东移动是因为方格禁止通行。
无法向南或者向西移动是因为不能走出网格。
```
示例 2:
```
输入:blocked = [], source = [0,0], target = [999999,999999]
输出:true
解释:
因为没有方格被封锁,所以一定可以到达目标方格。
```
提示:
* $0 <= blocked.length <= 200$
* $blocked[i].length == 2$
* $0 <= xi, yi < 10^6$
* $source.length == target.length == 2$
* $0 <= sx, sy, tx, ty < 10^6$
* $source != target$
* 题目数据保证 $source$ 和 $target$ 不在封锁列表内 | ### BFS + 给定障碍物所能围成的最大面积
为了方便,我们用 $s$ 代指 $source$,用 $t$ 代指 $target$,用 $n$ 来代指 $blocked$ 大小。
整理题意为:在一个足够大的空间里,有少数的障碍物,问两点是否连通。
当两点相隔较远时,常规的 `BFS` 做法可能会搜完整个棋盘,而棋盘大小为 $10^6 \times 10^6$,会 `TLE`。
考虑什么情况下两点会不连通?
当两个点中的任意一点被障碍物围住时,两点将无法连通。
一个很容易想到的思路是:**从 $s$ 跑一遍 `BFS`,然后从 $t$ 跑一遍 `BFS`,同时设定一个最大访问点数量 `MAX`,若从两者出发能够访问的点数量都能超过 `MAX`,说明两点均没有被围住,最终必然会联通。**
考虑如何敲定 `MAX` 的取值范围?直观感受,`MAX` 应该是一个与 $blocked$ 大小相关的数。
但第一反应还是想从单秒计算量上界进行反推,两边 `BFS` 的复杂度均为 $O(\max)$,因此直接设定 `MAX = 1e5` 应该是比较合适的。
更小的 `MAX` 需要证明:**在给定数量障碍物的前提下,障碍物所能围成的最大面积为多少。**
首先,容易想到:**任何一条封闭图形的直边都可以通过调整为斜边来围成更大的面积:**
**即组成封闭图形的边不可能有直边,同时由于是封闭图形,因此斜边直接必然是单点衔接,而不可能是平行(无法封闭)。**
同时,**想要达到最大面积,应当尽可能利用边界作为围成图形的某些边。**
利用边界所能围成的最大封面图形 **可以是**「由边界提供两边,障碍物提供一边的三角形」。
如果不是该形状,则可以通过调整障碍物的直边为一条完整的斜边,来组成封闭三角形,围成面积不会变小:
即给定 $n$ 的情况下,根据「等差数列求和」可知,最大所能围成的面积为 $1 + 2 + ... + n - 1 = \frac{n \times (n - 1)}{2}$。
因此如果从 $s$ 和 $t$ 出发,能够访问的点数超过 $\frac{n \times (n - 1)}{2}$ 个,那么两点并没有被围住,必然联通。
最后,为了在 `BFS` 过程中记录某些点被访问过,可以通过计算某个位置哈希值(数值)来实现。
**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 和 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
int EDGE = (int)1e6, MAX = (int)1e5;
long BASE = 131L;
Set<Long> set = new HashSet<>();
int[][] dir = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
public boolean isEscapePossible(int[][] blocked, int[] s, int[] t) {
for (int[] p : blocked) set.add(p[0] * BASE + p[1]);
int n = blocked.length;
MAX = n * (n - 1) / 2; // 可直接使用 1e5
return check(s, t) && check(t, s);
}
boolean check(int[] a, int[] b) {
Set<Long> vis = new HashSet<>();
Deque<int[]> d = new ArrayDeque<>();
d.addLast(a);
vis.add(a[0] * BASE + a[1]);
while (!d.isEmpty() && vis.size() <= MAX) {
int[] poll = d.pollFirst();
int x = poll[0], y = poll[1];
if (x == b[0] && y == b[1]) return true;
for (int[] di : dir) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= EDGE || ny < 0 || ny >= EDGE) continue;
long hash = nx * BASE + ny;
if (set.contains(hash)) continue;
if (vis.contains(hash)) continue;
d.addLast(new int[]{nx, ny});
vis.add(hash);
}
}
return vis.size() > MAX;
}
}
```
-
```C++
class Solution {
public:
int EDGE = 1e6, MAX = 1e5;
long long BASE = 13331;
unordered_set<long long> set;
int dir[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
bool isEscapePossible(vector<vector<int>>& blocked, vector<int>& s, vector<int>& t) {
for(auto& p : blocked) set.insert(p[0] * BASE + p[1]);
int n = blocked.size();
MAX = n * (n - 1) / 2; // 可直接使用 1e5
return check(s, t) and check(t, s);
}
bool check(vector<int>& a, vector<int>& b){
unordered_set<long long> vis;
queue< pair<int,int> > q;
q.push( {a[0], a[1]});
vis.insert(a[0] * BASE + a[1]);
while(q.size() and vis.size() <= MAX){
auto t = q.front();
q.pop();
int x = t.first, y = t.second;
if(x == b[0] and y == b[1]) return true;
for(int i = 0; i < 4; i++){
int nx = x + dir[i][0], ny = y + dir[i][1];
if(nx < 0 or nx >= EDGE or ny < 0 or ny >= EDGE) continue;
if(set.count(nx * BASE + ny)) continue;
if(vis.count(nx * BASE + ny)) continue;
q.push( {nx, ny} );
vis.insert(nx * BASE + ny);
}
}
return vis.size() > MAX;
}
};
```
-
```Python
EDGE, MAX, BASE, DIR = int(1e6), int(1e5), 131, [(1, 0), (-1, 0), (0, 1), (0, -1)]
class Solution:
def isEscapePossible(self, blocked: List[List[int]], source: List[int], target: List[int]) -> bool:
block = {p[0] * BASE + p[1] for p in blocked}
n = len(blocked)
MAX = n * (n-1)//2 # 可直接使用 1e5
def check(a, b):
vis = {a[0] * BASE + a[1]}
d = deque([a])
while len(d) and len(vis) <= MAX:
x, y = d.popleft()
if x == b[0] and y == b[1]:
return True
for dx, dy in DIR:
nx, ny = x + dx, y + dy
if nx < 0 or nx >= EDGE or ny < 0 or ny >= EDGE:
continue
h = nx * BASE + ny
if h in block or h in vis:
continue
d.append((nx, ny))
vis.add(h)
return len(vis) > MAX
return check(source, target) and check(target, source)
```
* 时间复杂度:令 $n$ 为 $blocked$ 大小,两次 `BFS` 的最大访问点数为 $\frac{n \times (n - 1)}{2}$。整体复杂度为 $O(n^2)$
* 空间复杂度:两次 `BFS` 的最大访问点数为 $\frac{n \times (n - 1)}{2}$。整体复杂度为 $O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1036` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1037. 有效的回旋镖（简单）.md | 1037. 有效的回旋镖 | https://leetcode.cn/problems/valid-boomerang/solution/by-ac_oier-eory/ | 简单 | [
"计算几何",
"数学"
] | 给定一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点,如果这些点构成一个 回旋镖 则返回 `true`。
回旋镖 定义为一组三个点,这些点 各不相同 且 不在一条直线上 。
示例 1:
```
输入:points = [[1,1],[2,3],[3,2]]
输出:true
```
示例 2:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:false
```
提示:
* $points.length == 3$
* $points[i].length == 2$
* $0 <= x_i, y_i <= 100$ | ### 计算几何
共三个点,分别使用两个点计算向量,随后判断向量叉积是否为 $0$。
代码:
```Java
class Solution {
public boolean isBoomerang(int[][] ps) {
return (ps[1][0] - ps[0][0]) * (ps[2][1] - ps[0][1]) != (ps[2][0] - ps[0][0]) * (ps[1][1] - ps[0][1]);
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1037` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1038. 从二叉搜索树到更大和树（中等）.md | 1038. 从二叉搜索树到更大和树 | https://leetcode.cn/problems/binary-search-tree-to-greater-sum-tree/solutions/2552959/gong-shui-san-xie-bst-de-zhong-xu-bian-l-vtu1/ | 中等 | [
"BST",
"中序遍历"
] | 给定一个二叉搜索树 `root` (BST),请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。
提醒一下, 二叉搜索树满足下列约束条件:
* 节点的左子树仅包含键小于节点键的节点。
* 节点的右子树仅包含键大于节点键的节点。
* 左右子树也必须是二叉搜索树。
示例 1:
```
输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
```
示例 2:
```
输入:root = [0,null,1]
输出:[1,null,1]
```
提示:
* 树中的节点数在 $[1, 100]$ 范围内。
* $0 <= Node.val <= 100$
* 树中的所有值均不重复 。 | ### 中序遍历
利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。
首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。
假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。
这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。
Java 代码:
```Java
class Solution {
int tot = 0;
public TreeNode bstToGst(TreeNode root) {
dfs(root);
return root;
}
void dfs(TreeNode root) {
if (root == null) return ;
dfs(root.right);
tot += root.val;
root.val = tot;
dfs(root.left);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int tot = 0;
TreeNode* bstToGst(TreeNode* root) {
dfs(root);
return root;
}
void dfs(TreeNode* root) {
if (root == nullptr) return;
dfs(root->right);
tot += root->val;
root->val = tot;
dfs(root->left);
}
};
```
Python 代码:
```Python
class Solution:
def bstToGst(self, root: TreeNode) -> TreeNode:
tot = 0
def dfs(root):
nonlocal tot
if not root: return
dfs(root.right)
tot += root.val
root.val = tot
dfs(root.left)
dfs(root)
return root
```
TypeScript 代码:
```TypeScript
function bstToGst(root: TreeNode | null): TreeNode | null {
let tot = 0;
const dfs = function(root: TreeNode | null): void {
if (!root) return ;
dfs(root.right);
tot += root.val;
root.val = tot;
dfs(root.left);
}
dfs(root);
return root;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1041. 困于环中的机器人（中等）.md | 1041. 困于环中的机器人 | https://leetcode.cn/problems/robot-bounded-in-circle/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hgdtp/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 在无限的平面上,机器人最初位于 $(0, 0)$ 处,面朝北方。注意:
* 北方向 是 `y` 轴的正方向。
* 南方向 是 `y` 轴的负方向。
* 东方向 是 `x` 轴的正方向。
* 西方向 是 `x` 轴的负方向。
机器人可以接受下列三条指令之一:
* `"G"`:直走 $1$ 个单位
* `"L"`:左转 $90$ 度
* `"R"`:右转 $90$ 度
机器人按顺序执行指令 `instructions`,并一直重复它们。
只有在平面中存在环使得机器人永远无法离开时,返回 `true`。否则,返回 `false`。
示例 1:
```
输入:instructions = "GGLLGG"
输出:true
解释:机器人最初在(0,0)处,面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“G”:移动一步。位置:(0,2).方向:北。
“L”:逆时针旋转90度。位置:(0,2).方向:西。
“L”:逆时针旋转90度。位置:(0,2)方向:南。
“G”:移动一步。位置:(0,1)方向:南。
“G”:移动一步。位置:(0,0)方向:南。
重复指令,机器人进入循环:(0,0)——>(0,1)——>(0,2)——>(0,1)——>(0,0)。
在此基础上,我们返回true。
```
示例 2:
```
输入:instructions = "GG"
输出:false
解释:机器人最初在(0,0)处,面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“G”:移动一步。位置:(0,2).方向:北。
重复这些指示,继续朝北前进,不会进入循环。
在此基础上,返回false。
```
示例 3:
```
输入:instructions = "GL"
输出:true
解释:机器人最初在(0,0)处,面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“L”:逆时针旋转90度。位置:(0,1).方向:西。
“G”:移动一步。位置:(- 1,1)方向:西。
“L”:逆时针旋转90度。位置:(- 1,1)方向:南。
“G”:移动一步。位置:(- 1,0)方向:南。
“L”:逆时针旋转90度。位置:(- 1,0)方向:东方。
“G”:移动一步。位置:(0,0)方向:东方。
“L”:逆时针旋转90度。位置:(0,0)方向:北。
重复指令,机器人进入循环:(0,0)——>(0,1)——>(- 1,1)——>(- 1,0)——>(0,0)。
在此基础上,我们返回true。
```
提示:
* $1 <= instructions.length <= 100$
* `instructions[i]` 仅包含 `'G'`, `'L'`, `'R'` | ### 模拟
为了方便,将 `instructions` 记为 `s`,“北西南东”四个方向分别记为“上左下右”四个逆时针方向。
起始位置在 $(0,0)$,方向为上,我们可以将「位置 + 方向」统称为「状态」。
所谓“循环”,则是指执行若干次的 `s` 后,会回到相同的状态。
我们可以按 `s` 执行一遍,假设执行完所在位置为 $(x, y)$,所在位置为 $k$,先根据 **位置** 分情况讨论:
1. $(x, y)$ 为 $(0, 0)$,此时无论执行一遍后的方向为何值,必然能在若干次执行后回到起始状态。
即只需要确保 `(n * k) % 4` 为 $0$ 即可,机器人会陷入循环;
2. $(x, y)$ 不为 $(0, 0)$,再根据 **方向** 进一步分情况讨论:
* 方向为上:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向不变。
那么执行 $n$ 遍后位置为 $(n \times x, n \times y)$,其中 $n$ 为正整数,并且 $x$ 和 $y$ 不同时为 $0$,因此随着执行次数增加,位置会离 $(0, 0)$ 越来越远,机器人不会陷入循环;
* 方向为下:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向翻转。
如果再执行一遍,由于再次执行时的方向与起始方向相反,因此位置变化为 $(-x, -y)$,同时方向再次翻转(与起始方向一致)。即执行偶数次后,会回到起始状态,机器人会陷入循环;
* 方向为左:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向为逆时针 $90$ 度。
如果执行第二次,位置变化为 $(-y, x)$,方向再逆时针 $90$ 度(与起始方向相反);执行第三次,位置变化为 $(-x, -y)$,方向再逆时针 $90$ 度(与起始方向呈顺时针 $90$ 度),该次变化会和首次执行相互抵消;执行第四次,位置变化为 $(y, -x)$,方向再逆时针 $90$ 度(与起始方向相同),该次变化与第二次执行相互抵消。总的位置变化为 $(0, 0)$,同时方向与起始方向一致,机器人会陷入循环;
* 方向为右:与「方向为左」同理,机器人会陷入循环。
综上,只要执行一遍 `s` 后所在位置为 $(0, 0)$ 或方向不为上,均可确保循环发生。
Java 代码:
```Java
class Solution {
public boolean isRobotBounded(String s) {
int x = 0, y = 0, d = 0;
int[][] dirs = new int[][]{{0,1}, {-1,0}, {0,-1}, {1,0}};
for (char c : s.toCharArray()) {
if (c == 'G') {
x += dirs[d][0]; y += dirs[d][1];
} else if (c == 'L') {
d = (d + 1) % 4;
} else {
d = ((d - 1) % 4 + 4) % 4;
}
}
return (x == 0 && y == 0) || d != 0;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isRobotBounded(string s) {
int x = 0, y = 0, d = 0;
int dirs[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
for (char c : s) {
if (c == 'G') {
x += dirs[d][0]; y += dirs[d][1];
} else if (c == 'L') {
d = (d + 1) % 4;
} else {
d = ((d - 1) % 4 + 4) % 4;
}
}
return (x == 0 && y == 0) || d != 0;
}
};
```
Python 代码:
```Python
class Solution:
def isRobotBounded(self, s: str) -> bool:
x, y, d = 0, 0, 0
dirs = [[0, 1], [-1, 0], [0, -1], [1, 0]]
for c in s:
if c == 'G':
x += dirs[d][0]
y += dirs[d][1]
elif c == 'L':
d = (d + 1) % 4
else:
d = ((d - 1) % 4 + 4) % 4
return (x == 0 and y == 0) or d != 0
```
Go 代码:
```Go
func isRobotBounded(s string) bool {
x, y, d := 0, 0, 0
dirs := [][]int{{0, 1}, {-1, 0}, {0, -1}, {1, 0}}
for _, c := range s {
if c == 'G' {
x += dirs[d][0]
y += dirs[d][1]
} else if c == 'L' {
d = (d + 1) % 4
} else {
d = ((d - 1) % 4 + 4) % 4
}
}
return (x == 0 && y == 0) || d != 0
}
```
TypeScript 代码:
```TypeScript
function isRobotBounded(s: string): boolean {
let x = 0, y = 0, d = 0;
const dirs: number[][] = [[0, 1], [-1, 0], [0, -1], [1, 0]];
for (const c of s) {
if (c === 'G') {
x += dirs[d][0];
y += dirs[d][1];
} else if (c === 'L') {
d = (d + 1) % 4;
} else {
d = ((d - 1) % 4 + 4) % 4;
}
}
return (x === 0 && y === 0) || d !== 0;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1044. 最长重复子串（困难）.md | 1044. 最长重复子串 | https://leetcode-cn.com/problems/longest-duplicate-substring/solution/gong-shui-san-xie-zi-fu-chuan-ha-xi-ying-hae9/ | 困难 | [
"字符串哈希",
"二分",
"后缀数组"
] | 给你一个字符串 `s` ,考虑其所有 重复子串 :即 `s` 的连续子串,在 `s` 中出现 $2$ 次或更多次。这些出现之间可能存在重叠。
返回 任意一个 可能具有最长长度的重复子串。如果 `s` 不含重复子串,那么答案为 `""` 。
示例 1:
```
输入:s = "banana"
输出:"ana"
```
示例 2:
```
输入:s = "abcd"
输出:""
```
提示:
* $2 <= s.length <= 3 * 10^4$
* `s` 由小写英文字母组成 | ### 字符串哈希 + 二分
题目要求得「能取得最大长度的任一方案」,首先以「最大长度」为分割点的数轴具有「二段性」:
* 小于等于最大长度方案均存在(考虑在最大长度方案上做删减);
* 大于最大长度的方案不存在。
二分范围为 $[0, n]$,关键在于如何 `check` 函数,即实现「检查某个长度 $len$ 作为最大长度,是否存在合法方案」。
对于常规做法而言,可枚举每个位置作为起点,得到长度为 $len$ 的子串,同时使用 `Set<String>` 容器记录已被处理过子串有哪些,当容器中出现过当前子串,说明存在合法方案。
但是该做法实现的 `check` 并非线性,子串的生成和存入容器的时执行的哈希函数执行均和子串长度相关,复杂度是 $O(n * len)$。
我们可以通过「字符串哈希」进行优化,对「字符串哈希」不熟悉的同学可以看前置 🧀 [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660&chksm=fd9cb20acaeb3b1cc78abf05d6fea6d093098998ce877f799ac478247604bd267fbee6fcd989&token=1342991619&lang=zh_CN#rd)。
具体的,在二分前先通过 $O(n)$ 的复杂度预处理出哈希数组,从而确保能够在 `check` 时能够 $O(1)$ 得到某个子串的哈希值,最终将 `check` 的复杂度降为 $O(n)$。
代码:
```Java
class Solution {
long[] h, p;
public String longestDupSubstring(String s) {
int P = 1313131, n = s.length();
h = new long[n + 10]; p = new long[n + 10];
p[0] = 1;
for (int i = 0; i < n; i++) {
p[i + 1] = p[i] * P;
h[i + 1] = h[i] * P + s.charAt(i);
}
String ans = "";
int l = 0, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
String t = check(s, mid);
if (t.length() != 0) l = mid;
else r = mid - 1;
ans = t.length() > ans.length() ? t : ans;
}
return ans;
}
String check(String s, int len) {
int n = s.length();
Set<Long> set = new HashSet<>();
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
long cur = h[j] - h[i - 1] * p[j - i + 1];
if (set.contains(cur)) return s.substring(i - 1, j);
set.add(cur);
}
return "";
}
}
```
* 时间复杂度:令 $n$ 为字符串 `s` 的长度,预处理出哈希数组的复杂度为 $O(n)$;二分最大长度的复杂度为 $O(n\log{n})$;整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 后缀数组
另外一个较为进阶的做法是使用「后缀数组」,后缀数组有基于基数排序的倍增实现,复杂度为 $O(n\log{n})$,也有基于 `DC3` 的 $O(n)$ 做法。
`DC3` 的做法已经写不出来了,写一个基于「基数排序」的倍增做法。
后缀数组包含几个核心数组:
* `sa` 数组:字典序排名为 $i$ 的后缀是第几个;
* `rk` 数组:第 $i$ 个后缀的排名是多少(不难发现 `rk` 与 `sa` 满足 $sa[rk[i]] = rk[sa[i]] = i$);
* `height` 数组:存储 $sa[i]$ 与 $sa[i - 1]$ 的 `LCP(最长公共前缀)` 为何值。
代码:
```Java
class Solution {
int N = 30010;
int[] x = new int[N], y = new int[N], c = new int[N];
int[] sa = new int[N], rk = new int[N], height = new int[N];
void swap(int[] a, int[] b) {
int n = a.length;
int[] c = a.clone();
for (int i = 0; i < n; i++) a[i] = b[i];
for (int i = 0; i < n; i++) b[i] = c[i];
}
public String longestDupSubstring(String s) {
int n = s.length(), m = 128;
s = " " + s;
char[] cs = s.toCharArray();
// sa:两遍基数排序,板子背不下来也可以直接使用 sort,复杂度退化到 n \log^2 n
for (int i = 1; i <= n; i++) {
x[i] = cs[i]; c[x[i]]++;
}
for (int i = 2; i <= m; i++) c[i] += c[i - 1];
for (int i = n; i > 0; i--) sa[c[x[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int cur = 0;
for (int i = n - k + 1; i <= n; i++) y[++cur] = i;
for (int i = 1; i <= n; i ++) {
if (sa[i] > k) y[++cur] = sa[i] - k;
}
for (int i = 1; i <= m; i++) c[i] = 0;
for (int i = 1; i <= n; i++) c[x[i]]++;
for (int i = 2; i <= m; i++) c[i] += c[i - 1];
for (int i = n; i > 0; i--) {
sa[c[x[y[i]]]--] = y[i];
y[i] = 0;
}
swap(x, y);
x[sa[1]] = cur = 1;
for (int i = 2; i <= n; i++) {
if (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) x[sa[i]] = cur;
else x[sa[i]] = ++cur;
}
if (cur == n) break;
m = cur;
}
// height
int k = 0;
for (int i = 1; i <= n; i ++) rk[sa[i]] = i;
for (int i = 1; i <= n; i++) {
if (rk[i] == 1) continue;
int j = sa[rk[i] - 1];
k = k > 0 ? k - 1 : k;
while (i + k <= n && j + k <= n && cs[i + k] == cs[j + k]) k++;
height[rk[i]] = k;
}
int idx = -1, max = 0;
for (int i = 1; i <= n; i++) {
if (height[i] > max) {
max = height[i];
idx = sa[i];
}
}
return max == 0 ? "" : s.substring(idx, idx + max);
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1047. 删除字符串中的所有相邻重复项（简单）.md | 1047. 删除字符串中的所有相邻重复项 | https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/solution/cong-30-dao-100wu-chong-shi-xian-jie-jue-vkah/ | 简单 | [
"队列",
"模拟"
] | 给出由小写字母组成的字符串 S,重复项删除操作会选择两个相邻且相同的字母,并删除它们。
在 S 上反复执行重复项删除操作,直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例:
```
输入:"abbaca"
输出:"ca"
解释:
例如,在 "abbaca" 中,我们可以删除 "bb" 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca",其中又只有 "aa" 可以执行重复项删除操作,所以最后的字符串为 "ca"。
```
提示:
* 1 <= S.length <= 20000
* S 仅由小写英文字母组成。 | ### (自带) 栈解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
Deque<Character> d = new ArrayDeque<>();
for (char c : cs) {
if (!d.isEmpty() && d.peekLast().equals(c)) {
d.pollLast();
} else {
d.addLast(c);
}
}
StringBuilder sb = new StringBuilder();
while (!d.isEmpty()) sb.append(d.pollLast());
sb.reverse();
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### (数组模拟) 栈解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
char[] d = new char[s.length()];
int hh = 0, tt = -1;
for (char c : cs) {
if (hh <= tt && d[tt] == c) {
tt--;
} else {
d[++tt] = c;
}
}
StringBuilder sb = new StringBuilder();
while (hh <= tt) sb.append(d[tt--]);
sb.reverse();
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### (自带) 双端队列解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
Deque<Character> d = new ArrayDeque<>();
for (char c : cs) {
if (!d.isEmpty() && d.peekLast().equals(c)) {
d.pollLast();
} else {
d.addLast(c);
}
}
StringBuilder sb = new StringBuilder();
while (!d.isEmpty()) sb.append(d.pollFirst());
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### (数组模拟) 双端队列解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
char[] d = new char[s.length()];
int hh = 0, tt = -1;
for (char c : cs) {
if (hh <= tt && d[tt] == c) {
tt--;
} else {
d[++tt] = c;
}
}
StringBuilder sb = new StringBuilder();
while (hh <= tt) sb.append(d[hh++]);
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 纯数组解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
char[] d = new char[s.length()];
int hh = 0, tt = -1;
for (char c : cs) {
if (hh <= tt && d[tt] == c) {
tt--;
} else {
d[++tt] = c;
}
}
return new String(d, 0, tt + 1);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1049. 最后一块石头的重量 II（中等）.md | 1049. 最后一块石头的重量 II | https://leetcode-cn.com/problems/last-stone-weight-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-neng-jgxik/ | 中等 | [
"动态规划",
"背包问题",
"01 背包",
"数学"
] | 有一堆石头,用整数数组 `stones` 表示。
其中 `stones[i]` 表示第 `i` 块石头的重量。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 `x` 和 `y`,且 `x <= y`。那么粉碎的可能结果如下:
* 如果 `x == y`,那么两块石头都会被完全粉碎;
* 如果 `x != y`,那么重量为 `x` 的石头将会完全粉碎,而重量为 `y` 的石头新重量为 `y-x`。
最后,最多只会剩下一块 石头。返回此石头最小的可能重量 。
如果没有石头剩下,就返回 `0`。
示例 1:
```
输入:stones = [2,7,4,1,8,1]
输出:1
解释:
组合 2 和 4,得到 2,所以数组转化为 [2,7,1,8,1],
组合 7 和 8,得到 1,所以数组转化为 [2,1,1,1],
组合 2 和 1,得到 1,所以数组转化为 [1,1,1],
组合 1 和 1,得到 0,所以数组转化为 [1],这就是最优值。
```
示例 2:
```
输入:stones = [31,26,33,21,40]
输出:5
```
示例 3:
```
输入:stones = [1,2]
输出:1
```
提示:
* $1 <= stones.length <= 30$
* $1 <= stones[i] <= 100$ | ### 基本分析
看到标题,心里咯噔了一下 🤣
一般性的石子合并问题通常是只能操作相邻的两个石子,要么是「区间 DP」要么是「四边形不等式」,怎么到 LeetCode 就成了中等难度的题目(也太卷了 🤣
仔细看了一下题目,可对任意石子进行操作,重放回的重量也不是操作石子的总和,而是操作石子的差值。
哦,那没事了 ~ 🤣
也是基于此启发,我们可以这样进行分析。
假设想要得到最优解,我们需要按照如下顺序操作石子:$[(sa, sb), (sc, sd), ... ,(si, sj), (sp, sq)]$。
其中 $abcdijpq$ 代表了石子编号,**字母顺序不代表编号的大小关系**。
**如果不考虑「有放回」的操作的话,我们可以划分为两个石子堆(正号堆/负号堆):**
* **将每次操作中「重量较大」的石子放到「正号堆」,代表在这次操作中该石子重量在「最终运算结果」中应用 $+$ 运算符**
* **将每次操作中「重量较少/相等」的石子放到「负号堆」,代表在这次操作中该石子重量在「最终运算结果」中应用 $-$ 运算符**
**这意味我们最终得到的结果,可以为原来 $stones$ 数组中的数字添加 $+/-$ 符号,所形成的「计算表达式」所表示。**
那有放回的石子重量如何考虑?
**其实所谓的「有放回」操作,只是触发调整「某个原有石子」所在「哪个堆」中,并不会真正意义上的产生「新的石子重量」。**
什么意思呢?
假设有起始石子 $a$ 和 $b$,且两者重量关系为 $a \geq b$,那么首先会将 $a$ 放入「正号堆」,将 $b$ 放入「负号堆」。重放回操作可以看作产生一个新的重量为 $a - b$ 的“虚拟石子”,将来这个“虚拟石子”也会参与某次合并操作,也会被添加 $+/-$ 符号:
* 当对“虚拟石子”添加 $+$ 符号,即可 $+(a - b)$,展开后为 $a - b$,即起始石子 $a$ 和 $b$ 所在「石子堆」不变
* 当对“虚拟石子”添加 $-$ 符号,即可 $-(a - b)$,展开后为 $b - a$,即起始石子 $a$ 和 $b$ 所在「石子堆」交换
**因此所谓不断「合并」&「重放」,本质只是在构造一个折叠的计算表达式,最终都能展开扁平化为非折叠的计算表达式。**
**综上,即使是包含「有放回」操作,最终的结果仍然可以使用「为原来 $stones$ 数组中的数字添加 $+/-$ 符号,形成的“计算表达式”」所表示。**
---
### 动态规划
有了上述分析后,问题转换为:**为 $stones$ 中的每个数字添加 $+/-$,使得形成的「计算表达式」结果绝对值最小。**
与[(题解)494. 目标和](https://leetcode-cn.com/problems/target-sum/solution/gong-shui-san-xie-yi-ti-si-jie-dfs-ji-yi-et5b/) 类似,需要考虑正负号两边时,其实只需要考虑一边就可以了,使用总和 $sum$ 减去决策出来的结果,就能得到另外一边的结果。
同时,由于想要「计算表达式」结果绝对值,因此我们需要将石子划分为差值最小的两个堆。
其实就是对「计算表达式」中带 $-$ 的数值提取公因数 $-1$,进一步转换为两堆石子相减总和,绝对值最小。
这就将问题彻底切换为 01 背包问题:**从 $stones$ 数组中选择,凑成总和不超过 $\frac{sum}{2}$ 的最大价值。**
其中「成本」&「价值」均为数值本身。
整理一下:
定义 $f[i][j]$ 代表考虑前 $i$ 个物品(数值),凑成总和不超过 $j$ 的最大价值。
每个物品都有「选」和「不选」两种决策,转移方程为:
$$f[i][j] = \max(f[i - 1][j], f[i - 1][j - stones[i - 1]] + stones[i - 1])$$
与完全背包不同,01 背包的几种空间优化是不存在时间复杂度上的优化,因此写成 朴素二维、滚动数组、一维优化 都可以。
建议直接上手写「一维空间优化」版本,是其他背包问题的基础。
代码:
```Java
class Solution {
public int lastStoneWeightII(int[] ss) {
int n = ss.length;
int sum = 0;
for (int i : ss) sum += i;
int t = sum / 2;
int[][] f = new int[n + 1][t + 1];
for (int i = 1; i <= n; i++) {
int x = ss[i - 1];
for (int j = 0; j <= t; j++) {
f[i][j] = f[i - 1][j];
if (j >= x) f[i][j] = Math.max(f[i][j], f[i - 1][j - x] + x);
}
}
return Math.abs(sum - f[n][t] - f[n][t]);
}
}
```
```Java
class Solution {
public int lastStoneWeightII(int[] ss) {
int n = ss.length;
int sum = 0;
for (int i : ss) sum += i;
int t = sum / 2;
int[][] f = new int[2][t + 1];
for (int i = 1; i <= n; i++) {
int x = ss[i - 1];
int a = i & 1, b = (i - 1) & 1;
for (int j = 0; j <= t; j++) {
f[a][j] = f[b][j];
if (j >= x) f[a][j] = Math.max(f[a][j], f[b][j - x] + x);
}
}
return Math.abs(sum - f[n&1][t] - f[n&1][t]);
}
}
```
```Java
class Solution {
public int lastStoneWeightII(int[] ss) {
int n = ss.length;
int sum = 0;
for (int i : ss) sum += i;
int t = sum / 2;
int[] f = new int[t + 1];
for (int i = 1; i <= n; i++) {
int x = ss[i - 1];
for (int j = t; j >= x; j--) {
f[j] = Math.max(f[j], f[j - x] + x);
}
}
return Math.abs(sum - f[t] - f[t]);
}
}
```
* 时间复杂度:$O(n \times \sum_{i = 0}^{n - 1} stones[i])$
* 空间复杂度:$O(n \times \sum_{i = 0}^{n - 1} stones[i])$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1051-1060/1051. 高度检查器（简单）.md | 1051. 高度检查器 | https://leetcode.cn/problems/height-checker/solution/by-ac_oier-8xoj/ | 简单 | [
"排序",
"模拟"
] | 学校打算为全体学生拍一张年度纪念照。根据要求,学生需要按照 非递减 的高度顺序排成一行。
排序后的高度情况用整数数组 `expected` 表示,其中 `expected[i]` 是预计排在这一行中第 `i` 位的学生的高度(下标从 $0$ 开始)。
给你一个整数数组 `heights`,表示 当前学生站位 的高度情况。`heights[i]` 是这一行中第 `i` 位学生的高度(下标从 $0$ 开始)。
返回满足 `heights[i] != expected[i]` 的 下标数量 。
示例:
```
输入:heights = [1,1,4,2,1,3]
输出:3
解释:
高度:[1,1,4,2,1,3]
预期:[1,1,1,2,3,4]
下标 2 、4 、5 处的学生高度不匹配。
```
示例 2:
```
输入:heights = [5,1,2,3,4]
输出:5
解释:
高度:[5,1,2,3,4]
预期:[1,2,3,4,5]
所有下标的对应学生高度都不匹配。
```
示例 3:
```
输入:heights = [1,2,3,4,5]
输出:0
解释:
高度:[1,2,3,4,5]
预期:[1,2,3,4,5]
所有下标的对应学生高度都匹配。
```
提示:
* $1 <= heights.length <= 100$
* $1 <= heights[i] <= 100$ | ### 排序
先排序得到目标序列,再将目标序列和原序列进行逐一对比,得到答案。
排序部分,可以使用复杂度为 $O(n\log{n})$ 的双轴快排,也可以利用数据范围为 $100$,利用计数排序思想来构建目标序列,复杂度为 $O(C + n)$。
代码(快排 $P1$,计数排序 $P2$):
```Java
class Solution {
public int heightChecker(int[] heights) {
int[] t = heights.clone();
Arrays.sort(t);
int n = heights.length, ans = 0;
for (int i = 0; i < n; i++) {
if (t[i] != heights[i]) ans++;
}
return ans;
}
}
```
-
```Java
class Solution {
public int heightChecker(int[] heights) {
int[] cnts = new int[110];
for (int i : heights) cnts[i]++;
int n = heights.length, ans = 0;
int[] t = new int[n];
for (int i = 0, j = 0; i < 110; i++) {
while (cnts[i]-- > 0) t[j++] = i;
}
for (int i = 0; i < n; i++) {
if (t[i] != heights[i]) ans++;
}
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$(快排)或者为 $O(C + n)$(计数排序),统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$(快排)或 $O(C + n)$(计数排序)
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1051` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1051-1060/1052. 爱生气的书店老板（中等）.md | 1052. 爱生气的书店老板 | https://leetcode-cn.com/problems/grumpy-bookstore-owner/solution/hua-dong-chuang-kou-luo-ti-by-ac_oier-nunu/ | 中等 | [
"滑动窗口",
"双指针"
] | 今天,书店老板有一家店打算试营业 $customers.length$ 分钟。每分钟都有一些顾客($customers[i]$)会进入书店,所有这些顾客都会在那一分钟结束后离开。
在某些时候,书店老板会生气。 如果书店老板在第 $i$ 分钟生气,那么 $grumpy[i] = 1$,否则 $grumpy[i] = 0$。 当书店老板生气时,那一分钟的顾客就会不满意,不生气则他们是满意的。
书店老板知道一个秘密技巧,能抑制自己的情绪,可以让自己连续 $X$ 分钟不生气,但却只能使用一次。
请你返回这一天营业下来,最多有多少客户能够感到满意的数量。
示例:
```
输入:customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3
输出:16
解释:
书店老板在最后 3 分钟保持冷静。
感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.
```
提示:
* $1 <= X <= customers.length == grumpy.length <= 20000$
* $0 <= customers[i] <= 1000$
* $0 <= grumpy[i] <= 1$ | ### 滑动窗口
由于「技巧」只会将情绪将「生气」变为「不生气」,不生气仍然是不生气。
1. 我们可以先将原本就满意的客户加入答案,同时将对应的 $customers[i]$ 变为 $0$。
2. 之后的问题转化为:在 $customers$ 中找到连续一段长度为 $minutes$ 的子数组,使得其总和最大。这部分就是我们应用技巧所得到的客户。
代码:
```Java
class Solution {
public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
int n = customers.length, ans = 0;
for (int i = 0; i < n; i++) {
if (grumpy[i] == 0) {
ans += customers[i];
customers[i] = 0;
}
}
int cur = 0, max = 0;
for (int i = 0; i < n; i++) {
cur += customers[i];
if (i >= minutes) cur -= customers[i - minutes];
max = Math.max(max, cur);
}
return ans + max;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1052` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1071-1080/1074. 元素和为目标值的子矩阵数量（困难）.md | 1074. 元素和为目标值的子矩阵数量 | https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-uttw/ | 困难 | [
"前缀和",
"哈希表"
] | 给出矩阵 matrix 和目标值 target,返回元素总和等于目标值的非空子矩阵的数量。
子矩阵 x1, y1, x2, y2 是满足 x1 <= x <= x2 且 y1 <= y <= y2 的所有单元 matrix[x][y] 的集合。
如果 (x1, y1, x2, y2) 和 (x1', y1', x2', y2') 两个子矩阵中部分坐标不同(如:x1 != x1'),那么这两个子矩阵也不同。
示例 1:
```
输入:matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
输出:4
解释:四个只含 0 的 1x1 子矩阵。
```
示例 2:
```
输入:matrix = [[1,-1],[-1,1]], target = 0
输出:5
解释:两个 1x2 子矩阵,加上两个 2x1 子矩阵,再加上一个 2x2 子矩阵。
```
示例 3:
```
输入:matrix = [[904]], target = 0
输出:0
```
提示:
* 1 <= matrix.length <= 100
* 1 <= matrix[0].length <= 100
* -1000 <= matrix[i] <= 1000
* -$10^8$ <= target <= $10^8$ | ### 朴素二维前缀和
从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。
搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。
因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$。
数据范围是 $10^2$,对应的计算量是 $10^8$,处于超时边缘,但当我们枚举「矩阵右下角」$(i,j)$ 的时候,我们只需要搜索位于 $(i,j)$ 的左上方的点 $(p,q)$ 作为「矩阵左上角」,所以其实我们是取不满 $m^2 * n^2$ 的,但仍然具有超时风险(2021/05/29 Java 测试可通过)。
代码:
```Java
class Solution {
public int numSubmatrixSumTarget(int[][] mat, int t) {
int n = mat.length, m = mat[0].length;
int[][] sum = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int p = 1; p <= i; p++) {
for (int q = 1; q <= j; q++) {
if (sum[i][j] - sum[p - 1][j] - sum[i][q - 1] + sum[p - 1][q - 1] == t) ans++;
}
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(m^2 * n^2)$
* 空间复杂度:$O(m * n)$
---
### 优化枚举 + 哈希表
上述分析是从「点」上来确定一个子矩阵,在 $n$ 和 $m$ 同阶的情况下,复杂度是 $O(n^4)$ 的。
事实上,我们能从「边」的角度来确定一个子矩阵,通过枚举三条边,然后加速找第四条边的过程,这样可以将复杂度降到 $O(n^3)$。
**这个分析思路在 [(题解)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/) 详细讲过,没有印象的同学可以翻翻。这道题一定程度上是那道题的简化版,在本题我们只需要找到矩阵和为 $target$ 的值,因此只需要使用「哈希表」来记录出现过的值即可,而在 [(原题)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/) 中,我们需要找到和不超过 $k$ 的最大子矩阵,因此还涉及「有序集合 + 二分」。**
具体的,我们仍然需要先预处理出一个二维前缀和。**然后通过枚举确定「子矩阵的上下边界」,在将「子矩阵右边界」不断右移的过程中,把「子矩阵右边界」到「原矩阵左边界」行程的矩阵和存入哈希表(因为要统计数量,存储格式为 {"面积”:"出现次数"} ),然后通过容斥原理来找到目标的「子矩阵左边界」。**
假设当前我们「子矩阵的上下边界」已经固定,当枚举到某个「子矩阵右边界」时,我们先通过二维前缀和计算出「子矩阵右边界」和「原矩阵左边界」形成的矩阵和 $cur$,由于我们希望找到矩阵和为 $target$ 的子矩阵,即希望找到一个「子矩阵左边界」使得矩阵和满足要求,这等价于从「哈希表」中找到一个 $x$,使得 $cur - x = target$,这是一个 $O(1)$ 操作。
代码:
```Java
class Solution {
public int numSubmatrixSumTarget(int[][] mat, int t) {
int n = mat.length, m = mat[0].length;
int[][] sum = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];
}
}
int ans = 0;
for (int top = 1; top <= n; top++) {
for (int bot = top; bot <= n; bot++) {
int cur = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int r = 1; r <= m; r++) {
cur = sum[bot][r] - sum[top - 1][r];
if (cur == t) ans++;
if (map.containsKey(cur - t)) ans += map.get(cur - t);
map.put(cur, map.getOrDefault(cur, 0) + 1);
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(m * n^2)$
* 空间复杂度:$O(m * n)$
---
### 进阶
1. 【时间复杂度】在上述解法中,我们采用的是**固定上下边界,移动右边界,通过哈希表找左边界**的做法,复杂度为 $O(m * n^2)$;自然也能改为**固定左右边界,移动下边界,通过哈希表找上边界**做法,复杂度为 $O(m^2 * n)$。那么我们要如何调整代码,才能最大化「哈希表」带来的优化效果呢?此时的复杂度又是多少?
2. 【空间复杂度】我们空间复杂度的瓶颈在「二维前缀和」上,但注意到无论我们采取「固定上下边界」还是「固定左右边界」的做法,扫描原矩阵的方向都是固定的,那么是否可以不预处理「二维前缀和」呢?从而将空间复杂度降低到 $O(\max(n, m))$ 呢?
上述两问,你都可以在 [(题解)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/) 中找到答案。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1074` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1071-1080/1078. Bigram 分词（简单）.md | 1078. Bigram 分词 | https://leetcode-cn.com/problems/occurrences-after-bigram/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-qyki/ | 简单 | [
"模拟"
] | 给出第一个词 `first` 和第二个词 `second`,考虑在某些文本 `text` 中可能以 `"first second third"` 形式出现的情况,其中 `second` 紧随 `first` 出现,`third` 紧随 `second` 出现。
对于每种这样的情况,将第三个词 `"third"` 添加到答案中,并返回答案。
示例 1:
```
输入:text = "alice is a good girl she is a good student", first = "a", second = "good"
输出:["girl","student"]
```
示例 2:
```
输入:text = "we will we will rock you", first = "we", second = "will"
输出:["we","rock"]
```
提示:
* $1 <= text.length <= 1000$
* `text` 由小写英文字母和空格组成
* `text` 中的所有单词之间都由 单个空格字符 分隔
* $1 <= first.length, second.length <= 10$
* `first` 和 `second` 由小写英文字母组成 | ### 模拟
好像每次起晚都是简单题?🤣
根据题意进行模拟。
代码:
```Java
class Solution {
public String[] findOcurrences(String text, String a, String b) {
String[] ss = text.split(" ");
int n = ss.length;
List<String> list = new ArrayList<>();
for (int i = 0; i + 2 < n; i++) {
if (ss[i].equals(a) && ss[i + 1].equals(b)) list.add(ss[i + 2]);
}
return list.toArray(new String[list.size()]);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1078` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1081-1090/1089. 复写零（简单）.md | 1089. 复写零 | https://leetcode.cn/problems/duplicate-zeros/solution/by-ac_oier-zivq/ | 简单 | [
"双指针"
] | 给你一个长度固定的整数数组 `arr`,请你将该数组中出现的每个零都复写一遍,并将其余的元素向右平移。
注意:请不要在超过该数组长度的位置写入元素。
要求:请对输入的数组 就地 进行上述修改,不要从函数返回任何东西。
示例 1:
```
输入:[1,0,2,3,0,4,5,0]
输出:null
解释:调用函数后,输入的数组将被修改为:[1,0,0,2,3,0,0,4]
```
示例 2:
```
输入:[1,2,3]
输出:null
解释:调用函数后,输入的数组将被修改为:[1,2,3]
```
提示:
* $1 <= arr.length <= 10000$
* $0 <= arr[i] <= 9$ | ### 双指针
这道题挺有意思的,建议大家在看文字的同时,在纸上推导一遍。
我们可以假设已经通过原数组 `arr` 处理出最终的目标数组 `ans`,起始使用指针 $i$ 指向原数组的开头位置,使用指针 $j$ 指向目标数组的开头位置。
然后开始同时从前往后处理,默认情况下,两个指针每次往后移动一位,当在原数组中出现 $arr[i] = 0$ 时,根据题意,我们需要在目标数组 $ans[j]$ 后面复写多一位,因此此时让 $j$ 多走一位。
当 $j$ 走到的位置已超出数组长度,此时 $i$ 也停在了该被截断的位置的下一位。
此时我们先将 $i$ 和 $j$ 同时往回走一步,确保 $i$ 落在真正的截断后的位置,但需要注意,由于 $j$ 在之前的往前走逻辑中可能会走两步,因此 $j$ 在往回走一步后仍可能在数组以外的位置。
然后考虑如何在 $i$ 和 $j$ 所在位置开始「往回」赋值:每次将 $arr[i]$ 赋值给 $arr[j]$(需要确保 $j$ 下标合法),由于 $i$ 必然不会出现在 $j$ 的后面(即不会出现 $j < i$),因此不会出现值被提前覆盖的问题。因此通常情况下,我们可以不断的同时减少 $i$ 和 $j$,并将 $arr[i]$ 赋值给 $arr[j]$。当出现 $arr[i] = 0$ 时,我们需要额外让 $j$ 往前多走一步,并将该位置置为 $0$,来实现目标数组「复写零」的效果。
当 $i$ 指针越过开头的位置,说明已完成从 `arr` 到 `ans` 的转换。
> 这个往回赋值的过程,十分建议大家在纸上推导一遍。
代码:
```Java
class Solution {
public void duplicateZeros(int[] arr) {
int n = arr.length, i = 0, j = 0;
while (j < n) {
if (arr[i] == 0) j++;
i++; j++;
}
i--; j--;
while (i >= 0) {
if (j < n) arr[j] = arr[i];
if (arr[i] == 0 && --j >= 0) arr[j] = 0;
i--; j--;
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1089` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1091-1100/1092. 最短公共超序列（困难）.md | 1092. 最短公共超序列 | https://leetcode.cn/problems/shortest-common-supersequence/solution/by-ac_oier-s346/ | 困难 | [
"序列 DP",
"LCS",
"最长公共子序列",
"动态规划",
"构造",
"双指针"
] | 给出两个字符串 `str1` 和 `str2`,返回同时以 `str1` 和 `str2` 作为子序列的最短字符串。如果答案不止一个,则可以返回满足条件的任意一个答案。
(如果从字符串 `T` 中删除一些字符(也可能不删除,并且选出的这些字符可以位于 `T` 中的 任意位置),可以得到字符串 `S`,那么 `S` 就是 `T` 的子序列)
示例:
```
输入:str1 = "abac", str2 = "cab"
输出:"cabac"
解释:
str1 = "abac" 是 "cabac" 的一个子串,因为我们可以删去 "cabac" 的第一个 "c"得到 "abac"。
str2 = "cab" 是 "cabac" 的一个子串,因为我们可以删去 "cabac" 末尾的 "ac" 得到 "cab"。
最终我们给出的答案是满足上述属性的最短字符串。
```
提示:
* $1 <= str1.length, str2.length <= 1000$
* `str1` 和 `str2` 都由小写英文字母组成。 | ### LCS 求具体方案 + 构造
为了方便,我们令 `str1` 为 `s1`,`str2` 为 `s2`,并将两者长度记为 $n$ 和 $m$。
容易想到最终的方案必然是由三部分组成:两字符串的公共子序列(且必然是最长公共子序列)+ 两者特有的字符部分。
基于此,我们可以先使用对两者求 `LCS`,并在求具体方案时遵循:属于最长公共子序列的字符只添加一次,而特有于 `s1` 或 `s2` 的字符则独自添加一次。
求解 `LCS` 部分我们定义 **$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度(为了方便,令下标从 $1$ 开始)。**
当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:
* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表**必然使用 $s1[i]$ 与 $s2[j]$ 时** `LCS` 的长度。
* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表**必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** `LCS` 的长度。
> **不了解 LCS 的同学可以看前置 🧀 : [LCS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492097&idx=1&sn=f51f29d86df809d8ac43a40a1369b3d6)**
当预处理出动规数组 `f` 之后,我们使用「双指针」和「通用 `DP` 求具体方案」的做法进行构造:使用 `i` 变量指向 `s1` 的尾部(即起始有 $i = n$),使用 `j` 变量指向 `s2` 的尾部(即起始有 $j = m$),根据 `i` 和 `j` 当前所在位置以及 $f[i][j]$ 从何值转移而来:
1. 若 `i` 或 `j` 其一走完(`i = 0` 或 `j = 0`),将剩余字符追加到答案中;
2. 当 $f[i][j] = f[i - 1][j - 1] + 1$ 且 $s1[i] = s2[j]$ 时(可简化为 $s1[i] = s2[j]$ 判断),此时 `i` 指向的字符和 `j` 指向的字符为相同,且为 `LCS` 中的字符,将其追加到具体方案,并让 `i` 和 `j` 同时后移;
3. 当 $f[i][j] = f[i - 1][j]$,将 `s1[i]` 追加到答案中,令 `i` 后移;
4. 当 $f[i][j] = f[i][j - 1]$,将 `s2[j]` 追加到答案中,令 `j` 后移。
当条件 `3` 和 `4` 同时满足时,由于只需要输出任一具体方案,我们任取其一即可。
最后,由于我们是从后往前进行构造,在返回时需要再进行一次翻转。
Java 代码:
```Java
class Solution {
public String shortestCommonSupersequence(String str1, String str2) {
int n = str1.length(), m = str2.length();
str1 = " " + str1; str2 = " " + str2;
char[] s1 = str1.toCharArray(), s2 = str2.toCharArray();
int[][] f = new int[n + 10][m + 10];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1;
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
}
}
StringBuilder sb = new StringBuilder();
int i = n, j = m;
while (i > 0 || j > 0) {
if (i == 0) sb.append(s2[j--]);
else if (j == 0) sb.append(s1[i--]);
else {
if (s1[i] == s2[j]) {
sb.append(s1[i]);
i--; j--;
} else if (f[i][j] == f[i - 1][j]) {
sb.append(s1[i--]);
} else {
sb.append(s2[j--]);
}
}
}
return sb.reverse().toString();
}
}
```
C++ 代码:
```C++
class Solution {
public:
string shortestCommonSupersequence(string str1, string str2) {
int n = str1.size(), m = str2.size();
str1 = " " + str1; str2 = " " + str2;
vector<vector<int>> f(n + 10, vector<int>(m + 10));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (str1[i] == str2[j])
f[i][j] = f[i - 1][j - 1] + 1;
else
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
}
}
string res;
int i = n, j = m;
while (i > 0 || j > 0) {
if (i == 0) res += str2[j--];
else if (j == 0) res += str1[i--];
else {
if (str1[i] == str2[j]) {
res += str1[i];
i--; j--;
}
else if (f[i][j] == f[i - 1][j]) res += str1[i--];
else res += str2[j--];
}
}
reverse(res.begin(), res.end());
return res;
}
};
```
Python 代码:
```Python
class Solution:
def shortestCommonSupersequence(self, s1: str, s2: str) -> str:
n, m = len(s1), len(s2)
s1 = " " + s1
s2 = " " + s2
f = [[0] * (m + 10) for _ in range(n + 10)]
for i in range(1, n + 1):
for j in range(1, m + 1):
f[i][j] = f[i - 1][j - 1] + 1 if s1[i] == s2[j] else max(f[i - 1][j], f[i][j - 1])
ans = ""
i, j = n, m
while i > 0 or j > 0:
if i == 0:
ans += s2[j]
j -= 1
elif j == 0:
ans += s1[i]
i -= 1
else:
if s1[i] == s2[j]:
ans += s1[i]
i -= 1
j -= 1
elif f[i][j] == f[i - 1][j]:
ans += s1[i]
i -= 1
else:
ans += s2[j]
j -= 1
return ans[::-1]
```
TypeScript 代码:
```TypeScript
function shortestCommonSupersequence(s1: string, s2: string): string {
const n = s1.length, m = s2.length
s1 = " " + s1; s2 = " " + s2
const f = new Array<Array<number>>()
for (let i = 0; i < n + 10; i++) f.push(new Array<number>(m + 10).fill(0))
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
}
}
let ans = ""
let i = n, j = m
while (i > 0 || j > 0) {
if (i == 0) ans += s2[j--]
else if (j == 0) ans += s1[i--]
else {
if (s1[i] == s2[j]) {
ans += s1[i]
i--; j--
} else if (f[i][j] == f[i - 1][j]) {
ans += s1[i--]
} else {
ans += s2[j--]
}
}
}
return ans.split('').reverse().join('')
};
```
* 时间复杂度:`LCS` 复杂度为 $O(n \times m)$;构造答案复杂度为 $O(n \times m)$。整体复杂度为 $O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1092` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1091-1100/1094. 拼车（中等）.md | 1094. 拼车 | https://leetcode.cn/problems/car-pooling/solutions/2550276/gong-shui-san-xie-tu-jie-chai-fen-ru-men-opii/ | 中等 | [
"差分",
"前缀和"
] | 车上最初有 `capacity` 个空座位,车只能向一个方向行驶(不允许掉头或改变方向)。
给定整数 `capacity` 和一个数组 `trips`, $trip[i] = [numPassengers_{i}, from_{i}, to_{i}]$ 表示第 `i` 次旅行有 $numPassengers_{i}$ 乘客,接他们和放他们的位置分别是 $from_{i}$ 和 $to_{i}$ 。
这些位置是从汽车的初始位置向东的公里数。
当且仅当你可以在所有给定的行程中接送所有乘客时,返回 `true`,否则请返回 `false`。
示例 1:
```
输入:trips = [[2,1,5],[3,3,7]], capacity = 4
输出:false
```
示例 2:
```
输入:trips = [[2,1,5],[3,3,7]], capacity = 5
输出:true
```
提示:
* $1 <= trips.length <= 1000$
* $trips[i].length = 3$
* $1 <= numPassengers_{i} <= 100$
* $0 <= from_{i} < to_{i} <= 1000$
* $1 <= capacity <= 10^5$ | ### 差分
从朴素的想法开始:创建一个数组 `cnt`,用于存储从某个站点出发时,车上的乘客数量。
例如 $cnt[x] = c$ 含义为在站点 $x$ 出发时(在该站点的下车和上车均完成),车上乘客数为 $c$ 个。
对于每个 $trips[i] = (c, a, b)$,我们需要对 $[a, b)$ 范围内的 $cnt[j]$ 进行加 $c$ 操作。
处理完 `trips` 后,检查所有站点的乘客人数,根据是否满足 `capacity` 限制返回答案。
因此,这是一个关于「区间修改,单点查询」的经典问题,可使用「差分」求解。
所谓“差分”,是指 **原数组中每个元素与前一元素之差所形成的数组**,与之相对应的是“前缀和”。
我们知道,对原数组进行诸位累加(前缀计算操作),所得到的数组为前缀和数组。差分数组,则是对其执行前缀计算后,能够得到原数组的那个数组 🤣 。
关于「差分数组 - 原数组 - 前缀和数组」三者关系如图所示:
前缀和数组的主要作用,是利用「容斥原理」快速求解某段之和。例如要查询原数组 `nums` 中下标范围 $[l, r]$ 的和,可通过 $sum[r] - sum[l - 1]$ 快速求解。
差分数组的主要作用,是帮助快速修改某段区间。
由于差分数组执行「前缀计算」后得到的是原数组,因此在差分数组上修改某个值,会对原数组某段后缀产生相同的影响。
因此,**当我们想要对原数组的 $[l, r]$ 进行整体修改时,只需要对差分数组的 $l$ 和 $r + 1$ 位置执行相应操作即可**。
举个 🌰,假设想对原数组 `nums` 的 $[l, r]$ 进行整体“加一”操作,那么可转换为对差分数组 `c[l]` 的加一操作(等价对原数组的 $[l, n - 1]$ 进行加一),以及对差分数组 `c[r + 1]` 的减一操作(等价于对原数组的 $[r + 1, n - 1]$ 进行减一,最终只有 $[l, r]$ 有加一效果)。
至此,我们完成了对「差分」的基本学习:**将原数组的区间修改等价为差分数组的特定位置修改**。
回到本题,起始先用 `nums` 来作为差分数组,对于 $trips[i] = (c, a, b)$,有 $c$ 个乘客在 $a$ 点上车,在 $b$ 点下车,因此对 $[a, b)$ 进行整体加 $c$ 操作,对应差分数组操作 `nums[a] += c; nums[b] -= c`。
处理完 `trips` 后,对差分数组 `nums` 进行前缀计算(可直接复用 `nums`,进行原地计算),便可得到各个站点的乘客数量,与 `capacity` 比较得出答案。
一些细节:为了方便,人为规定站点编号从 $1$ 开始。
Java 代码:
```Java
class Solution {
public boolean carPooling(int[][] trips, int capacity) {
int[] nums = new int[1010];
for (int[] t : trips) {
int c = t[0], a = t[1], b = t[2];
nums[a + 1] += c; nums[b + 1] -= c;
}
for (int i = 1; i <= 1000; i++) {
nums[i] += nums[i - 1];
if (nums[i] > capacity) return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool carPooling(vector<vector<int>>& trips, int capacity) {
vector<int> nums(1010, 0);
for (const auto& t : trips) {
int c = t[0], a = t[1], b = t[2];
nums[a + 1] += c; nums[b + 1] -= c;
}
for (int i = 1; i <= 1000; i++) {
nums[i] += nums[i - 1];
if (nums[i] > capacity) return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
nums = [0] * 1010
for t in trips:
c, a, b = t[0], t[1], t[2]
nums[a + 1] += c
nums[b + 1] -= c
for i in range(1, 1001):
nums[i] += nums[i - 1]
if nums[i] > capacity: return False
return True
```
TypeScript 代码:
```TypeScript
function carPooling(trips: number[][], capacity: number): boolean {
const nums = new Array(1010).fill(0);
for (const t of trips) {
const c = t[0], a = t[1], b = t[2];
nums[a + 1] += c; nums[b + 1] -= c;
}
for (let i = 1; i <= 1000; i++) {
nums[i] += nums[i - 1];
if (nums[i] > capacity) return false;
}
return true;
};
```
* 时间复杂度:$O(n + m)$,其中 $n$ 为数组 `trips` 大小;$m = 1000$ 为位置值域大小
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1094` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/11. 盛最多水的容器（中等）.md | 11. 盛最多水的容器 | https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/ | 中等 | [
"双指针",
"贪心"
] | 给你 $n$ 个非负整数 $a_1$,$a_2$,...,$a_n$,每个数代表坐标中的一个点 $(i, a_i)$ 。
在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 $(i, a_i)$ 和 $(i, 0)$ 。
找出其中的两条线,使得它们与 `x` 轴共同构成的容器可以容纳最多的水。
说明:你不能倾斜容器。
示例 1:
```
输入:[1,8,6,2,5,4,8,3,7]
输出:49
解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。
```
示例 2:
```
输入:height = [1,1]
输出:1
```
示例 3:
```
输入:height = [4,3,2,1,4]
输出:16
```
示例 4:
```
输入:height = [1,2,1]
输出:2
```
提示:
* $n = height.length$
* $2 <= n <= 3 \times 10^4$
* $0 <= height[i] <= 3 \times 10^4$ | ### 双指针 + 贪心
先用两个指针 `i` 和 `j` 指向左右边界,然后考虑指针应该怎么移动。
由于构成矩形的面积,取决于 `i` 和 `j` 之间的距离(记为 `w`) 和 `i` 和 `j` 下标对应的高度的最小值(记为 `h`)。
首先无论是 `i` 指针往右移动还是 `j` 指针往左移动都会导致 `w` 变小,所以想要能够枚举到更大的面积,我们应该让 `h` 在指针移动后变大。
不妨假设当前情况是 `height[i] < heigth[j]`(此时矩形的高度为 `height[i]`),然后分情况讨论:
* 让 `i` 和 `j` 两者高度小的指针移动,即 `i` 往右移动:
* 移动后,i 指针对应的高度变小,即 `height[i] > height[i + 1]`:`w` 和 `h` 都变小了,面积一定变小
* 移动后,i 指针对应的高度不变,即 `height[i] = height[i + 1]`:`w` 变小,`h` 不变,面积一定变小
* 移动后,i 指针对应的高度变大,即 `height[i] < height[i + 1]`:`w` 变小,`h` 变大,面积可能会变大
* 让 `i` 和 `j` 两者高度大的指针移动,即 `j` 往左移动:
* 移动后,j 指针对应的高度变小,即 `height[j] > height[j - 1]`:`w` 变小,`h` 可能不变或者变小(当 `height[j - 1] >= height[i]` 时,`h` 不变;当 `height[j - 1] < height[i]` 时,`h` 变小),面积一定变小
* 移动后,j 指针对应的高度不变,即 `height[j] = height[j - 1]`:`w` 变小,`h` 不变,面积一定变小
* 移动后,j 指针对应的高度变大,即 `height[j] < height[j - 1]`:`w` 变小,`h` 不变,面积一定变小
综上所述,我们只有将高度小的指针往内移动,才会枚举到更大的面积:
代码:
```Java
class Solution {
public int maxArea(int[] height) {
int n = height.length, ans = 0;
int i = 0, j = n - 1;
while (i < j) {
ans = Math.max(ans, (j - i) * Math.min(height[i], height[j]));
if (height[i] < height[j]) i++;
else j--;
}
return ans;
}
}
```
* 时间复杂度:会对整个数组扫描一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/12. 整数转罗马数字（中等）.md | 12. 整数转罗马数字 | https://leetcode-cn.com/problems/integer-to-roman/solution/shua-chuan-lc-tan-xin-jie-fa-by-ac_oier-5kbw/ | 中等 | [
"模拟"
] | 罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。
```
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
```
例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:
* I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
* X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
* C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
给定一个整数,将其转为罗马数字。输入确保在 1 到 3999 的范围内。
示例 1:
```
输入: 3
输出: "III"
```
示例 2:
```
输入: 4
输出: "IV"
```
示例 3:
```
输入: 9
输出: "IX"
```
示例 4:
```
输入: 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.
```
示例 5:
```
输入: 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.
```
提示:
* $1 <= num <= 3999$ | ### 模拟
现实中每一个「阿拉伯数字」固定对应一个「罗马数字」,不存在说一个「阿拉伯数字」能够对应出一个较长或者较短的「罗马数字」。
因此这是一个按照固定规则进行转换的「模拟」过程。
根据题意,我们可以列举出有限个罗马字符和其对应的数值。
然后从左到右构建罗马数字,优先构建数值高的罗马字符(如果有足够的分值,尽量尝试构建 "M",直到分值不够,再尽量尝试构建 "CM" ... )
代码:
```Java
class Solution {
int[] val = new int[]{1000,900,500,400,100,90,50,40,10,9,5,4,1};
String[] str = new String[]{"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
public String intToRoman(int x) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < val.length && x > 0; i++) {
int cv = val[i];
String cs = str[i];
while (x >= cv) {
sb.append(cs);
x -= cv;
}
}
return sb.toString();
}
}
```
* 时间复杂度:通过映射对应关系,我们发现一位「阿拉伯数字」(数值 0-9)最多用 4 个字母表示(8 = VIII),因此「罗马数字」的长度最多不超过「阿拉伯数字」长度的 $4$ 倍(同一数量级内)。对应输入值 $n$ 而言,长度约为 $\log{n}$,因此「罗马数字」的长度不超过 $4 * \log{n}$。复杂度为 $O(\log{n})$
* 空间复杂度:虽然使用了两个数组记录罗马字符和数值,但消耗的空间固定,不随着样本大小而变化。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.12` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/13. 罗马数字转整数（简单）.md | 13. 罗马数字转整数 | https://leetcode-cn.com/problems/roman-to-integer/solution/shua-chuan-lc-ha-xi-biao-by-ac_oier-mooy/ | 简单 | [
"模拟",
"哈希表"
] | 罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。
```
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
```
例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:
* I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
* X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
* C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
给定一个罗马数字,将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
```
输入: "III"
输出: 3
```
示例 2:
```
输入: "IV"
输出: 4
```
示例 3:
```
输入: "IX"
输出: 9
```
示例 4:
```
输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.
```
示例 5:
```
输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.
```
提示:
* $1 <= s.length <= 15$
* `s` 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
* 题目数据保证 s 是一个有效的罗马数字,且表示整数在范围 [1, 3999] 内
* 题目所给测试用例皆符合罗马数字书写规则,不会出现跨位等情况。
* IL 和 IM 这样的例子并不符合题目要求,49 应该写作 XLIX,999 应该写作 CMXCIX 。 | ### 模拟
与 [12. 整数转罗马数字](https://leetcode-cn.com/problems/integer-to-roman/solution/gong-shui-san-xie-12-zheng-shu-zhuan-luo-b9kw/) 类似,现实中每一个「罗马数字」固定对应一个「阿拉伯数字」。
因此这是一个按照固定规则进行转换的「模拟」过程。
根据题意,我们可以列举出有限个罗马字符和其对应的数值。
然后从左到右匹配罗马数字,优先匹配数值高的罗马字符即可。
代码:
```Java
class Solution {
int[] val = new int[]{1000,900,500,400,100,90,50,40,10,9,5,4,1};
String[] str = new String[]{"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
public int romanToInt(String s) {
int n = s.length();
int ans = 0;
for (int i = 0, j = 0; i < str.length && j < n; i++) {
int cv = val[i];
String cs = str[i];
int size = cs.length();
while (j + size <= n && s.substring(j, j + size).equals(cs)) {
ans += cv;
j += size;
}
}
return ans;
}
}
```
* 时间复杂度:通过映射对应关系,我们发现每一位「罗马数字字符」都对应特定的数值,将对应数值添加到答案的复杂度为 $O(1)$。复杂度为 $O(n)$
* 空间复杂度:虽然使用了两个数组记录罗马字符和数值,但消耗的空间固定,不随着样本大小而变化。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.13` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/14. 最长公共前缀（简单）.md | 14. 最长公共前缀 | https://leetcode-cn.com/problems/longest-common-prefix/solution/shua-chuan-lc-die-dai-mo-ni-by-ac_oier-8t4q/ | 简单 | [
"模拟"
] | 编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 `""`。
示例 1:
```
输入:strs = ["flower","flow","flight"]
输出:"fl"
```
示例 2:
```
输入:strs = ["dog","racecar","car"]
输出:""
解释:输入不存在公共前缀。
```
提示:
* $0 <= strs.length <= 200$
* $0 <= strs[i].length <= 200$
* `strs[i]` 仅由小写英文字母组成 | ### 朴素解法
对每个字符串进行逐位检查,直到不满足公共前缀。
代码:
```Java
class Solution {
public String longestCommonPrefix(String[] ss) {
String ans = "";
if (ss.length == 0) return ans;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
String s = ss[0];
if (i >= s.length()) return ans;
char c = ss[0].charAt(i);
for (String item : ss) {
if (i >= item.length() || item.charAt(i) != c) return ans;
}
ans += String.valueOf(c);
}
return ans;
}
}
```
说明:判断条件不一定要写成 `i < Integer.MAX_VALUE`,题目给出了范围是 200 以内,写成 `i <= 200` 也可以。不影响执行效率。
* 时间复杂度:对于 $n$ 个字符串,都需要遍历到公共前缀长度 m。复杂度为 $O(n \times m)$
* 空间复杂度:需要存储公共前缀作为答案返回。复杂度为 $O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/15. 三数之和（中等）.md | 15. 三数之和 | https://leetcode-cn.com/problems/3sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-cd8r/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?
请你找出所有和为 $0$ 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
```
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
```
示例 2:
```
输入:nums = []
输出:[]
```
示例 3:
```
输入:nums = [0]
输出:[]
```
提示:
* $0 <= nums.length <= 3000$
* $-10^5 <= nums[i] <= 10^5$ | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > 0:`k` 左移,使 `sum` 变小
* `sum` < 0:`j` 右移,使 `sum` 变大
* `sum` = 0:找到符合要求的答案,存起来
由于题目要求答案不能包含重复的三元组,所以在确定第一个数和第二个数的时候,要跳过数值一样的下标(在三数之和确定的情况下,确保第一个数和第二个数不会重复,即可保证三元组不重复)。
Java 代码:
```Java
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
int j = i + 1, k = n - 1;
while (j < k) {
while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;
if (j >= k) break;
int sum = nums[i] + nums[j] + nums[k];
if (sum == 0) {
ans.add(Arrays.asList(nums[i], nums[j], nums[k]));
j++;
} else if (sum > 0) {
k--;
} else if (sum < 0) {
j++;
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(), nums.end());
int n = nums.size();
vector<vector<int>> ans;
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
int j = i + 1, k = n - 1;
while (j < k) {
while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;
if (j >= k) break;
int sum = nums[i] + nums[j] + nums[k];
if (sum == 0) {
ans.push_back({nums[i], nums[j], nums[k]});
j++;
} else if (sum > 0) {
k--;
} else if (sum < 0) {
j++;
}
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums.sort()
n = len(nums)
ans = []
for i in range(n):
if i > 0 and nums[i] == nums[i - 1]: continue
j, k = i + 1, n - 1
while j < k:
while j > i + 1 and j < n and nums[j] == nums[j - 1]:
j += 1
if j >= k: break
_sum = nums[i] + nums[j] + nums[k]
if _sum == 0:
ans.append([nums[i], nums[j], nums[k]])
j += 1
elif _sum > 0:
k -= 1
elif _sum < 0:
j += 1
return ans
```
TypeScript 代码:
```TypeScript
function threeSum(nums: number[]): number[][] {
nums.sort((a, b) => a - b);
const n = nums.length;
const ans = [];
for (let i = 0; i < n; i++) {
if (i > 0 && nums[i] === nums[i - 1]) continue;
let j = i + 1, k = n - 1;
while (j < k) {
while (j > i + 1 && j < n && nums[j] === nums[j - 1]) j++;
if (j >= k) break;
const sum = nums[i] + nums[j] + nums[k];
if (sum === 0) {
ans.push([nums[i], nums[j], nums[k]]);
j++;
} else if (sum > 0) {
k--;
} else if (sum < 0) {
j++;
}
}
}
return ans;
};
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/16. 最接近的三数之和（中等）.md | 16. 最接近的三数之和 | https://leetcode-cn.com/problems/3sum-closest/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-p2ou/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给定一个包括 $n$ 个整数的数组 `nums` 和 一个目标值 `target`。
找出 `nums` 中的三个整数,使得它们的和与 `target` 最接近。
返回这三个数的和。
每组输入只存在唯一答案。
示例:
```
输入:nums = [-1,2,1,-4], target = 1
输出:2
解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
```
提示:
* $3 <= nums.length <= 10^3$
* $-10^3 <= nums[i] <= 10^3$
* $-10^4 <= target <= 10^4$ | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k]` 最接近 `target` 的唯一解。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > `target`:`k` 左移,使 `sum` 变小
* `sum` < `target`:`j` 右移,使 `sum` 变大
* `sum` = `target`:找到最符合要求的答案,直接返回
为了更快找到答案,对于相同的 `i`,可以直接跳过下标。
Java 代码:
```Java
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int n = nums.length, ans = nums[0] + nums[1] + nums[2];
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
int j = i + 1, k = n - 1;
while (j < k) {
int sum = nums[i] + nums[j] + nums[k];
if (Math.abs(sum - target) < Math.abs(ans - target)) ans = sum;
if (ans == target) {
return target;
} else if (sum > target) {
k--;
} else if (sum < target) {
j++;
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int threeSumClosest(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
int n = nums.size(), ans = nums[0] + nums[1] + nums[2];
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
int j = i + 1, k = n - 1;
while (j < k) {
int sum = nums[i] + nums[j] + nums[k];
if (abs(sum - target) < abs(ans - target)) ans = sum;
if (ans == target) {
return target;
} else if (sum > target) {
k--;
} else if (sum < target) {
j++;
}
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def threeSumClosest(self, nums: List[int], target: int) -> int:
nums.sort()
n, ans = len(nums), nums[0] + nums[1] + nums[2]
for i in range(n):
if i > 0 and nums[i] == nums[i - 1]:
continue
j, k = i + 1, n - 1
while j < k:
s = nums[i] + nums[j] + nums[k]
if abs(s - target) < abs(ans - target):
ans = s
if ans == target:
return target
elif s > target:
k -= 1
elif s < target:
j += 1
return ans
```
TypeScript 代码:
```TypeScript
function threeSumClosest(nums: number[], target: number): number {
nums.sort((a, b) => a - b);
let n = nums.length, ans = nums[0] + nums[1] + nums[2];
for (let i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
let j = i + 1, k = n - 1;
while (j < k) {
const sum = nums[i] + nums[j] + nums[k];
if (Math.abs(sum - target) < Math.abs(ans - target)) ans = sum;
if (ans == target) {
return target;
} else if (sum > target) {
k--;
} else if (sum < target) {
j++;
}
}
}
return ans;
};
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n ^ 2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.16` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/17. 电话号码的字母组合（中等）.md | 17. 电话号码的字母组合 | https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/solution/shua-chuan-lc-dfs-hui-su-jie-fa-by-ac_oi-qa02/ | 中等 | [
"DFS",
"回溯算法"
] | 给定一个仅包含数字 `2-9` 的字符串,返回所有它能表示的字母组合。
答案可以按「任意顺序」返回。
给出数字到字母的映射如下(与电话按键相同)。注意 $1$ 不对应任何字母。
示例 1:
```
输入:digits = "23"
输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
```
示例 2:
```
输入:digits = ""
输出:[]
```
示例 3:
```
输入:digits = "2"
输出:["a","b","c"]
```
提示:
* $0 <= digits.length <= 4$
* $digits[i]$ 是范围 `['2','9']` 的一个数字。 | ### 回溯算法
对于字符串 `ds` 中的每一位数字,都有其对应的字母映射数组。
在 DFS 中决策每一位数字应该对应哪一个字母,当决策的位数 `i == n`,代表整个 `ds` 字符串都被决策完毕,将决策结果添加到结果集:
代码:
```Java
class Solution {
Map<String, String[]> map = new HashMap<>(){{
put("2", new String[]{"a", "b", "c"});
put("3", new String[]{"d", "e", "f"});
put("4", new String[]{"g", "h", "i"});
put("5", new String[]{"j", "k", "l"});
put("6", new String[]{"m", "n", "o"});
put("7", new String[]{"p", "q", "r", "s"});
put("8", new String[]{"t", "u", "v"});
put("9", new String[]{"w", "x", "y", "z"});
}};
public List<String> letterCombinations(String ds) {
int n = ds.length();
List<String> ans = new ArrayList<>();
if (n == 0) return ans;
StringBuilder sb = new StringBuilder();
dfs(ds, 0, n, sb, ans);
return ans;
}
void dfs(String ds, int i, int n, StringBuilder sb, List<String> ans) {
if (i == n) {
ans.add(sb.toString());
return;
}
String key = ds.substring(i, i + 1);
String[] all = map.get(key);
for (String item : all) {
sb.append(item);
dfs(ds, i + 1, n, sb, ans);
sb.deleteCharAt(sb.length() - 1);
}
}
}
```
* 时间复杂度:`n` 代表字符串 `ds` 的长度,一个数字最多对应 4 个字符(7 对应 “pqrs"),即每个数字最多有 4 个字母需要被决策。复杂度为 $O(4^n)$
* 空间复杂度:有多少种方案,就需要多少空间来存放答案。复杂度为 $O(4^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.17` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/18. 四数之和（中等）.md | 18. 四数之和 | https://leetcode-cn.com/problems/4sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-dqx7/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给定一个包含 $n$ 个整数的数组 `nums` 和一个目标值 `t`,判断 `nums` 中是否存在四个元素 `a`,`b`,`c` 和 `d` ,使得 `a + b + c + d` 的值与 `t` 相等?
找出所有满足条件且不重复的四元组。
注意:答案中不可以包含重复的四元组。
示例 1:
```
输入:nums = [1,0,-1,0,-2,2], t = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
```
示例 2:
```
输入:nums = [], t = 0
输出:[]
```
提示:
* $0 <= nums.length <= 200$
* $-10^9 <= nums[i] <= 10^9$
* $-10^9 <= t<= 10^9$ | ### 排序 + 双指针
对数组进行排序,使用四个指针 `i`、`j` 、`k` 和 `p` 分别代表要找的四个数。
1. 通过枚举 `i` 确定第一个数,枚举 `j` 确定第二个数,另外两个指针 `k` 和 `p` 分别从左边 `j + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] + nums[p] == t` 的所有组合。
2. `k` 和 `p` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k] + nums[p]` :
* `sum` > `t`:`p` 左移,使 `sum` 变小
* `sum` < `t`:`k` 右移,使 `sum` 变大
* `sum` = `t`:将组合加入结果集,`k` 右移继续进行检查
题目要求不能包含重复元素,所以我们要对 `i`、`j` 和 `k` 进行去重,去重逻辑是对于相同的数,只使用第一个。
Java 代码:
```Java
class Solution {
public List<List<Integer>> fourSum(int[] nums, int t) {
Arrays.sort(nums);
int n = nums.length;
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) { // 确定第一个数
if (i > 0 && nums[i] == nums[i - 1]) continue; // 对第一个数进行去重(相同的数只取第一个)
for (int j = i + 1; j < n; j++) { // 确定第二个数
if (j > i + 1 && nums[j] == nums[j - 1]) continue; // 对第二个数进行去重(相同的数只取第一个)
// 确定第三个数和第四个数
int k = j + 1, p = n - 1;
while (k < p) {
// 对第三个数进行去重(相同的数只取第一个)
while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++;
// 如果 k 跳过相同元素之后的位置超过了 p,本次循环结束
if (k >= p) break;
long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];
if (sum == t) {
ans.add(Arrays.asList(nums[i], nums[j], nums[k], nums[p]));
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int t) {
sort(nums.begin(), nums.end());
int n = nums.size();
vector<vector<int>> ans;
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
for (int j = i + 1; j < n; j++) {
if (j > i + 1 && nums[j] == nums[j - 1]) continue;
int k = j + 1, p = n - 1;
while (k < p) {
while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++;
if (k >= p) break;
long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];
if (sum == t) {
ans.push_back({nums[i], nums[j], nums[k], nums[p]});
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def fourSum(self, nums: List[int], t: int) -> List[List[int]]:
nums.sort()
n = len(nums)
ans = []
for i in range(n):
if i > 0 and nums[i] == nums[i - 1]: continue
for j in range(i + 1, n):
if j > i + 1 and nums[j] == nums[j - 1]: continue
k, p = j + 1, n - 1
while k < p:
while k > j + 1 and k < n and nums[k] == nums[k - 1]:
k += 1
if k >= p: break
_sum = nums[i] + nums[j] + nums[k] + nums[p]
if _sum == t:
ans.append([nums[i], nums[j], nums[k], nums[p]])
k += 1
elif _sum > t:
p -= 1
elif _sum < t:
k += 1
return ans
```
TypeScript 代码:
```TypeScript
function fourSum(nums: number[], t: number): number[][] {
nums.sort((a, b) => a - b);
const n = nums.length;
const ans = [];
for (let i = 0; i < n; i++) {
if (i > 0 && nums[i] === nums[i - 1]) continue;
for (let j = i + 1; j < n; j++) {
if (j > i + 1 && nums[j] === nums[j - 1]) continue;
let k = j + 1, p = n - 1;
while (k < p) {
while (k > j + 1 && k < n && nums[k] === nums[k - 1]) k++;
if (k >= p) break;
const sum = nums[i] + nums[j] + nums[k] + nums[p];
if (sum === t) {
ans.push([nums[i], nums[j], nums[k], nums[p]]);
k++;
} else if (sum > t) {
p--;
} else if (sum < t) {
k++;
}
}
}
}
return ans;
};
```
* 时间复杂度:`i` 和 `j` 是直接枚举确定,复杂度为 $O(n^2)$,当确定下来 `i` 和 `j` 之后,通过双指针确定 `k` 和 `p` ,也就是对于每一组 `i` 和 `j` 而言复杂度为 $O(n)$。总的复杂度为 $O(n^3)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.18` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/19. 删除链表的倒数第 N 个结点（中等）.md | 19. 删除链表的倒数第 N 个结点 | https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/solution/shua-chuan-lc-lian-biao-kuai-man-zhi-zhe-1gs1/ | 中等 | [
"链表",
"快慢指针",
"双指针"
] | 给你一个链表,删除链表的倒数第 `n` 个结点,并且返回链表的头结点。
进阶:你能尝试使用一趟扫描实现吗?
示例 1:
```
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
```
示例 2:
```
输入:head = [1], n = 1
输出:[]
```
示例 3:
```
输入:head = [1,2], n = 1
输出:[1]
```
提示:
* 链表中结点的数目为 `sz`
* $1 <= sz <= 30$
* $0 <= Node.val <= 100$
* $1 <= n <= sz$ | ### 快慢指针
删除链表的倒数第 `n` 个结点,首先要确定倒数第 `n` 个节点的位置。
我们可以设定两个指针,分别为 `slow` 和 `fast`,刚开始都指向 head。
然后先让 `fast` 往前走 `n` 步,`slow` 指针不动,这时候两个指针的距离为 `n`。
再让 `slow` 和 `fast` 同时往前走(保持两者距离不变),直到 `fast` 指针到达结尾的位置。
这时候 `slow` 会停在待删除节点的前一个位置,让 `slow.next = slow.next.next` 即可。
但这里有一个需要注意的边界情况是:如果链表的长度是 `L`,而我们恰好要删除的是倒数第 `L` 个节点(删除头节点),这时候 `fast` 往前走 `n` 步之后会变为 null,此时我们只需要让 `head = slow.next` 即可删除。
代码:
```Java
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if (head.next == null) return null;
ListNode slow = head, fast = head;
while (n-- > 0) fast = fast.next;
if (fast == null) {
head = slow.next;
} else {
while (fast.next != null) {
slow = slow.next; fast = fast.next;
}
slow.next = slow.next.next;
}
return head;
}
}
```
* 时间复杂度:需要扫描的长度为链表的长度。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/20. 有效的括号（简单）.md | 20. 有效的括号 | https://leetcode-cn.com/problems/valid-parentheses/solution/shua-chuan-lc-zhan-ascii-chai-zhi-jie-fa-00zo/ | 简单 | [
"栈",
"有效括号"
] | 给定一个只包括 `'(',')','{','}','[',']'` 的字符串 `s` ,判断字符串是否有效。
有效字符串需满足:
1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
示例 1:
```
输入:s = "()"
输出:true
```
示例 2:
```
输入:s = "()[]{}"
输出:true
```
示例 3:
```
输入:s = "(]"
输出:false
```
示例 4:
```
输入:s = "([)]"
输出:false
```
示例 5:
```
输入:s = "{[]}"
输出:true
```
提示:
* $1 <= s.length <= 10^4$
* `s` 仅由括号 `'()[]{}'` 组成 | ### 栈 + 哈希表
这是道模拟题,同一类型的括号,一个右括号要对应一个左括号。
不难发现可以直接使用 `栈` 来解决:
代码:
```Java
class Solution {
HashMap<Character, Character> map = new HashMap<Character, Character>(){{
put(']', '[');
put('}', '{');
put(')', '(');
}};
public boolean isValid(String s) {
Deque<Character> d = new ArrayDeque<>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(' || c == '{' || c == '[') {
d.addLast(c);
} else {
if (!d.isEmpty() && d.peekLast() == map.get(c)) {
d.pollLast();
} else {
return false;
}
}
}
return d.isEmpty();
}
}
```
* 时间复杂度:对字符串 `s` 扫描一遍。复杂度为 $O(n)$
* 空间复杂度:使用的哈希表空间固定,不随着样本数量变大而变大。复杂度为 $O(1)$
**注意:三叶使用了 `Deque` 双端队列来充当栈,而不是 `Stack`,这也是 JDK 推荐的做法。建议所有的 Java 同学都采用 `Deque` 作为栈。**
**不使用 `Stack` 的原因是 `Stack` 继承自 `Vector`,拥有了动态数组的所有公共 API,并不安全,而且 `Stack` 还犯了面向对象设计的错误:将组合关系当成了继承关系。**
---
### 栈 + ASCII 差值
我们也可以利用 `"()"`、`"{}"` 和 `"[]"` 的左右部分在 ASCII 值上比较接近的事实。
`(` 和 `)` 分别对应 -7 和 -8;`[` 和 `]` 分别对应 43 和 45;`{` 和 `}` 分别对应 75 和 77。
也就是同类型的左右括号,相差不超过 2 ,同时不同类型的左右括号,相差大于 2。
利用此特性,我们可以节省一个哈希表:
代码:
```Java
class Solution {
public boolean isValid(String s) {
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
int u = c - '0';
if (c == '(' || c == '{' || c == '[') {
d.addLast(u);
} else {
if (!d.isEmpty() && Math.abs(d.peekLast() - u) <= 2) {
d.pollLast();
} else {
return false;
}
}
}
return d.isEmpty();
}
}
```
* 时间复杂度:对字符串 `s` 扫描一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1104. 二叉树寻路（中等）.md | 1104. 二叉树寻路 | https://leetcode-cn.com/problems/path-in-zigzag-labelled-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-rw2d/ | 中等 | [
"二叉树",
"模拟",
"数学"
] | 在一棵无限的二叉树上,每个节点都有两个子节点,树中的节点 逐行 依次按 “之” 字形进行标记。
如下图所示,在奇数行(即,第一行、第三行、第五行......)中,按从左到右的顺序进行标记;
而偶数行(即,第二行、第四行、第六行......)中,按从右到左的顺序进行标记。
给你树上某一个节点的标号 label,请你返回从根节点到该标号为 label 节点的路径,该路径是由途经的节点标号所组成的。
示例 1:
```
输入:label = 14
输出:[1,3,4,14]
```
示例 2:
```
输入:label = 26
输出:[1,2,6,10,26]
```
提示:
* 1 <= label <= $10^6$ | ### 模拟
一个朴素的做法是根据题意进行模拟。
利用从根节点到任意一层都是满二叉树,我们可以先确定 `label` 所在的层级 `level`,然后计算出当前层起始节点值(最小值)和结束节点值(最大值)。
再利用「每层节点数量翻倍」&「隔层奇偶性翻转」,寻址出上一层的节点下标(令每层下标均「从左往右」计算,并从 $1$ 开始),直到构造出答案(寻址到根节点)。
代码:
```Java
class Solution {
// 第 level 层的起始节点值
int getStart(int level) {
return (int)Math.pow(2, level - 1);
}
// 第 level 层的结束节点值
int getEnd(int level) {
int a = getStart(level);
return a + a - 1;
}
public List<Integer> pathInZigZagTree(int n) {
// 计算 n 所在层级
int level = 1;
while (getEnd(level) < n) level++;
int[] ans = new int[level];
int idx = level - 1, cur = n;
while (idx >= 0) {
ans[idx--] = cur;
int tot = (int)Math.pow(2, level - 1);
int start = getStart(level), end = getEnd(level);
if (level % 2 == 0) {
// 当前层为偶数层,则当前层节点「从右往左」数值递增,相应计算上一层下标也应该「从右往左」
int j = tot / 2;
for (int i = start; i <= end; i += 2, j--) {
if (i == cur || (i + 1) == cur) break;
}
int prevStart = getStart(level - 1);
while (j-- > 1) prevStart++;
cur = prevStart;
} else {
// 当前层为奇数层,则当前层节点「从左往右」数值递增,相应计算上一层下标也应该「从左往右」
int j = 1;
for (int i = start; i <= end; i += 2, j++) {
if (i == cur || (i + 1) == cur) break;
}
int prevEnd = getEnd(level - 1);
while (j-- > 1) prevEnd--;
cur = prevEnd;
}
level--;
}
List<Integer> list = new ArrayList<>();
for (int i : ans) list.add(i);
return list;
}
}
```
* 时间复杂度:确定 $n$ 所在层级复杂度为 $O(\log{n})$;构造答案最坏情况下每个节点会被遍历一次,复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 数学
上述解法复杂度上界取决于「由当前行节点位置确定上层位置」的线性遍历。
如果二叉树本身不具有奇偶性翻转的话,显然某个节点 $x$ 的父节点为 $\left \lfloor x / 2 \right \rfloor$,但事实上存在奇偶性翻转,而在解法一中我们已经可以 $O(1)$ 计算某一层的起始值和结束值,有了「起始值 & 结算值」和「当前节点所在层的相对位置」,只需要利用“对称性”找到父节点在上层的相应位置,然后根据相应位置算出父节点值即可。
代码:
```Java
class Solution {
int getStart(int level) {
return (int)Math.pow(2, level - 1);
}
int getEnd(int level) {
int a = getStart(level);
return a + a - 1;
}
public List<Integer> pathInZigZagTree(int n) {
int level = 1;
while (getEnd(level) < n) level++;
int[] ans = new int[level];
int idx = level - 1, cur = n;
while (idx >= 0) {
ans[idx--] = cur;
int loc = ((1 << (level)) - 1 - cur) >> 1;
cur = (1 << (level - 2)) + loc;
level--;
}
List<Integer> list = new ArrayList<>();
for (int i : ans) list.add(i);
return list;
}
}
```
* 时间复杂度:复杂度上界取决于确定 $n$ 所在层级。复杂度为 $O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1106. 解析布尔表达式（困难）.md | 1106. 解析布尔表达式 | https://leetcode.cn/problems/parsing-a-boolean-expression/solution/by-ac_oier-jr29/ | 困难 | [
"栈",
"表达式计算"
] | 给你一个以字符串形式表述的 布尔表达式 `(boolean) expression`,返回该式的运算结果。
有效的表达式需遵循以下约定:
* `"t"`,运算结果为 `True`
* `"f"`,运算结果为 `False`
* `"!(expr)"`,运算过程为对内部表达式 `expr` 进行逻辑 非的运算(`NOT`)
* `"&(expr1,expr2,...)"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 与的运算(`AND`)
* `"|(expr1,expr2,...)"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 或的运算(`OR`)
示例 1:
```
输入:expression = "!(f)"
输出:true
```
示例 2:
```
输入:expression = "|(f,t)"
输出:true
```
示例 3:
```
输入:expression = "&(t,f)"
输出:false
```
示例 4:
```
输入:expression = "|(&(t,f,t),!(t))"
输出:false
```
提示:
* $1 <= expression.length <= 20000$
* `expression[i]` 由 `{'(', ')', '&', '|', '!', 't', 'f', ','}` 中的字符组成。
* `expression` 是以上述形式给出的有效表达式,表示一个布尔值。 | ### 双栈
为了方便,我们令 `expression` 为 `s`。
我们可以将 `t` 和 `f` 看做操作数,而 `|`、`&` 和 `!` 看做操作符,创建两个栈 `nums` 和 `ops` 分别对其进行存储。
剩余的 `()` 和 `,` 则只是优先级和分隔符,无须额外关注。
从前往后处理 `s`,根据当前处理的字符为何值进行分情况讨论:
* `,`:分隔符,直接跳过;
* `t` 或 `f`:操作数,添加到 `nums` 栈中;
* `|`、`&` 或 `!`:操作符,添加到 `ops` 栈中;
* `(`:子表达式的左端点,为了在我们从「双栈」中取出数值和符号计算时,可以知道某个子表达式计算完成,需要记录一下。往 `nums` 追加一个占位符号 `-` 来代指;
* `)`:子表达式的右端点,代表一个子表达式的结束。可从「双栈」中取出符号和数组进行计算(在 `ops` 中仅取栈顶元素,代表当前子表达式的操作符;而在 `nums` 中则取到代表左端点的占位元素 `-` 为止),并将结果重新放入 `nums` 中。
最后考虑如何计算最简表达式,考虑实现一个 `char calc(char a, char b, char op)` 函数,代表对操作数 `a` 和 `b` 执行 `op` 操作并进行结果返回。
实际上,在 `calc` 函数我们只区分 `|` 操作和其他操作即可。也就是说 `&` 和 `!` 均当做 `&` 来做,`!` 操作在计算完整个表达式后再翻转。
Java 代码:
```Java
class Solution {
public boolean parseBoolExpr(String s) {
Deque<Character> nums = new ArrayDeque<>(), ops = new ArrayDeque<>();
for (char c : s.toCharArray()) {
if (c == ',') continue;
if (c == 't' || c == 'f') nums.addLast(c);
if (c == '|' || c == '&' || c == '!') ops.addLast(c);
if (c == '(') nums.addLast('-');
if (c == ')') {
char op = ops.pollLast(), cur = ' ';
while (!nums.isEmpty() && nums.peekLast() != '-') {
char top = nums.pollLast();
cur = cur == ' ' ? top : calc(top, cur, op);
}
if (op == '!') cur = cur == 't' ? 'f' : 't';
nums.pollLast(); nums.addLast(cur);
}
}
return nums.peekLast() == 't';
}
char calc(char a, char b, char op) {
boolean x = a == 't', y = b == 't';
boolean ans = op == '|' ? x | y : x & y;
return ans ? 't' : 'f';
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool parseBoolExpr(string s) {
deque<char> nums, ops;
for (char c : s) {
if (c == ',') continue;
if (c == 't' || c == 'f') nums.push_back(c);
if (c == '|' || c == '&' || c == '!') ops.push_back(c);
if (c == '(') nums.push_back('-');
if (c == ')') {
char op = ops.back(); ops.pop_back();
char cur = ' ';
while (!nums.empty() && nums.back() != '-') {
char top = nums.back(); nums.pop_back();
cur = cur == ' ' ? top : calc(top, cur, op);
}
if (op == '!') cur = cur == 't' ? 'f' : 't';
nums.pop_back(); nums.push_back(cur);
}
}
return nums.back() == 't';
}
char calc(char a, char b, char op) {
bool x = a == 't', y = b == 't';
bool ans = op == '|' ? x | y : x & y;
return ans ? 't' : 'f';
}
};
```
Python 代码:
```Python
class Solution:
def parseBoolExpr(self, s: str) -> bool:
def calc(a, b, op):
x, y = a == 't', b == 't'
ans = x | y if op == '|' else x & y
return 't' if ans else 'f'
nums, ops = [], []
for c in s:
if c == ',':
continue
if c == 't' or c == 'f':
nums.append(c)
if c == '|' or c == '&' or c == '!':
ops.append(c)
if c == '(':
nums.append('-')
if c == ')':
op, cur = ops.pop(), ' '
while nums and nums[-1] != '-':
top = nums.pop()
cur = top if cur == ' ' else calc(cur, top, op)
if op == '!':
cur = 't' if cur == 'f' else 'f'
nums.pop()
nums.append(cur)
return nums[-1] == 't'
```
TypeScript 代码:
```TypeScript
function parseBoolExpr(s: string): boolean {
function calc(a: string, b: string, op: string): string {
const x = a == 't', y = b == 't'
const ans = op == '|' ? x || y : x && y
return ans ? 't' : 'f'
}
const nums = new Array<string>(s.length).fill(''), ops = new Array<string>(s.length).fill('')
let idx1 = 0, idx2 = 0
for (const c of s) {
if (c == ',') continue
if (c == 't' || c == 'f') nums[idx1++] = c
if (c == '|' || c == '&' || c == '!') ops[idx2++] = c
if (c == '(') nums[idx1++] = '-'
if (c == ')') {
let op = ops[--idx2], cur = ' '
while (idx1 > 0 && nums[idx1 - 1] != '-') {
const top = nums[--idx1]
cur = cur == ' ' ? top : calc(top, cur, op)
}
if (op == '!') cur = cur == 't' ? 'f' : 't'
idx1--; nums[idx1++] = cur
}
}
return nums[idx1 - 1] == 't'
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1106` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1108. IP 地址无效化（简单）.md | 1108. IP 地址无效化 | https://leetcode.cn/problems/defanging-an-ip-address/solution/by-ac_oier-cndi/ | 简单 | [
"模拟"
] | 给你一个有效的 `IPv4` 地址 `address`,返回这个 `IP` 地址的无效化版本。
所谓无效化 `IP` 地址,其实就是用 `"[.]"` 代替了每个 `"."`。
示例 1:
```
输入:address = "1.1.1.1"
输出:"1[.]1[.]1[.]1"
```
示例 2:
```
输入:address = "255.100.50.0"
输出:"255[.]100[.]50[.]0"
```
提示:
* 给出的 `address` 是一个有效的 `IPv4` 地址 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String defangIPaddr(String s) {
StringBuilder sb = new StringBuilder();
int n = s.length(), idx = -1;
while (++idx < n) {
char c = s.charAt(idx);
if (c == '.') sb.append('[');
sb.append(c);
if (c == '.') sb.append(']');
}
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1109. 航班预订统计（中等）.md | 1109. 航班预订统计 | https://leetcode-cn.com/problems/corporate-flight-bookings/solution/gong-shui-san-xie-yi-ti-shuang-jie-chai-fm1ef/ | 中等 | [
"区间求和问题",
"差分",
"线段树"
] | 这里有 $n$ 个航班,它们分别从 $1$ 到 $n$ 进行编号。
有一份航班预订表 `bookings`,表中第 $i$ 条预订记录 $bookings[i] = [first_i, last_i, seats_i]$ 意味着在从 $first_i$ 到 $last_i$ (包含 $first_i$ 和 $last_i$ )的 每个航班 上预订了 $seats_i$ 个座位。
请你返回一个长度为 $n$ 的数组 `answer`,其中 $answer[i]$ 是航班 $i$ 上预订的座位总数。
示例 1:
```
输入:bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5
输出:[10,55,45,25,25]
解释:
航班编号 1 2 3 4 5
预订记录 1 : 10 10
预订记录 2 : 20 20
预订记录 3 : 25 25 25 25
总座位数: 10 55 45 25 25
因此,answer = [10,55,45,25,25]
```
示例 2:
```
输入:bookings = [[1,2,10],[2,2,15]], n = 2
输出:[10,25]
解释:
航班编号 1 2
预订记录 1 : 10 10
预订记录 2 : 15
总座位数: 10 25
因此,answer = [10,25]
```
提示:
* $1 <= n <= 2 * 10^4$
* $1 <= bookings.length <= 2 * 10^4$
* $bookings[i].length == 3$
* $1 <= first_i <= last_i <= n$
* $1 <= seats_i <= 10^4$ | ### 基本分析
本题只涉及「区间修改 + 单点查询」,属于「区间求和」问题中的入门难度。
对于各类「区间求和」问题,该用什么方式进行求解,之前在 [这里](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 提到过。
此处可以再总结一下(加粗字体为最佳方案):
* 数组不变,区间查询:**前缀和**、树状数组、线段树;
* 数组单点修改,区间查询:**树状数组**、线段树;
* 数组区间修改,单点查询:**差分**、线段树;
* 数组区间修改,区间查询:**线段树**。
> 注意:上述总结是对于一般性而言的(能直接解决的),对标的是模板问题。
但存在经过一些经过“额外”操作,对问题进行转化,从而使用别的解决方案求解的情况。
例如某些问题,我们可以先对原数组进行差分,然后使用树状数组,也能解决区间修改问题。
或者使用多个树状数组来维护多个指标,从而实现类似线段树的持久化标记操作。
但这些不属于一般性,所以就不添加到题解了。
---
### 差分
本题只涉及「区间修改 + 单点查询」,因此是一道「差分」的模板题。
「差分」可以看做是求「前缀和」的逆向过程。
对于一个「将区间 $[l, r]$ 整体增加一个值 $v$」操作,我们可以对差分数组 $c$ 的影响看成两部分:
* 对 $c[l] += v$:由于差分是前缀和的逆向过程,这个操作对于将来的查询而言,带来的影响是对于所有的下标大于等于 $l$ 的位置都增加了值 $v$;
* 对 $c[r + 1] -= v$:由于我们期望只对 $[l, r]$ 产生影响,因此需要对下标大于 $r$ 的位置进行减值操作,从而抵消“影响”。
对于最后的构造答案,可看做是对每个下标做“单点查询”操作,只需要对差分数组求前缀和即可。
代码:
```Java
class Solution {
public int[] corpFlightBookings(int[][] bs, int n) {
int[] c = new int[n + 1];
for (int[] bo : bs) {
int l = bo[0] - 1, r = bo[1] - 1, v = bo[2];
c[l] += v;
c[r + 1] -= v;
}
int[] ans = new int[n];
ans[0] = c[0];
for (int i = 1; i < n; i++) {
ans[i] = ans[i - 1] + c[i];
}
return ans;
}
}
```
* 时间复杂度:令 `bs` 长度为 $m$,预处理差分数组的复杂度为 $O(m)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$
* 空间复杂度:$O(n)$
---
### 线段树
在「基本分析」中,我们发现几乎所有的「区间求和」问题都可以使用线段树解决。
那么是否无脑写线段树呢?答案并不是,恰好相反。
线段树代码很长,且常数很大,实际表现不算很好。只有不得不写「线段树」的时候,我们才考虑线段树。
回到本题,由于涉及「区间修改」操作,因此我们需要对线段树进行持久化标记(懒标记),从而确保操作仍为 $\log$ 级别的复杂度。
代码:
```Java
class Solution {
class Node {
int l, r, v, add;
Node(int _l, int _r) {
l = _l; r = _r;
}
}
int N = 20009;
Node[] tr = new Node[N * 4];
void pushup(int u) {
tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;
}
void pushdown(int u) {
int add = tr[u].add;
tr[u << 1].v += add;
tr[u << 1].add += add;
tr[u << 1 | 1].v += add;
tr[u << 1 | 1].add += add;
tr[u].add = 0;
}
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l != r) {
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
}
void update(int u, int l, int r, int v) {
if (l <= tr[u].l && tr[u].r <= r) {
tr[u].v += v;
tr[u].add += v;
} else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) update(u << 1, l, r, v);
if (r > mid) update(u << 1 | 1, l, r, v);
pushup(u);
}
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) {
return tr[u].v;
} else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
int ans = 0;
if (l <= mid) ans += query(u << 1, l, r);
if (r > mid) ans += query(u << 1 | 1, l, r);
return ans;
}
}
public int[] corpFlightBookings(int[][] bs, int n) {
build(1, 1, n);
for (int[] bo : bs) {
update(1, bo[0], bo[1], bo[2]);
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = query(1, i + 1, i + 1);
}
return ans;
}
}
```
* 时间复杂度:线段树建树复杂度为 $O(n)$,其余操作复杂度为 $O(\log{n})$。对于本题,令 `bs` 长度为 $m$,整体复杂度为 $O(m\log{n} + n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/113. 路径总和 II（中等）.md | 113. 路径总和 II | https://acoier.com/2022/12/10/113.%20%E8%B7%AF%E5%BE%84%E6%80%BB%E5%92%8C%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"DFS",
"二叉树"
] | 给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
```
示例 2:
```
输入:root = [1,2,3], targetSum = 5
输出:[]
```
示例 3:
```
输入:root = [1,2], targetSum = 0
输出:[]
```
提示:
* 树中节点总数在范围 $[0, 5000]$ 内
* $-1000 <= Node.val <= 1000$
* $-1000 <= targetSum <= 1000$ | ### 树的遍历 - DFS
定义 `DFS` 函数 `void dfs(TreeNode root, int cur, int t, List<Integer> path)` 。
其中 `root` 为当前遍历到的节点;`cur` 为当前路径总和;`t` 为目标总和;`path` 为当前路径方案。
剩下的为常规的树的遍历,当 `root` 为叶子节点(既没有左子树,也没有右子树)时,根据 `cur` 是否与 `t` 相等,决定是否要把 `path` 添加到答案中。
代码:
```Java
class Solution {
List<List<Integer>> ans = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int t) {
if (root != null) dfs(root, root.val, t, new ArrayList<>(){{add(root.val);}});
return ans;
}
void dfs(TreeNode root, int cur, int t, List<Integer> path) {
if (root.left == null && root.right == null) {
if (cur == t) ans.add(new ArrayList<>(path));
return ;
}
List<TreeNode> list = new ArrayList<>();
if (root.left != null) list.add(root.left);
if (root.right != null) list.add(root.right);
for (TreeNode child : list) {
path.add(child.val);
dfs(child, cur + child.val, t, path);
path.remove(path.size() - 1);
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.113` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/115. 不同的子序列（困难）.md | 115. 不同的子序列 | https://leetcode.cn/problems/distinct-subsequences/solution/xiang-jie-zi-fu-chuan-pi-pei-wen-ti-de-t-wdtk/ | 困难 | [
"线性 DP"
] | 给定一个字符串 `s` 和一个字符串 `t` ,计算在 `s` 的子序列中 `t` 出现的个数。
字符串的一个 子序列 是指,通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。(例如,`"ACE"` 是 `"ABCDE"` 的一个子序列,而 `"AEC"` 不是)
题目数据保证答案符合 `32` 位带符号整数范围。
示例 1:
```
输入:s = "rabbbit", t = "rabbit"
输出:3
解释:
如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
(上箭头符号 ^ 表示选取的字母)
rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^
```
示例 2:
```
输入:s = "babgbag", t = "bag"
输出:5
解释:
如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。
(上箭头符号 ^ 表示选取的字母)
babgbag
^^ ^
babgbag
^^ ^
babgbag
^ ^^
babgbag
^ ^^
babgbag
^^^
```
提示:
* $0 <= s.length, t.length <= 1000$
* `s` 和 `t` 由英文字母组成 | ### 基本思路
有两个字符串 `s` 和 `t`,长度数量级都为 $10^3$。
一个朴素的想法是,找出所有 `s` 的子序列,与 `t` 进行比较,找所有子序列的复杂度是 $O(2^n)$,肯定会超时。
因此,我们放弃这种朴素思路。
字符串匹配也不具有二段性质,不可能有 $log$ 级别的算法,那么复杂度再往下优化就是 $O(n * m)$ 的递推 DP 做法了。
***
### 动态规划
DP 的状态定义猜测通常是一门经验学科。
**但是,对于两个字符串匹配,一个非常通用的状态定义如下:**
**定义 $f[i][j]$ 为考虑 `s` 中 $[0,i]$ 个字符,`t` 中 $[0,j]$ 个字符的匹配个数。**
那么显然对于某个 $f[i][j]$ 而言,从「最后一步」的匹配进行分析,包含两类决策:
* 不让 `s[i]` 参与匹配,也就是需要让 `s` 中 $[0,i-1]$ 个字符去匹配 `t` 中的 $[0,j]$ 字符。此时匹配值为 $f[i-1][j]$
* 让 `s[i]` 参与匹配,这时候只需要让 `s` 中 $[0,i-1]$ 个字符去匹配 `t` 中的 $[0,j-1]$ 字符即可,同时满足 `s[i]=t[j]`。此时匹配值为 $f[i-1][j-1]$
最终 $f[i][j]$ 就是两者之和。
代码:
```java []
class Solution {
public int numDistinct(String s, String t) {
// 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始
// 同时由于往头部插入相同的(不存在的)字符,不会对结果造成影响,而且可以使得 f[i][0] = 1,可以将 1 这个结果滚动下去
int n = s.length(), m = t.length();
s = " " + s;
t = " " + t;
char[] cs = s.toCharArray(), ct = t.toCharArray();
// f(i,j) 代表考虑「s 中的下标为 0~i 字符」和「t 中下标为 0~j 字符」是否匹配
int[][] f = new int[n + 1][m + 1];
// 原字符只有小写字符,当往两个字符插入空格之后,f[i][0] = 1 是一个显而易见的初始化条件
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
// 包含两种决策:
// 不使用 cs[i] 进行匹配,则有 f[i][j] = f[i - 1][j]
f[i][j] = f[i - 1][j];
// 使用 cs[i] 进行匹配,则要求 cs[i] == ct[j],然后有 f[i][j] += f[i - 1][j - 1]
if (cs[i] == ct[j]) {
f[i][j] += f[i - 1][j - 1];
}
}
}
return f[n][m];
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$
*PS. 需要说明的是,由于中间结果会溢出,CPP 中必须使用 long long,而 Java 不用。由于 Java 中 int 的存储机制,只要在运算过程中只要不涉及取 min、取 max 或者其他比较操作的话,中间结果溢出不会影响最终结果。*
***
### 总结
1. 关于字符串匹配,通常有两种(你也可以理解为一种)通用的状态定义:
* $f[i][j]$ 表示「第一个字符 `s` 中 $[0,i]$ 个字符」与「第二个字符 `t` 中 $[0,j]$ 个字符」的匹配结果
* $f[i][j]$ 表示「第一个字符 `s` 中 $[0,i]$ 个字符」与「第二个字符 `t` 中 $[0,j]$ 个字符」且 「最后一个字符为 `t[j]`」的匹配结果
2. 往两个字符串的头部追加「不存在」的字符,目的是为了能够构造出可以滚动(被累加)下去的初始化值
***
### 进阶
事实上,关于字符串匹配问题,还有一道稍稍不同的变形的题目。
也是利用了类似的「通用思路」(状态定义) &「技巧」,然后对匹配过程中的字符进行分情况讨论,学有余力的同学可以看看:
[10. 正则表达式匹配](https://leetcode-cn.com/problems/regular-expression-matching/) : [如何利用的「等差」性质降低「正则字符串匹配」算法复杂度 ...](https://leetcode-cn.com/problems/regular-expression-matching/solution/shua-chuan-lc-dong-tai-gui-hua-jie-fa-by-zn9w/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/117. 填充每个节点的下一个右侧节点指针 II（中等）.md | 117. 填充每个节点的下一个右侧节点指针 II | https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/solutions/2510505/gong-shui-san-xie-xiang-xi-tu-jie-o1-kon-d6vg/ | 中等 | [
"BFS",
"链表"
] | 给定一个二叉树:
```
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
```
填充它的每个 `next` 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 `next` 指针设置为 `NULL`。
初始状态下,所有 `next` 指针都被设置为 `NULL`。
示例 1:
```
输入:root = [1,2,3,4,5,null,7]
输出:[1,#,2,3,#,4,5,7,#]
解释:给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化输出按层序遍历顺序(由 next 指针连接),'#' 表示每层的末尾。
```
示例 2:
```
输入:root = []
输出:[]
```
提示:
* 树中的节点数在范围 $[0, 6000]$ 内
* $-100 <= Node.val <= 100$
进阶:
* 你只能使用常量级额外空间。
* 使用递归解题也符合要求,本题中递归程序的隐式栈空间不计入额外空间复杂度。 | ### BFS - 层序遍历
一个最直观的做法,是利用 `BFS` 对树进行「层序遍历」。
每个 `BFS` 回合中,对整层节点进行处理。
首先通过 `pop` 拿到当前节点,同时通过 `peek` 拿到当前层的下一节点,并建立 `next` 关系,注意需要跳过每层的最后一个节点。
Java 代码:
```Java
class Solution {
public Node connect(Node root) {
Node ans = root;
if (root == null) return ans;
Deque<Node> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
int sz = d.size();
while (sz-- > 0) {
Node a = d.pollFirst();
if (sz != 0) a.next = d.peekFirst();
if (a.left != null) d.addLast(a.left);
if (a.right != null) d.addLast(a.right);
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
Node* connect(Node* root) {
Node* ans = root;
if (root == nullptr) return ans;
deque<Node*> d;
d.push_back(root);
while (!d.empty()) {
int sz = d.size();
while (sz-- > 0) {
Node* a = d.front();
d.pop_front();
if (sz != 0) a->next = d.front();
if (a->left) d.push_back(a->left);
if (a->right) d.push_back(a->right);
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def connect(self, root: 'Node') -> 'Node':
ans = root
if root is None:
return ans
d = [root]
while d:
sz = len(d)
for i in range(sz):
a = d.pop(0)
if i != sz - 1:
a.next = d[0]
if a.left:
d.append(a.left)
if a.right:
d.append(a.right)
return ans
```
TypeScript 代码:
```TypeScript
function connect(root: Node | null): Node | null {
let ans = root;
if (root == null) return ans;
const d = [root];
while (d.length > 0) {
let sz = d.length;
while (sz-- > 0) {
const a = d.shift() as Node;
if (sz != 0) a.next = d[0];
if (a.left) d.push(a.left);
if (a.right) d.push(a.right);
}
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### BFS - 逐层构建
上述解法中,每一层节点的 `next` 关系的构建都是独立的。我们构建第 $k$ 层的 `next` 关系时,并没有利用已建好的到第 $k - 1$ 层的 `next` 关系。
实际上,每一层构建好的 `next` 关系都可看做「链表」,可参与到下一层 `next` 关系的构建,同时由于所有节点的起始 `next` 指向都是 `null`,相当于首层的 `next` 关系已经默认建好了。
我们使用图解方式,来感受逐层构建过程:
Java 代码:
```Java
class Solution {
public Node connect(Node root) {
Node ans = root;
if (root == null) return ans;
Node cur = root;
while (cur != null) {
Node head = new Node(-1), tail = head;
for (Node i = cur; i != null; i = i.next) {
if (i.left != null) tail = tail.next = i.left;
if (i.right != null) tail = tail.next = i.right;
}
cur = head.next;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
Node* connect(Node* root) {
auto ans = root;
if (root == nullptr) return ans;
auto cur = root;
while (cur) {
auto head = new Node(-1), tail = head;
for (auto i = cur; i != nullptr; i = i->next) {
if (i->left) tail = tail->next = i->left;
if (i->right) tail = tail->next = i->right;
}
cur = head->next;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def connect(self, root: 'Node') -> 'Node':
ans = root
if not root:
return ans
cur = root
while cur:
head = Node(-1)
tail = head
i = cur
while i:
if i.left:
tail.next = i.left
tail = tail.next
if i.right:
tail.next = i.right
tail = tail.next
i = i.next
cur = head.next
return ans
```
TypeScript 代码:
```TypeScript
function connect(root: Node | null): Node | null {
let ans = root;
if (root == null) return ans;
let cur = root;
while (cur != null) {
let head = new Node(-1), tail = head;
for (let i = cur; i != null; i = i.next) {
if (i.left) tail = tail.next = i.left;
if (i.right) tail = tail.next = i.right;
}
cur = head.next;
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.117` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/119. 杨辉三角 II（简单）.md | 119. 杨辉三角 II | https://leetcode-cn.com/problems/pascals-triangle-ii/solution/dong-tai-gui-hua-luo-ti-chang-jian-de-ko-n2xj/ | 简单 | [
"数学",
"线性 DP"
] | 给定一个非负索引 k,其中 k ≤ 33,返回杨辉三角的第 k 行。
在杨辉三角中,每个数是它左上方和右上方的数的和。
示例:
```
输入: 3
输出: [1,3,3,1]
```
进阶:
* 你可以优化你的算法到 O(k) 空间复杂度吗? | ### 动态规划
```java
class Solution {
public List<Integer> getRow(int idx) {
int[][] f = new int[idx + 1][idx + 1];
f[0][0] = 1;
for (int i = 1; i < idx + 1; i++) {
for (int j = 0; j < i + 1; j++) {
f[i][j] = f[i - 1][j];
if (j - 1 >= 0) f[i][j] += f[i - 1][j - 1];
if (f[i][j] == 0) f[i][j] = 1;
}
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < idx + 1; i++) ans.add(f[idx][i]);
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
***
### 滚动数组
滚动数组优化十分机械,直接将滚动的维度从 `i` 改造为 `i % 2` 或 `i & 1` 即可。
`i & 1` 相比于 `i % 2` 在不同架构的机器上,效率会更稳定些 ~
```java
class Solution {
public List<Integer> getRow(int idx) {
int[][] f = new int[2][idx + 1];
f[0][0] = 1;
for (int i = 1; i < idx + 1; i++) {
for (int j = 0; j < i + 1; j++) {
f[i & 1][j] = f[(i - 1) & 1][j];
if (j - 1 >= 0) f[i & 1][j] += f[(i - 1) & 1][j - 1];
if (f[i & 1][j] == 0) f[i & 1][j] = 1;
}
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < idx + 1; i++) ans.add(f[idx & 1][i]);
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
***
### 一维优化
只有第 `i` 行的更新只依赖于 `i - 1` 行,因此可以直接消除行的维度:
```java
class Solution {
public List<Integer> getRow(int idx) {
int[] f = new int[idx + 1];
f[0] = 1;
for (int i = 1; i < idx + 1; i++) {
for (int j = i; j >= 0; j--) {
if (j - 1 >= 0) f[j] += f[j - 1];
if (f[j] == 0) f[j] = 1;
}
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < idx + 1; i++) ans.add(f[i]);
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.119` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1131-1140/1137. 第 N 个泰波那契数（简单）.md | 1137. 第 N 个泰波那契数 | https://leetcode-cn.com/problems/n-th-tribonacci-number/solution/gong-shui-san-xie-yi-ti-si-jie-die-dai-d-m1ie/ | 简单 | [
"动态规划",
"递归",
"递推",
"矩阵快速幂",
"打表"
] | 泰波那契序列 $T_{n}$ 定义如下:
$T_{0} = 0$, $T_{1} = 1$, $T_{2} = 1$, 且在 $n >= 0$ 的条件下 $T_{n+3} = T_{n} + T_{n+1} + T_{n+2}$
给你整数 $n$,请返回第 $n$ 个泰波那契数 $T_n$ 的值。
示例 1:
```
输入:n = 4
输出:4
解释:
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
```
示例 2:
```
输入:n = 25
输出:1389537
```
提示:
* $0 <= n <= 37$
* 答案保证是一个 $32$ 位整数,即 $answer <= 2^{31} - 1$。 | ### 动态规划(迭代)
都直接给出状态转移方程了,其实就是道模拟题。
使用三个变量,从前往后算一遍即可。
Java 代码:
```Java
class Solution {
public int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
int a = 0, b = 1, c = 1;
for (int i = 3; i <= n; i++) {
int d = a + b + c;
a = b; b = c; c = d;
}
return c;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
int a = 0, b = 1, c = 1;
for (int i = 3; i <= n; i++) {
int d = a + b + c;
a = b; b = c; c = d;
}
return c;
}
};
```
Python 代码:
```Python
class Solution:
def tribonacci(self, n: int) -> int:
if n == 0: return 0
if n == 1 or n == 2: return 1
a, b, c = 0, 1, 1
for i in range(3, n + 1):
d = a + b + c
a, b, c = b, c, d
return c
```
TypeScript 代码:
```TypeScript
function tribonacci(n: number): number {
if (n === 0) return 0;
if (n === 1 || n === 2) return 1;
let a = 0, b = 1, c = 1;
for (let i = 3; i <= n; i++) {
const d = a + b + c;
a = b; b = c; c = d;
}
return c;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 动态规划(递归)
也就是记忆化搜索,创建一个 `cache` 数组用于防止重复计算。
Java 代码:
```Java
class Solution {
int[] cache = new int[40];
public int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
if (cache[n] != 0) return cache[n];
cache[n] = tribonacci(n - 1) + tribonacci(n - 2) + tribonacci(n - 3);
return cache[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> cache = vector<int>(40, 0);
int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
if (cache[n] != 0) return cache[n];
cache[n] = tribonacci(n - 1) + tribonacci(n - 2) + tribonacci(n - 3);
return cache[n];
}
};
```
Python 代码:
```Python
class Solution:
def __init__(self):
self.cache = [0] * 40
def tribonacci(self, n: int) -> int:
if n == 0: return 0
if n == 1 or n == 2: return 1
if self.cache[n] != 0: return self.cache[n]
self.cache[n] = self.tribonacci(n - 1) + self.tribonacci(n - 2) + self.tribonacci(n - 3)
return self.cache[n]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 矩阵快速幂
这还是一道「矩阵快速幂」的板子题。
首先你要对「快速幂」和「矩阵乘法」概念有所了解。
矩阵快速幂用于求解一般性问题:给定大小为 $n \times n$ 的矩阵 $M$,求答案矩阵 $M^k$,并对答案矩阵中的每位元素对 $P$ 取模。
在上述两种解法中,当我们要求解 $f[i]$ 时,需要将 $f[0]$ 到 $f[n - 1]$ 都算一遍,因此需要线性的复杂度。
对于此类的「数列递推」问题,我们可以使用「矩阵快速幂」来进行加速(比如要递归一个长度为 $1e9$ 的数列,线性复杂度会被卡)。
使用矩阵快速幂,我们只需要 $O(\log{n})$ 的复杂度。
根据题目的递推关系($i >= 3$):
$$
f(i) = f(i - 1) + f(i - 2) + f(i - 3)
$$
我们发现要求解 $f(i)$,其依赖的是 $f(i - 1)$、$f(i - 2)$ 和 $f(i - 3)$。
我们可以将其存成一个列向量:
$$
\begin{bmatrix}
f(i - 1)\\
f(i - 2)\\
f(i - 3)
\end{bmatrix}
$$
当我们整理出依赖的列向量之后,不难发现,我们想求的 $f(i)$ 所在的列向量是这样的:
$$
\begin{bmatrix}
f(i)\\
f(i - 1)\\
f(i - 2)
\end{bmatrix}
$$
利用题目给定的依赖关系,对目标矩阵元素进行展开:
$$
\begin{bmatrix}
f(i)\\
f(i - 1)\\
f(i - 2)
\end{bmatrix} = \begin{bmatrix}
f(i - 1) * 1 + f(i - 2) * 1 + f(i - 3) * 1\\
f(i - 1) * 1 + f(i - 2) * 0 + f(i - 3) * 0\\
f(i - 1) * 0 + f(i - 2) * 1 + f(i - 3) * 0
\end{bmatrix}
$$
那么根据矩阵乘法,即有:
$$
\begin{bmatrix}
f(i)\\
f(i - 1)\\
f(i - 2)
\end{bmatrix} = \begin{bmatrix}
1 &1 &1 \\
1 &0 &0 \\
0 &1 &0
\end{bmatrix} * \begin{bmatrix}
f(i - 1)\\
f(i - 2)\\
f(i - 3)
\end{bmatrix}
$$
我们令
$$
Mat = \begin{bmatrix}
1 &1 &1 \\
1 &0 &0 \\
0 &1 &0
\end{bmatrix}
$$
然后发现,利用 $Mat$ 我们也能实现数列递推(公式太难敲了,随便列两项吧):
$$
Mat * \begin{bmatrix}
f(i - 1)\\
f(i - 2)\\
f(i - 3)
\end{bmatrix} = \begin{bmatrix}
f(i)\\
f(i - 1)\\
f(i - 2)
\end{bmatrix}
$$
$$
Mat * \begin{bmatrix}
f(i )\\
f(i - 1)\\
f(i - 2)
\end{bmatrix} = \begin{bmatrix}
f(i + 1)\\
f(i)\\
f(i - 1)
\end{bmatrix}
$$
再根据矩阵运算的结合律,最终有:
$$
\begin{bmatrix}
f(n)\\
f(n - 1)\\
f(n - 2)
\end{bmatrix} = Mat^{n - 2} * \begin{bmatrix}
f(2)\\
f(1)\\
f(0)
\end{bmatrix}
$$
从而将问题转化为求解 $Mat^{n - 2}$ ,这时候可以套用「矩阵快速幂」解决方案。
Java 代码:
```Java
class Solution {
int N = 3;
int[][] mul(int[][] a, int[][] b) {
int[][] c = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
}
}
return c;
}
public int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
int[][] ans = new int[][]{
{1,0,0},
{0,1,0},
{0,0,1}
};
int[][] mat = new int[][]{
{1,1,1},
{1,0,0},
{0,1,0}
};
int k = n - 2;
while (k != 0) {
if ((k & 1) != 0) ans = mul(ans, mat);
mat = mul(mat, mat);
k >>= 1;
}
return ans[0][0] + ans[0][1];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int N = 3;
vector<vector<long long>> mul(vector<vector<long long>>& a, vector<vector<long long>>& b) {
vector<vector<long long>> c(N, vector<long long>(N, 0));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
}
}
return c;
}
int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
vector<vector<long long>> ans = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
vector<vector<long long>> mat = {{1, 1, 1}, {1, 0, 0}, {0, 1, 0}};
int k = n - 2;
while (k != 0) {
if ((k & 1) != 0) ans = mul(ans, mat);
mat = mul(mat, mat);
k >>= 1;
}
return ans[0][0] + ans[0][1];
}
};
```
Python 代码:
```Python
class Solution:
def __init__(self):
self.N = 3
def mul(self, a, b):
c = [[0] * self.N for _ in range(self.N)]
for i in range(self.N):
for j in range(self.N):
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j]
return c
def tribonacci(self, n: int) -> int:
if n == 0: return 0
if n == 1 or n == 2: return 1
ans = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
mat = [[1, 1, 1], [1, 0, 0], [0, 1, 0]]
k = n - 2
while k != 0:
if k & 1: ans = self.mul(ans, mat)
mat = self.mul(mat, mat)
k >>= 1
return ans[0][0] + ans[0][1]
```
TypeScript 代码:
```TypeScript
function tribonacci(n: number): number {
const N = 3;
const mul = function(a: number[][], b: number[][]): number[][] {
const c = Array.from({ length: N }, () => Array(N).fill(0));
for (let i = 0; i < N; i++) {
for (let j = 0; j < N; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
}
}
return c;
};
if (n === 0) return 0;
if (n === 1 || n === 2) return 1;
let ans = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
let mat = [[1, 1, 1], [1, 0, 0], [0, 1, 0]];
let k = n - 2;
while (k !== 0) {
if (k & 1) ans = mul(ans, mat);
mat = mul(mat, mat);
k >>= 1;
}
return ans[0][0] + ans[0][1];
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 打表
当然,我们也可以将数据范围内的所有答案进行打表预处理,然后在询问时直接查表返回。
但对这种题目进行打表带来的收益没有平常打表题的大,因为打表内容不是作为算法必须的一个环节,而直接是作为该询问的答案,但测试样例是不会相同的,即不会有两个测试数据都是 $n = 37$。
这时候打表节省的计算量是不同测试数据之间的相同前缀计算量,例如 $n = 36$ 和 $n = 37$,其 $35$ 之前的计算量只会被计算一次。
因此直接为「解法二」的 `cache` 添加 `static` 修饰其实是更好的方式:代码更短,同时也能起到同样的节省运算量的效果。
Java 代码:
```Java
class Solution {
static int[] cache = new int[40];
static {
cache[0] = 0; cache[1] = 1; cache[2] = 1;
for (int i = 3; i < cache.length; i++) {
cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3];
}
}
public int tribonacci(int n) {
return cache[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
static vector<long long> cache;
Solution() {
cache.resize(40);
cache[0] = 0; cache[1] = 1; cache[2] = 1;
for (int i = 3; i < 40; ++i) {
cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3];
}
}
int tribonacci(int n) {
return static_cast<int>(cache[n]);
}
};
vector<long long> Solution::cache;
```
Python 代码:
```Python
class Solution:
cache = [0, 1, 1] + [0] * 37
for i in range(3, 40):
cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3]
def tribonacci(self, n: int) -> int:
return self.cache[n]
```
* 时间复杂度:将打表逻辑交给 $OJ$,复杂度为 $O(C)$,$C$ 固定为 $40$。将打表逻辑放到本地进行,复杂度为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1141-1150/1143. 最长公共子序列（中等）.md | 1143. 最长公共子序列 | https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/ | 中等 | [
"最长公共子序列",
"LCS",
"序列 DP"
] | 给定两个字符串 `s1` 和 `s2`,返回这两个字符串的最长公共子序列的长度。
如果不存在公共子序列,返回 $0$ 。
一个字符串的子序列是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
* 例如,`"ace"` 是 `"abcde"` 的子序列,但 `"aec"` 不是 `"abcde"` 的子序列。
两个字符串的公共子序列是这两个字符串所共同拥有的子序列。
示例 1:
```
输入:s1 = "abcde", s2 = "ace"
输出:3
解释:最长公共子序列是 "ace" ,它的长度为 3 。
```
示例 2:
```
输入:s1 = "abc", s2 = "abc"
输出:3
解释:最长公共子序列是 "abc" ,它的长度为 3 。
```
示例 3:
```
输入:s1 = "abc", s2 = "def"
输出:0
解释:两个字符串没有公共子序列,返回 0 。
```
提示:
* $1 <= s1.length, s2.length <= 1000$
* `s1` 和 `s2` 仅由小写英文字符组成。 | ### 动态规划(空格技巧)
这是一道「最长公共子序列(LCS)」的裸题。
对于这类题的都使用如下「状态定义」即可:
**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**
当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:
* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表**必然使用 $s1[i]$ 与 $s2[j]$ 时** LCS 的长度。
* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表**必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** LCS 的长度。
一些编码细节:
通常我会习惯性往字符串头部追加一个空格,以减少边界判断(使下标从 1 开始,并很容易构造出可滚动的「有效值」)。
Java 代码:
```Java
class Solution {
public int longestCommonSubsequence(String s1, String s2) {
int n = s1.length(), m = s2.length();
s1 = " " + s1; s2 = " " + s2;
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
int[][] f = new int[n + 1][m + 1];
// 因为有了追加的空格,我们有了显然的初始化值(以下两种初始化方式均可)
// for (int i = 0; i <= n; i++) Arrays.fill(f[i], 1);
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int j = 0; j <= m; j++) f[0][j] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (cs1[i] == cs2[j]) f[i][j] = f[i -1][j - 1] + 1;
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
}
}
// 减去最开始追加的空格
return f[n][m] - 1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int longestCommonSubsequence(string s1, string s2) {
int n = s1.size(), m = s2.size();
s1 = " " + s1, s2 = " " + s2;
int f[n+1][m+1];
memset(f, 0, sizeof(f));
for(int i = 0; i <= n; i++) f[i][0] = 1;
for(int j = 0; j <= m; j++) f[0][j] = 1;
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
if(s1[i] == s2[j]) f[i][j] = max(f[i-1][j-1] + 1, max(f[i-1][j], f[i][j-1]));
else f[i][j] = max(f[i-1][j], f[i][j-1]);
}
}
return f[n][m] - 1;
}
};
```
Python 代码:
```Python
class Solution:
def longestCommonSubsequence(self, s1: str, s2: str) -> int:
n, m = len(s1), len(s2)
s1, s2 = " " + s1, " " + s2
f = [[0] * (m + 1) for _ in range(n + 1)]
for i in range(n + 1): f[i][0] = 1
for j in range(m + 1): f[0][j] = 1
for i in range(1, n + 1):
for j in range(1, m + 1):
if s1[i] == s2[j]:
f[i][j] = f[i - 1][j - 1] + 1
else:
f[i][j] = max(f[i - 1][j], f[i][j - 1])
return f[n][m] - 1
```
TypeScript 代码:
```TypeScript
function longestCommonSubsequence(s1: string, s2: string): number {
const n = s1.length, m = s2.length;
s1 = " " + s1; s2 = " " + s2;
const f = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
for (let i = 0; i <= n; i++) f[i][0] = 1;
for (let j = 0; j <= m; j++) f[0][j] = 1;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1;
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
}
}
return f[n][m] - 1;
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$
---
### 动态规划(利用偏移)
上述「追加空格」的做法只是个人比较习惯的做法。
事实上,我们也可以通过修改「状态定义」来实现递推:
**$f[i][j]$ 代表考虑 $s1$ 的前 $i - 1$ 个字符、考虑 $s2$ 的前 $j - 1$ 的字符,形成的最长公共子序列长度。**
那么最终的 $f[n][m]$ 就是我们的答案,$f[0][0]$ 当做无效值,不处理即可。
* `s1[i-1]==s2[j-1]` : $f[i][j]=f[i-1][j-1]+1$。代表使用 $s1[i-1]$ 与 $s2[j-1]$形成最长公共子序列的长度。
* `s1[i-1]!=s2[j-1]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表不使用 $s1[i-1]$ 形成最长公共子序列的长度、不使用 $s2[j-1]$ 形成最长公共子序列的长度。这两种情况中的最大值。
Java 代码:
```Java
class Solution {
public int longestCommonSubsequence(String s1, String s2) {
int n = s1.length(), m = s2.length();
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
int[][] f = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (cs1[i - 1] == cs2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
}
}
return f[n][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int longestCommonSubsequence(string s1, string s2) {
int m = s1.size(), n = s2.size();
vector<vector<int>> f(m + 1,vector<int>(n + 1,0));
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++){
if(s1[i - 1] == s2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;
else f[i][j] = max(f[i - 1][j],f[i][j - 1]);
}
}
return f[m][n];
}
};
```
Python 代码:
```Python
class Solution:
def longestCommonSubsequence(self, s1: str, s2: str) -> int:
m, n = len(s1), len(s2)
f = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i - 1] == s2[j - 1]:
f[i][j] = f[i - 1][j - 1] + 1
else:
f[i][j] = max(f[i - 1][j],f[i][j - 1])
return f[m][n]
```
TypeScript 代码:
```TypeScript
function longestCommonSubsequence(s1: string, s2: string): number {
const n = s1.length, m = s2.length;
const cs1 = s1.split(''), cs2 = s2.split('');
const f: number[][] = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (cs1[i - 1] == cs2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;
else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
}
}
return f[n][m];
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1143` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1151-1160/1154. 一年中的第几天（简单）.md | 1154. 一年中的第几天 | https://leetcode-cn.com/problems/day-of-the-year/solution/gong-shui-san-xie-jian-dan-qian-zhui-he-lwo2g/ | 简单 | [
"前缀和",
"模拟"
] | 给你一个字符串 `date`,按 `YYYY-MM-DD` 格式表示一个 现行公元纪年法 日期。
请你计算并返回该日期是当年的第几天。
通常情况下,我们认为 `1` 月 `1` 日是每年的第 `1` 天,`1` 月 `2` 日是每年的第 `2` 天,依此类推。每个月的天数与现行公元纪年法(格里高利历)一致。
示例 1:
```
输入:date = "2019-01-09"
输出:9
```
示例 2:
```
输入:date = "2019-02-10"
输出:41
```
示例 3:
```
输入:date = "2003-03-01"
输出:60
```
示例 4:
```
输入:date = "2004-03-01"
输出:61
```
提示:
* `date.length == 10`
* `date[4] == date[7] == '-'`,其他的 `date[i]` 都是数字
* `date` 表示的范围从 `1900` 年 `1` 月 `1` 日至 `2019` 年 `12` 月 `31` 日 | ### 模拟
根据题意进行模拟即可。
由于每年月份的天数都相对固定(仅有闰年 $2$ 月份不同),因此我们可以使用 `static` 进行打表预处理。
使用 `nums` 构建一个平年的月份数组,再通过「前缀和」得到平年的每个月的天数总和。
最后将 `date` 按照 `-` 分割为年月日,分别进行计数。
注意,当年份为闰年且当前月份超过了 $2$ 月份,要追加一天。
代码:
```Java
class Solution {
static int[] nums = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static int[] f = new int[13];
static {
for (int i = 1; i <= 12; i++) f[i] = f[i - 1] + nums[i - 1];
}
public int dayOfYear(String date) {
String[] ss = date.split("-");
int y = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]), d = Integer.parseInt(ss[2]);
boolean isLeap = (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
int ans = m > 2 && isLeap ? f[m - 1] + 1 : f[m - 1];
return ans + d;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1151-1160/1155. 掷骰子的N种方法（中等）.md | 1155. 掷骰子的N种方法 | https://leetcode-cn.com/problems/number-of-dice-rolls-with-target-sum/solution/dong-tai-gui-hua-bei-bao-wen-ti-yun-yong-axtf/ | 中等 | [
"背包问题",
"动态规划",
"分组背包"
] | 这里有 d 个一样的骰子,每个骰子上都有 f 个面,分别标号为 `1,2,...,f`。
我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。
如果需要掷出的总点数为 target,请你计算出有多少种不同的组合情况(所有的组合情况总共有 $f^d$ 种),模 $10^9 + 7$ 后返回。
示例 1:
```
输入:d = 1, f = 6, target = 3
输出:1
```
示例 2:
```
输入:d = 2, f = 6, target = 7
输出:6
```
示例 3:
```
输入:d = 2, f = 5, target = 10
输出:1
```
示例 4:
```
输入:d = 1, f = 2, target = 3
输出:0
```
示例 5:
```
输入:d = 30, f = 30, target = 500
输出:222616187
```
提示:
* 1 <= d, f <= 30
* 1 <= target <= 1000 | ### 分组背包
在 [分组背包问题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487504&idx=1&sn=9ac523ec0ac14c8634a229f8c3f919d7&chksm=fd9cbb0fcaeb32196b80a40e4408f6a7e2651167e0b9e31aa6d7c6109fbc2117340a59db12a1&token=1936267333&lang=zh_CN#rd) 中我们提到,分组背包不仅仅有「组内物品最多选择一个」的情况,还存在「组内物品必须选择一个」的情况。
对于本题,可以将每个骰子看作一个物品组,且每次 **必须** 从物品组中选择一个物品(所掷得的数值大小视作具体物品)。
这样就把问题转换为:**用 $d$ 个骰子(物品组)进行掷,掷出总和(取得的总价值)为 $t$ 的方案数。**
虽然,我们还没专门讲过「背包问题求方案数」,但基本分析与「背包问题求最大价值」并无本质区别。
我们可以套用「分组背包求最大价值」的状态定义来微调:**$f[i][j]$ 表示考虑前 $i$ 个物品组,凑成价值为 $j$ 的方案数。**
为了方便,我们令物品组的编号从 $1$ 开始,因此有显而易见的初始化条件 $f[0][0] = 1$。
代表在不考虑任何物品组的情况下,只有凑成总价值为 $0$ 的方案数为 $1$,凑成其他总价值的方案不存在。
**不失一般性考虑 $f[i][j]$ 该如何转移,也就是考虑第 $i$ 个物品组有哪些决策。**
根据题意,对于第 $i$ 个物品组而言,可能决策的方案有:
* 第 $i$ 个骰子的结果为 $1$,有 $f[i][j] = f[i - 1][j - 1]$
* 第 $i$ 个骰子的结果为 $2$,有 $f[i][j] = f[i - 1][j - 2]$
...
* 第 $i$ 个骰子的结果为 $m$,有 $f[i][j] = f[i - 1][j - m]$
$f[i][j]$ 则是上述所有可能方案的方案数总和,即有:
$$
f[i][j] = \sum_{k = 1}^{m}f[i - 1][j - k], j >= k
$$
#### 朴素二维
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numRollsToTarget(int n, int m, int t) {
int[][] f = new int[n + 1][t + 1];
f[0][0] = 1;
// 枚举物品组(每个骰子)
for (int i = 1; i <= n; i++) {
// 枚举背包容量(所掷得的总点数)
for (int j = 0; j <= t; j++) {
// 枚举决策(当前骰子所掷得的点数)
for (int k = 1; k <= m; k++) {
if (j >= k) {
f[i][j] = (f[i][j] + f[i-1][j-k]) % mod;
}
}
}
}
return f[n][t];
}
}
```
* 时间复杂度:$O(n * m * t)$
* 空间复杂度:$O(n * t)$
#### 滚动数组
根据状态转移方程,我们发现 $f[i][j]$ 明确只依赖于 $f[i - 1][x]$,且 $x < j$。
因此我们可以使用之前学过的「滚动数组」,用很机械的方式将空间从 $O(n * t)$ 优化至 $O(t)$。
需要注意的是,由于我们直接是在 $f[i][j]$ 格子的基础上进行方案数累加,因此在计算 $f[i][j]$ 记得手动置零。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numRollsToTarget(int n, int m, int t) {
int[][] f = new int[2][t + 1];
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
int a = i & 1, b = (i - 1) & 1;
for (int j = 0; j <= t; j++) {
f[a][j] = 0; // 先手动置零
for (int k = 1; k <= m; k++) {
if (j >= k) {
f[a][j] = (f[a][j] + f[b][j-k]) % mod;
}
}
}
}
return f[n&1][t];
}
}
```
* 时间复杂度:$O(n * m * t)$
* 空间复杂度:$O(t)$
#### 一维空间优化
更进一步,利用「$f[i][j]$ 明确只依赖于 $f[i - 1][x]$,且 $x < j$ 」,我们能通过「[01 背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485638&idx=1&sn=d7468955c5b121664031fd5c1b5a6f10&chksm=fd9ca3d9caeb2acf2dd4e9f512b2d4dc820107489a094749ffe7cae646f0cc60de06f2d18898&token=800772286&lang=zh_CN#rd)」一维空间优化方式:**将物品维度取消,调整容量维度遍历顺序为「从大到小」。**
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numRollsToTarget(int n, int m, int t) {
int[] f = new int[t + 1];
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = t; j >= 0; j--) {
f[j] = 0;
for (int k = 1; k <= m; k++) {
if (j >= k) {
f[j] = (f[j] + f[j-k]) % mod;
}
}
}
}
return f[t];
}
}
```
* 时间复杂度:$O(n * m * t)$
* 空间复杂度:$O(t)$
---
### 总结
不难发现,不管是「组内物品最多选一件」还是「组内物品必须选一件」。
我们都是直接套用分组背包基本思路 *「枚举物品组-枚举容量-枚举决策」* 进行求解。
**分组背包的空间优化并不会降低时间复杂度,所以对于分组背包问题,我们可以直接写方便调试的朴素多维版本(在空间可接受的情况下),如果遇到卡空间,再通过机械的方式改为「滚动数组」形式。**
另外今天我们使用「分组背包问题求方案数」来作为「分组背包问题求最大价值」的练习题。
可以发现,两者其实并无本质区别,都是套用「背包问题求最大价值」的状态定义来微调。
更多的关于「背包问题求方案数」相关内容,在后面也会继续细讲。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1161-1170/1161. 最大层内元素和（中等）.md | 1161. 最大层内元素和 | https://leetcode.cn/problems/maximum-level-sum-of-a-binary-tree/solution/by-ac_oier-aemz/ | 中等 | [
"层序遍历",
"BFS"
] | 给你一个二叉树的根节点 `root`。设根节点位于二叉树的第 $1$ 层,而根节点的子节点位于第 $2$ 层,依此类推。
请返回层内元素之和 最大 的那几层(可能只有一层)的层号,并返回其中 最小 的那个。
示例 1:
```
输入:root = [1,7,0,7,-8,null,null]
输出:2
解释:
第 1 层各元素之和为 1,
第 2 层各元素之和为 7 + 0 = 7,
第 3 层各元素之和为 7 + -8 = -1,
所以我们返回第 2 层的层号,它的层内元素之和最大。
```
示例 2:
```
输入:root = [989,null,10250,98693,-89388,null,null,null,-32127]
输出:2
```
提示:
* 树中的节点数在 $[1, 10^4]$范围内
* $-10^5 <= Node.val <= 10^5$ | ### 层序遍历
根据题意,使用 `BFS` 进行层序遍历即可。
每次以「层」为单位进行拓展,统计该层的元素和,维护处理过程中的最大值层数和,以及层深度。
Java 代码:
```Java
class Solution {
public int maxLevelSum(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
int max = -0x3f3f3f3f, depth = 1, ans = 0;
d.addLast(root);
while (!d.isEmpty()) {
int sz = d.size(), cur = 0;
while (sz-- > 0) {
TreeNode t = d.pollFirst();
if (t.left != null) d.addLast(t.left);
if (t.right != null) d.addLast(t.right);
cur += t.val;
}
if (cur > max) {
max = cur; ans = depth;
}
depth++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maxLevelSum(root: TreeNode | null): number {
const d: TreeNode[] = new Array<TreeNode>()
let he = 0, ta = 0
d[ta++] = root
let max = -0x3f3f3f3f, depth = 1, ans = 0
while (he < ta) {
let sz = ta - he, cur = 0
while (sz-- > 0) {
const t = d[he++]
if (t.left != null) d[ta++] = t.left
if (t.right != null) d[ta++] = t.right
cur += t.val
}
if (cur > max) {
max = cur; ans = depth
}
depth++
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1161-1170/1162. 地图分析（中等）.md | 1162. 地图分析 | https://leetcode-cn.com/problems/as-far-from-land-as-possible/solution/gong-shui-san-xie-ru-he-shi-yong-duo-yua-vlea/ | 中等 | [
"图论 BFS",
"多源 BFS"
] | 你现在手里有一份大小为 $N \times N$ 的 网格 $grid$,上面的每个 单元格 都用 $0$ 和 $1$ 标记好了。
其中 $0$ 代表海洋,$1$ 代表陆地,请你找出一个海洋单元格,这个海洋单元格到离它最近的陆地单元格的距离是最大的。
我们这里说的距离是「曼哈顿距离」:$(x_0, y_0)$ 和 $(x_1, y_1)$ 这两个单元格之间的距离是 $|x_0 - x_1| + |y_0 - y_1|$。
如果网格上只有陆地或者海洋,请返回 $-1$。
示例 1:
```
输入:[[1,0,1],[0,0,0],[1,0,1]]
输出:2
解释:海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到最大,最大距离为 2。
```
示例 2:
```
输入:[[1,0,0],[0,0,0],[0,0,0]]
输出:4
解释:海洋单元格 (2, 2) 和所有陆地单元格之间的距离都达到最大,最大距离为 4。
```
提示:
* 1 <= grid.length == grid[0].length <= 100
* `grid[i][j]` 不是 $0$ 就是 $1$ | ### 单源 BFS
通常我们使用 BFS 求最短路,都是针对如下场景:从特定的起点出发,求解到达特定终点的最短距离。
**这是一类特殊的「单源最短路」问题:本质是在一个边权为 $1$ 的图上,求从特定「源点」出发到达特定「汇点」的最短路径。**
对于本题,如果套用「单源最短路」做法,我们需要对每个「海洋」位置做一次 BFS:求得每个「海洋」的最近陆地距离,然后在所有的距离中取 $max$ 作为答案。
单次 BFS 的最坏情况需要扫描完整个矩阵,复杂度为 $O(n^2)$。
同时,最多有 $n^2$ 个海洋区域需要做 BFS,因此这样的做法复杂度为 $O(n^4)$,并且 $O(n^4)$ 可直接取满。
PS. 数据范围为 $10^2$,理论上是一定会超时,但本题数据较弱,Java 2021/06/28 可过。
一些细节:为了方便,我们在使用哈希表记录距离时,将二维坐标 $(x, y)$ 转化为对应的一维下标 $idx = x \times n + y$ 作为 key 进行存储。
代码:
```Java
class Solution {
int n;
int[][] grid;
public int maxDistance(int[][] _grid) {
grid = _grid;
n = grid.length;
int ans = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 0) {
ans = Math.max(ans, bfs(i, j));
}
}
}
return ans;
}
// 单次 BFS:求解海洋位置 (x,y) 最近的陆地距离
int bfs(int x, int y) {
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
Deque<int[]> d = new ArrayDeque<>();
Map<Integer, Integer> map = new HashMap<>();
d.addLast(new int[]{x, y});
map.put(x * n + y, 0);
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int dx = poll[0], dy = poll[1];
int step = map.get(dx * n + dy);
if (grid[dx][dy] == 1) return step;
for (int[] di : dirs) {
int nx = dx + di[0], ny = dy + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
int key = nx * n + ny;
if (map.containsKey(key)) continue;
d.addLast(new int[]{nx, ny});
map.put(key, step + 1);
}
}
return -1;
}
}
```
* 时间复杂度:$O(n^4)$
* 空间复杂度:$O(n^2)$
---
### 多源 BFS
这其实还是道「多源 BFS」入门题。
**与「单源最短路」不同,「多源最短路」问题是求从「多个源点」到达「一个/多个汇点」的最短路径。**
在实现上,最核心的搜索部分,「多源 BFS」与「单源 BFS」并无区别。
**并且通过建立「虚拟源点」的方式,我们可以「多源 BFS」转换回「单源 BFS」问题。**
什么意思?
以本题为例,题面要我们求每个「海洋」区域到最近的「陆地」区域的最大值。
我们可以将「源点/起点」和「汇点/终点」进行反转:**从每个「陆地」区域出发,多个「陆地」区域每次同时向往扩散一圈,每个「海洋」区域被首次覆盖时所对应的圈数,就是「海洋」区域距离最近的「陆地」区域的距离。**
不过,这是如何与「单源 BFS」联系起来的呢?
我们可以想象存在一个「虚拟源点」,其与所有「真实源点」(陆地)存在等权的边,那么任意「海洋」区域与「最近的陆地」区域的最短路等价于与「虚拟源点」的最短路:
**实现上,我们并不需要真的将这个虚拟源点建立出来,只需要将所有的「真实源点」进行入队即可。**
这个过程相当于从队列中弹出「虚拟源点」,并把它所能到点(真实源点)进行入队,然后再进行常规的 BFS 即可。
一些细节:实现上为了方便,在进行常规 BFS 时,如果一个「海洋」区域被访问到,说明其被离它「最近的陆地」覆盖到了,修改值为最小距离。这样我们只需要考虑那些值仍然为 $0$ 的「海洋」区域即可(代表尚未被更新)。
代码:
```Java
class Solution {
public int maxDistance(int[][] grid) {
int n = grid.length;
Deque<int[]> d = new ArrayDeque<>();
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 1) {
d.add(new int[]{i, j});
map.put(i * n + j, 0);
}
}
}
int ans = -1;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
while (!d.isEmpty()) {
int[] poll = d.poll();
int dx = poll[0], dy = poll[1];
int step = map.get(dx * n + dy);
for (int[] di : dirs) {
int nx = dx + di[0], ny = dy + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
if (grid[nx][ny] != 0) continue;
grid[nx][ny] = step + 1;
d.add(new int[]{nx, ny});
map.put(nx * n + ny, step + 1);
ans = Math.max(ans, step + 1);
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 总结
今天我们介绍了「多源 BFS」,通过建立「虚拟源点」,我们可以将其转化回「单源 BFS」问题。
实现上我们只需要将所有的「真实源点」进行入队,然后再进行 BFS 即可。
看起来两者区别不大,但其本质是通过源点/汇点转换,应用常规的 Flood Fill 将多次朴素 BFS 转化为一次 BFS,可以有效降低我们算法的时间复杂度。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1171-1180/1175. 质数排列（简单）.md | 1175. 质数排列 | https://leetcode.cn/problems/prime-arrangements/solution/by-ac_oier-t3lk/ | 简单 | [
"数学",
"组合数",
"二分",
"打表"
] | 请你帮忙给从 $1$ 到 $n$ 的数设计排列方案,使得所有的「质数」都应该被放在「质数索引」(索引从 $1$ 开始)上;你需要返回可能的方案总数。
让我们一起来回顾一下「质数」:质数一定是大于 $1$ 的,并且不能用两个小于它的正整数的乘积来表示。
由于答案可能会很大,所以请你返回答案 模 `mod` $10^9 + 7$ 之后的结果即可。
示例 1:
```
输入:n = 5
输出:12
解释:举个例子,[1,2,5,4,3] 是一个有效的排列,但 [5,2,3,4,1] 不是,因为在第二种情况里质数 5 被错误地放在索引为 1 的位置上。
```
示例 2:
```
输入:n = 100
输出:682289015
```
提示:
* $1 <= n <= 100$ | ### 打表 + 二分 + 数学
根据题意,可将问题转换为求 $n$ 以内的质数个数,记为 $a$,同时可得非质数个数为 $b = n - a$。
质数的放置方案数为 $a!$,而非质数的放置方案数为 $b!$,根据「乘法原理」总的放置方案数为 $a! \times b!$。
我们可以通过「打表」的方式将 $100$ 以内的质数预处理到数组 `list` 中,对于每个 $n$ 而言,我们找到第一个满足「值小于等于 $n$」的位置,从而得知 $n$ 范围以内的质数个数。
代码:
```Java
class Solution {
static int MOD = (int)1e9+7;
static List<Integer> list = new ArrayList<>();
static {
for (int i = 2; i <= 100; i++) {
boolean ok = true;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) ok = false;
}
if (ok) list.add(i);
}
}
public int numPrimeArrangements(int n) {
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid) <= n) l = mid;
else r = mid - 1;
}
int a = r + 1, b = n - a;
long ans = 1;
for (int i = b; i > 1; i--) ans = ans * i % MOD ;
for (int i = a; i > 1; i--) ans = ans * i % MOD ;
return (int)ans;
}
}
```
* 时间复杂度:二分的复杂度为 $O(\log{C})$,其中 $C = 25$ 为 $100$ 以内的质数个数;计算方案数的复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(C)$,其中 $C = 25$ 为 $100$ 以内的质数个数
---
### 打表 + 数学
更进一步,对于特定的 $n$ 而言,我们在预处理 $100$ 以内的质数时,已经可以确定在 $[1, n]$ 内有多少个质数,从而省掉二分操作。
使用数组 `cnts` 记录下不超过当前值范围内质数的个数,$cnts[i] = x$ 含义为在 $[1, i]$ 范围内质数数量为 $x$。
代码:
```Java
class Solution {
static int MOD = (int)1e9+7;
static int[] cnts = new int[110];
static {
List<Integer> list = new ArrayList<>();
for (int i = 2; i <= 100; i++) {
boolean ok = true;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) ok = false;
}
if (ok) list.add(i);
cnts[i] = list.size();
}
}
public int numPrimeArrangements(int n) {
int a = cnts[n], b = n - a;
long ans = 1;
for (int i = b; i > 1; i--) ans = ans * i % MOD ;
for (int i = a; i > 1; i--) ans = ans * i % MOD ;
return (int)ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 100$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1175` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1171-1180/1178. 猜字谜（困难）.md | 1178. 猜字谜 | https://leetcode-cn.com/problems/number-of-valid-words-for-each-puzzle/solution/xiang-jin-zhu-shi-xiang-jie-po-su-wei-yu-3cr2/ | 困难 | [
"状态压缩",
"位运算",
"哈希表"
] | 外国友人仿照中国字谜设计了一个英文版猜字谜小游戏,请你来猜猜看吧。
字谜的迷面 puzzle 按字符串形式给出,如果一个单词 word 符合下面两个条件,那么它就可以算作谜底:
* 单词 word 中包含谜面 puzzle 的第一个字母。
* 单词 word 中的每一个字母都可以在谜面 puzzle 中找到。
例如,如果字谜的谜面是 "abcdefg",那么可以作为谜底的单词有 "faced", "cabbage", 和 "baggage";而 "beefed"(不含字母 "a")以及 "based"(其中的 "s" 没有出现在谜面中)都不能作为谜底。
返回一个答案数组 answer,数组中的每个元素 answer[i] 是在给出的单词列表 words 中可以作为字谜迷面 puzzles[i] 所对应的谜底的单词数目。
示例:
```
输入:
words = ["aaaa","asas","able","ability","actt","actor","access"],
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
输出:[1,1,3,2,4,0]
解释:
1 个单词可以作为 "aboveyz" 的谜底 : "aaaa"
1 个单词可以作为 "abrodyz" 的谜底 : "aaaa"
3 个单词可以作为 "abslute" 的谜底 : "aaaa", "asas", "able"
2 个单词可以作为 "absoryz" 的谜底 : "aaaa", "asas"
4 个单词可以作为 "actresz" 的谜底 : "aaaa", "asas", "actt", "access"
没有单词可以作为 "gaswxyz" 的谜底,因为列表中的单词都不含字母 'g'。
```
提示:
* 1 <= words.length <= $10^5$
* 4 <= words[i].length <= 50
* 1 <= puzzles.length <= $10^4$
* puzzles[i].length == 7
* words[i][j], puzzles[i][j] 都是小写英文字母。
* 每个 puzzles[i] 所包含的字符都不重复。 | ### 朴素位运算解法(TLE)
根据「谜底」和「谜面」的对应条件:
* 单词 `word` 中包含谜面 `puzzle` 的第一个字母。
* 单词 `word` 中的每一个字母都可以在谜面 `puzzle` 中找到
`puzzle` 本身长度只有 7 位,而且不重复;我们可以发现对应条件与 `word` 的重复字母无关。
因此我们可以使用「二进制」数来表示每一个 `word` 和 `puzzle`:
一个长度为 26 的二进制数来表示(直接使用长度为 32 的 int 即可,使用低 26 位),假如有 `str = "abz"` 则对应了 `100...011`(共 26 位,从右往左是 a - z)。
至此我们可以已经可以得出一个朴素解法的思路了:
1. 预处理除所有的 `word` 对应的二进制数字。计算量为 50 * $10^5$,数量级为 $10^6$
2. 对每个 `puzzle` 进行条件判定(每一个 `puzzle` 都需要遍历所有的 `word` 进行检查)。计算量为 $10^5$ * $10^4$,数量级为 $10^9$
计算机单秒的计算量为 $10^7$ 左右(OJ 测评器通常在 $10^6$ ~ $10^7$ 之间),哪怕忽略常数后,我们的总运算也超过了上限,铁定超时。
代码:
```java
class Solution {
public List<Integer> findNumOfValidWords(String[] ws, String[] ps) {
// 预处理出所有的 word 所对应的二进制数值
List<Integer> list = new ArrayList<>();
for (String w : ws) list.add(getBin(w));
// 判定每个 puzzles 有多少个谜底
List<Integer> ans = new ArrayList<>();
for (String p : ps) ans.add(getCnt(list, p));
return ans;
}
// 判定某个 puzzles 有多少个谜底
int getCnt(List<Integer> ws, String str) {
int ans = 0;
// 获取当前 puzzles 对应的二进制数字
int t = getBin(str);
// 当前 puzzles 的首个字符在二进制数值中的位置
int first = str.charAt(0) - 'a';
for (int w : ws) {
// check 条件一:单词 word 中包含谜面 puzzle 的第一个字母
if ((w >> first & 1) == 0) continue;
// check 条件二:单词 word 中的每一个字母都可以在谜面 puzzle 中找到
if ((w & t) == w) ans++;
}
return ans;
}
// 将 str 所包含的字母用二进制标识
// 如果 str = abz 则对应的二进制为 100...011 (共 26 位,从右往左是 a - z)
int getBin(String str) {
int t = 0;
char[] cs = str.toCharArray();
for (char c : cs) {
// 每一位字符所对应二进制数字中哪一位
int u = c - 'a';
// 如果当前位置为 0,代表还没记录过,则进行记录 (不重复记录)
if ((t >> u & 1) == 0) t += 1 << u;
}
return t;
}
}
```
* 时间复杂度:$O(words.length * (words[i].length + puzzles.length))$
* 空间复杂度:每个 `word` 对应了一个 int,每个 `puzzle` 对应了一个答案。复杂度为 $O(words.length + puzzles.length)$
***
### 哈希表 & 位运算解法
因此我们需要优化上述步骤 1 或者步骤 2 。显然超时的主要原因是步骤 2 计算量太多了。
一个很显眼的突破口是利用 `puzzles[i].length == 7`,同时判定条件 1 对 `puzzle` 的首字母进行了限定。
**对于一个确定的 `puzzle` 而言,我们要找它有多少个「谜底」。可以通过枚举它所有可能的「谜底」,再去 `words` 里面找每一个「谜底」出现了多少次。**
**结合题意的话,就是固定住 `puzzle` 的首位,去枚举其余后面的 6 位的所有的可能性(每一位都有保留和不保留两种选择),即枚举子集的过程。**
你可能还是无法理解,其实就是一个通过 `puzzle` 反推 `word` 的过程:
举个🌰吧,假如我们有 `puzzle` 是 `gabc`(假定现在的 `puzzle` 长度只有 4) ,那么可能的 `word` 有哪些?
1. 首先要满足条件一,也就是 `word` 必然包含首字母 `g`;
2. 然后是条件二,`word` 中的每一位都在 `puzzle` 出现过,因此可能的 `word` 包括 `g`、`ga`、`gb`、`gc`、`gab`、`gac`、`gbc`、`gabc`。
使用 1 和 0 代表 `puzzle` 每一位选择与否的话,其实就是对应了 1000、1100、1010、1001、1110、1101、1011、1111。
搞明白了这个过程之后,我们需要对 `words` 进行词频统计,我们可以使用「哈希表」记录相同含义的 `word` 出现了多少次(相同含义的意思是包含字母类型一样的 `word`,因为答案和 `word` 的重复字符无关)
这样做的复杂度/计算量是多少呢?
1. 统计所有 `word` 的词频。计算量为 50 * $10^5$,数量级为 $10^6$
2. 对应每个 `puzzle` 而言,由于其长度确定为 7,因此所有枚举所有可能「谜底」的数量不为 $2^6$=64 个,可以看做是 $O(1)$ 的,检查每个可能的「谜底」在 `words` 出现次数是通过哈希表,也是近似 $O(1)$ 的。因此在确定一个 `puzzle` 的答案时,与 `words` 的长度无关。计算量为 $10^4$,数量级为 $10^4$
计算机单秒的计算量为 $10^7$ 左右(OJ 测评器通常在 $10^6$ ~ $10^7$ 之间),因此可以过。
代码:
```java
class Solution {
public List<Integer> findNumOfValidWords(String[] ws, String[] ps) {
// 转用 「哈希表」来统计出所有的 word 所对应的二进制数值
Map<Integer, Integer> map = new HashMap<>();
for (String w : ws) {
int t = getBin(w);
map.put(t, map.getOrDefault(t, 0) + 1);
}
// 判定每个 puzzle 有多少个谜底
List<Integer> ans = new ArrayList<>();
for (String p : ps) ans.add(getCnt(map, p));
return ans;
}
int getCnt(Map<Integer, Integer> map, String str) {
int ans = 0;
int m = str.length();
char[] cs = str.toCharArray();
// 当前 puzzle 的首个字符在二进制数值中的位置
int first = cs[0] - 'a';
// 枚举「保留首个字母」的所有子集
// 即我们需要先固定 puzzle 的首位字母,然后枚举剩余的 6 位是否保留
// 由于是二进制,每一位共有 0 和 1 两种选择,因此共有 2^6 种可能性,也就是 2^6 = 1 << (7 - 1) = 64 种
// i 代表了所有「保留首个字母」的子集的「后六位」的二进制表示
for (int i = 0; i < (1 << (m - 1)); i++) {
// u 代表了当前可能的谜底。先将首字母提取出来
int u = 1 << first;
// 枚举「首个字母」之后的每一位
for (int j = 1; j < m; j++) {
// 如果当前位为 1,代表该位置要保留,将该位置的字母追加到谜底 u 中
if (((i >> (j - 1)) & 1) != 0) u += 1 << (cs[j] - 'a');
}
// 查询这样的字符是否出现在 `words` 中,出现了多少次
if (map.containsKey(u)) ans += map.get(u);
}
return ans;
}
// 将 str 所包含的字母用二进制标识
// 如果 str = abz 则对应的二进制为 100...011 (共 26 位,从右往左是 a - z)
int getBin(String str) {
int t = 0;
char[] cs = str.toCharArray();
for (char c : cs) {
// 每一位字符所对应二进制数字中哪一位
int u = c - 'a';
// 如果当前位置为 0,代表还没记录过,则进行记录 (不重复记录)
if ((t >> u & 1) == 0) t += 1 << u;
}
return t;
}
}
```
* 时间复杂度:$O(words.length * words[i].length + puzzles.length)$
* 空间复杂度:`word` 和 `puzzle` 分别具有最大长度和固定长度,使用空间主要取决于量数组的长度。复杂度为 $O(words.length + puzzles.length)$
***
### 位运算说明
a >> b & 1 代表检查 a 的第 b 位是否为 1,有两种可能性 0 或者 1
a += 1 << b 代表将 a 的第 b 位设置为 1 (当第 b 位为 0 的时候适用)
如不想写对第 b 位为 0 的前置判断,a += 1 << b 也可以改成 a |= 1 << b
*PS. 1 的二进制就是最低位为 1,其他位为 0 哦*
以上两个操作在位运算中出现频率超高,建议每位同学都加深理解。
***
### 点评
这道题解发到 LeetCode 之后,很多同学反映还是看不懂,还是不理解。
于是我重新的思考了这道题的每一个环节。
这道题之所是 Hard,是因为考察的都是违反人性”直觉”的东西:
1. 状态压缩:对一个单词出现过哪些字母,不能采用我们直观中的 map/set 进行记录,而要利用一个长度为 26 的二进制数来记录,对于某个字母需要计算在二进制数中的哪一位,如果出现过用 1 表示,没出现过用 0 表示
2. 正难则反:不能从 `words` 数组出发,去检查有哪些 `word` 符合要求;而要反过来从 `puzzle` 出发,去枚举当前 `puzzle` 所有合法的 `word`,再去确定这些合法的 `word` 在真实的 `words` 数组中出现了多少次
大家要尽量去理解这种思路的合理性,当这种思路也形成意识的时候,这种题也就不难了。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1178` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1184. 公交站间的距离（简单）.md | 1184. 公交站间的距离 | https://leetcode.cn/problems/distance-between-bus-stops/solution/by-ac_oier-fow3/ | 简单 | [
"模拟"
] | 环形公交路线上有 $n$ 个站,按次序从 $0$ 到 $n - 1$ 进行编号。我们已知每一对相邻公交站之间的距离,$distance[i]$ 表示编号为 $i$ 的车站和编号为 `(i + 1) % n` 的车站之间的距离。
环线上的公交车都可以按顺时针和逆时针的方向行驶。
返回乘客从出发点 `start` 到目的地 `destination` 之间的最短距离。
示例 1:
```
输入:distance = [1,2,3,4], start = 0, destination = 1
输出:1
解释:公交站 0 和 1 之间的距离是 1 或 9,最小值是 1。
```
示例 2:
```
输入:distance = [1,2,3,4], start = 0, destination = 2
输出:3
解释:公交站 0 和 2 之间的距离是 3 或 7,最小值是 3。
```
示例 3:
```
输入:distance = [1,2,3,4], start = 0, destination = 3
输出:4
解释:公交站 0 和 3 之间的距离是 6 或 4,最小值是 4。
```
提示:
* $1 <= n <= 10^4$
* $distance.length == n$
* $0 <= start, destination < n$
* $0 <= distance[i] <= 10^4$ | ### 模拟
根据题意进行模拟即可。
用 `i` 和 `j` 分别代表往前和往后走的指针,`a` 和 `b` 分别统计两种走法的总成本。
Java 代码:
```Java
class Solution {
public int distanceBetweenBusStops(int[] dist, int s, int t) {
int n = dist.length, i = s, j = s, a = 0, b = 0;
while (i != t) {
a += dist[i];
if (++i == n) i = 0;
}
while (j != t) {
if (--j < 0) j = n - 1;
b += dist[j];
}
return Math.min(a, b);
}
}
```
TypeScript 代码:
```TypeScript
function distanceBetweenBusStops(dist: number[], s: number, t: number): number {
let n = dist.length, i = s, j = s, a = 0, b = 0
while (i != t) {
a += dist[i]
if (++i == n) i = 0
}
while (j != t) {
if (--j < 0) j = n - 1
b += dist[j]
}
return Math.min(a, b)
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1184` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1185. 一周中的第几天（简单）.md | 1185. 一周中的第几天 | https://leetcode-cn.com/problems/day-of-the-week/solution/gong-shui-san-xie-jian-dan-ri-qi-tong-ji-czt6/ | 简单 | [
"模拟"
] | 给你一个日期,请你设计一个算法来判断它是对应一周中的哪一天。
输入为三个整数:`day`、`month` 和 `year`,分别表示日、月、年。
您返回的结果必须是这几个值中的一个 `{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}`。
示例 1:
```
输入:day = 31, month = 8, year = 2019
输出:"Saturday"
```
示例 2:
```
输入:day = 18, month = 7, year = 1999
输出:"Sunday"
```
示例 3:
```
输入:day = 15, month = 8, year = 1993
输出:"Sunday"
```
提示:
给出的日期一定是在 `1971` 到 `2100` 年之间的有效日期。 | ### 模拟
题目保证日期是在 `1971` 到 `2100` 之间,我们可以计算给定日期距离 `1970` 的最后一天(星期四)间隔了多少天,从而得知给定日期是周几。
具体的,可以先通过循环处理计算年份在 $[1971, year - 1]$ 时间段,经过了多少天(注意平年为 $365$,闰年为 $366$);然后再处理当前年 $year$ 的月份在 $[1, month - 1]$ 时间段 ,经过了多少天(注意当天年是否为闰年,特殊处理 $2$ 月份),最后计算当前月 $month$ 经过了多少天,即再增加 $day$ 天。
得到距离 `1970` 的最后一天(星期四)的天数后进行取模,即可映射回答案。
代码:
```Java
class Solution {
static String[] ss = new String[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
static int[] nums = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
public String dayOfTheWeek(int day, int month, int year) {
int ans = 4;
for (int i = 1971; i < year; i++) {
boolean isLeap = (i % 4 == 0 && i % 100 != 0) || i % 400 == 0;
ans += isLeap ? 366 : 365;
}
for (int i = 1; i < month; i++) {
ans += nums[i - 1];
if (i == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) ans++;
}
ans += day;
return ss[ans % 7];
}
}
```
* 时间复杂度:令当前时间 `2100-12-xx`,此时达到数据范围对应的计算量上界,设为 $C$。整体复杂度为 $O(C)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1185` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1189. “气球” 的最大数量（简单）.md | 1189. “气球” 的最大数量 | https://leetcode-cn.com/problems/maximum-number-of-balloons/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9px4/ | 简单 | [
"模拟"
] | 给你一个字符串 `text`,你需要使用 `text` 中的字母来拼凑尽可能多的单词 `"balloon"`(气球)。
字符串 `text` 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 `"balloon"`。
示例 1:
```
输入:text = "nlaebolko"
输出:1
```
示例 2:
```
输入:text = "loonbalxballpoon"
输出:2
```
示例 3:
```
输入:text = "leetcode"
输出:0
```
提示:
* $1 <= text.length <= 10^4$
* `text` 全部由小写英文字母组成 | ### 模拟
根据题意模拟即可。
先统计 `text` 中与单词 $balloon$ 相关的字符数量,由于一个单词需要消耗两个 `l` 和 `o` 字符,对其统计数量进行除 $2$ 下取整,然后所有字符的最小出现次数即是能够凑成 $balloon$ 的最大数量。
代码:
```Java
class Solution {
public int maxNumberOfBalloons(String text) {
int[] cnts = new int[5];
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c == 'b') cnts[0]++;
else if (c == 'a') cnts[1]++;
else if (c == 'l') cnts[2]++;
else if (c == 'o') cnts[3]++;
else if (c == 'n') cnts[4]++;
}
cnts[2] /= 2; cnts[3] /= 2;
int ans = cnts[0];
for (int i = 0; i < 5; i++) ans = Math.min(ans, cnts[i]);
return ans;
}
}
```
* 时间复杂度:令 $C$ 为目标字符串的字符种类数量,本题 $C = 5$,统计 `text` 的词频复杂度为 $O(n)$,计算答案复杂度为 $O(C)$。整体复杂度为 $O(n + C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1189` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1190. 反转每对括号间的子串（中等）.md | 1190. 反转每对括号间的子串 | https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses/solution/gong-shui-san-xie-shi-yong-shuang-duan-d-r35q/ | 中等 | [
"双端队列",
"栈"
] | 给出一个字符串 `s`(仅含有小写英文字母和括号)。
请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。
注意,您的结果中 不应 包含任何括号。
示例 1:
```
输入:s = "(abcd)"
输出:"dcba"
```
示例 2:
```
输入:s = "(u(love)i)"
输出:"iloveu"
```
示例 3:
```
输入:s = "(ed(et(oc))el)"
输出:"leetcode"
```
示例 4:
```
输入:s = "a(bcdefghijkl(mno)p)q"
输出:"apmnolkjihgfedcbq"
```
提示:
* $0 <= s.length <= 2000$
* `s` 中只有小写英文字母和括号
* 我们确保所有括号都是成对出现的 | ### 双端队列
根据题意,我们可以设计如下处理流程:
* 从前往后遍历字符串,将不是 `)` 的字符串从「尾部」放入队列中
* 当遇到 `)` 时,从队列「尾部」取出字符串,直到遇到 `(` 为止,并对取出字符串进行翻转
* 将翻转完成后字符串重新从「尾部」放入队列
* 循环上述过程,直到原字符串全部出来完成
* 从队列「头部」开始取字符,得到最终的答案
可以发现,上述过程需要用到双端队列(或者栈,使用栈的话,需要在最后一步对取出字符串再进行一次翻转)。
在 `Java` 中,双端队列可以使用自带的 `ArrayDeque`, 也可以直接使用数组进行模拟。
代码(使用 `ArrayDeque` ):
```Java
class Solution {
public String reverseParentheses(String s) {
int n = s.length();
char[] cs = s.toCharArray();
Deque<Character> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == ')') {
StringBuilder path = new StringBuilder();
while (!d.isEmpty()) {
if (d.peekLast() != '(') {
path.append(d.pollLast());
} else {
d.pollLast();
for (int j = 0; j < path.length(); j++) d.addLast(path.charAt(j));
break;
}
}
} else {
d.addLast(c);
}
}
StringBuilder sb = new StringBuilder();
while (!d.isEmpty()) sb.append(d.pollFirst());
return sb.toString();
}
}
```
代码(数组模拟双端队列):
```Java
class Solution {
int N = 2010, he = 0, ta = 0;
char[] d = new char[N], path = new char[N];
public String reverseParentheses(String s) {
int n = s.length();
char[] cs = s.toCharArray();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == ')') {
int idx = 0;
while (he < ta) {
if (d[ta - 1] == '(' && --ta >= 0) {
for (int j = 0; j < idx; j++) d[ta++] = path[j];
break;
} else {
path[idx++] = d[--ta];
}
}
} else {
d[ta++] = c;
}
}
StringBuilder sb = new StringBuilder();
while (he < ta) sb.append(d[he++]);
return sb.toString();
}
}
```
* 时间复杂度:每个 `(` 字符只会进出队列一次;`)` 字符串都不会进出队列,也只会被扫描一次;分析的重点在于普通字符,可以发现每个普通字符进出队列的次数取决于其右边的 `)` 的个数,最坏情况下每个字符右边全是右括号,因此复杂度可以当做 $O(n^2)$,但实际计算量必然取不满 $n^2$,将普通字符的重复弹出均摊到整个字符串处理过程,可以看作是每个字符串都被遍历常数次,复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1206. 设计跳表（困难）.md | 1206. 设计跳表 | https://leetcode.cn/problems/design-skiplist/solution/by-ac_oier-38rd/ | 困难 | [
"链表",
"数据结构"
] | 不使用任何库函数,设计一个 跳表 。
跳表 是在 $O(log{n})$ 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树,其功能与性能相当,并且跳表的代码长度相较下更短,其设计思想与链表相似。
例如,一个跳表包含 `[30, 40, 50, 60, 70, 90]`,然后增加 `80`、`45` 到跳表中,以下图的方式操作:
跳表中有很多层,每一层是一个短的链表。在第一层的作用下,增加、删除和搜索操作的时间复杂度不超过 $O(n)$。跳表的每一个操作的平均时间复杂度是 $O(\log{n})$,空间复杂度是 $O(n)$。
在本题中,你的设计应该要包含这些函数:
* `bool search(int target)`: 返回 `target` 是否存在于跳表中。
* `void add(int num)`: 插入一个元素到跳表。
* `bool erase(int num)`: 在跳表中删除一个值,如果 `num` 不存在,直接返回 `false`. 如果存在多个 `num` ,删除其中任意一个即可。
注意,跳表中可能存在多个相同的值,你的代码需要处理这种情况。
示例 1:
```
输入
["Skiplist", "add", "add", "add", "search", "add", "search", "erase", "erase", "search"]
[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]
输出
[null, null, null, null, false, null, true, false, true, false]
解释
Skiplist skiplist = new Skiplist();
skiplist.add(1);
skiplist.add(2);
skiplist.add(3);
skiplist.search(0); // 返回 false
skiplist.add(4);
skiplist.search(1); // 返回 true
skiplist.erase(0); // 返回 false,0 不在跳表中
skiplist.erase(1); // 返回 true
skiplist.search(1); // 返回 false,1 已被擦除
```
提示:
* $0 <= num, target <= 2 \times 10^4$
* 调用 `search`, `add`, `erase` 操作次数不大于 $5 \times 10^44$ | ### 数据结构
对于单链表而言,所有的操作(增删改查)都遵循「先查找,再操作」的步骤,这导致在单链表上所有操作复杂度均为 $O(n)$(瓶颈在于查找过程)。
跳表相对于单链表,则是通过引入「多层」链表来优化查找过程,其中每层链表均是「有序」链表:
* 对于单链表的 `Node` 设计而言,我们只需存储对应的节点值 `val`,以及当前节点的下一节点的指针 `ne` 即可(`ne` 为一指针变量)
* 对于跳表来说,除了存储对应的节点值 `val` 以外,我们需要存储当前节点在「每一层」的下一节点指针 `ne`(`ne` 为指针数组)
跳表的 `level` 编号从下往上递增,最下层的链表为元素最全的有序单链表,而查找过程则是按照 `level` 从上往下进行。
操作次数的数据范围为 $n = 5 \times 10^4$,因此设计最大的 `level` 为 $\log{n}$ 即可确保复杂度,但由于操作次数 $n = 5 \times 10^4$ 不可能全是 `add` 操作,因此这里直接取 `level` 为 $10$。
同时为了简化,建立一个哨兵节点 `he`,哨兵值的值应当足够小(根据数据范围,设定为 $-1$ 即可),所有的操作(假设当前操作的传入值为 `t`),先进行统一化的查找:**查找出每一层比 `t` 严格小的最后一个节点,将其存成 `ns` 数组。即 $ns[i]$ 为 $level = i$ 层严格比 $t$ 小的最后一个节点。**
再根据不同的操作进行下一步动作:
* `search` 操作:由于最后一层必然是元素最全的单链表,因此可以直接访问 `ns[0].ne[0]` 即是所有元素中满足大于等于 `t` 的第一个元素,通过判断其值与传入值 `t` 的大小关系来决定结果;
* `add` 操作:由于最后一层必然是元素最全的单链表,因此我们「从下往上」进行插入,最底下一层必然要插入,然后以一半的概率往上传递;
* `erase` 操作:与 `add` 操作互逆,按照「从下往上」的顺序进行删除。需要注意的是,由于相同的值在跳表中可能存在多个,因此我们在「从下往上」删除过程中需要判断待删除的元素与 `ns[0].ne[0]` 是否为同一元素(即要判断地址是否相同,而不是值相同)。
Java 代码:
```Java
class Skiplist {
int level = 10;
class Node {
int val;
Node[] ne = new Node[level];
Node (int _val) {
val = _val;
}
}
Random random = new Random();
Node he = new Node(-1);
void find(int t, Node[] ns) {
Node cur = he;
for (int i = level - 1; i >= 0; i--) {
while (cur.ne[i] != null && cur.ne[i].val < t) cur = cur.ne[i];
ns[i] = cur;
}
}
public boolean search(int t) {
Node[] ns = new Node[level];
find(t, ns);
return ns[0].ne[0] != null && ns[0].ne[0].val == t;
}
public void add(int t) {
Node[] ns = new Node[level];
find(t, ns);
Node node = new Node(t);
for (int i = 0; i < level; i++) {
node.ne[i] = ns[i].ne[i];
ns[i].ne[i] = node;
if (random.nextInt(2) == 0) break;
}
}
public boolean erase(int t) {
Node[] ns = new Node[level];
find(t, ns);
Node node = ns[0].ne[0];
if (node == null || node.val != t) return false;
for (int i = 0; i < level && ns[i].ne[i] == node; i++) ns[i].ne[i] = ns[i].ne[i].ne[i];
return true;
}
}
```
TypeScript 代码:
```TypeScript
const level: number = 10
class TNode {
val: number
ne: TNode[] = new Array<TNode>(level)
constructor(_val: number) {
this.val = _val
}
}
class Skiplist {
he: TNode = new TNode(-1)
find(t: number, ns: TNode[]): void {
let cur = this.he
for (let i = level - 1; i >= 0; i--) {
while (cur.ne[i] != null && cur.ne[i].val < t) cur = cur.ne[i]
ns[i] = cur
}
}
search(t: number): boolean {
let ns: TNode[] = new Array<TNode>(level)
this.find(t, ns)
return ns[0].ne[0] != null && ns[0].ne[0].val == t
}
add(t: number): void {
let ns: TNode[] = new Array<TNode>(level)
this.find(t, ns)
const node = new TNode(t)
for (let i = 0; i < level; i++) {
node.ne[i] = ns[i].ne[i]
ns[i].ne[i] = node
if (Math.round(Math.random()) == 0) break
}
}
erase(t: number): boolean {
let ns: TNode[] = new Array<TNode>(level)
this.find(t, ns)
const node = ns[0].ne[0]
if (node == null || node.val != t) return false
for (let i = 0; i < level && ns[i].ne[i] == node; i++) ns[i].ne[i] = ns[i].ne[i].ne[i]
return true
}
}
```
* 时间复杂度:所有操作的复杂度瓶颈在于 `find` 查找,`find` 查找期望复杂度为 $O(\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1206` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1208. 尽可能使字符串相等（中等）.md | 1208. 尽可能使字符串相等 | https://leetcode-cn.com/problems/get-equal-substrings-within-budget/solution/ni-bu-ke-neng-kan-bu-dong-de-qian-zhui-h-u4l1/ | 中等 | [
"前缀和",
"二分",
"滑动窗口"
] | 给你两个长度相同的字符串,s 和 t。
将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销(开销可能为 0),也就是两个字符的 ASCII 码值的差的绝对值。
用于变更字符串的最大预算是 maxCost。在转化字符串时,总开销应当小于等于该预算,这也意味着字符串的转化可能是不完全的。
如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串,则返回可以转化的最大长度。
如果 s 中没有子字符串可以转化成 t 中对应的子字符串,则返回 0。
示例 1:
```
输入:s = "abcd", t = "bcdf", maxCost = 3
输出:3
解释:s 中的 "abc" 可以变为 "bcd"。开销为 3,所以最大长度为 3。
```
示例 2:
```
输入:s = "abcd", t = "cdef", maxCost = 3
输出:1
解释:s 中的任一字符要想变成 t 中对应的字符,其开销都是 2。因此,最大长度为 1。
```
示例 3:
```
输入:s = "abcd", t = "acde", maxCost = 0
输出:1
解释:a -> a, cost = 0,字符串未发生变化,所以最大长度为 1。
```
提示:
* 1 <= s.length, t.length <= $10^5$
* 0 <= maxCost <= $10^6$
* s 和 t 都只含小写英文字母。 | ### 前缀和 + 二分 + 滑动窗口
给定了长度相同的 `s` 和 `t`,那么对于每一位而言,修改的成本都是相互独立而确定的。
我们可以先预处理出修改成本的前缀和数组 `sum`。
当有了前缀和数组之后,对于任意区间 `[i,j]` 的修改成本,便可以通过 `sum[j] - sum[i - 1]` 得出。
那么接下来我们只需要找出成本不超过 `maxCost` 的最大长度区间,这个长度区间其实就是滑动窗口长度,滑动窗口长度的范围为 `[1, n]` (n 为字符串的长度)。
通过枚举来找答案可以吗?
我们可以通过数据范围大概分析一下哈,共有 `n` 个滑动窗口长度要枚举,复杂度为 $O(n)$,对于每个滑动窗口长度,需要对整个前缀和数组进行滑动检查,复杂度为 $O(n)$。也就是整体复杂度是 $O(n^2)$ 的。
数据范围是 $10^5$,那么单个样本的计算量是 $10^{10}$,计算机单秒肯定算不完,会超时 ~
所以我们直接放弃通过枚举的朴素做法。
那么如何优化呢?其实有了对于朴素解法的分析之后,无非就是两个方向:
1. 优化第一个 $O(n)$:减少需要枚举的滑动窗口长度
2. 优化第二个 $O(n)$:实现不完全滑动前缀和数组,也能确定滑动窗口长度是否合法
事实上第 2 点是无法实现的,我们只能「减少需要枚举的滑动窗口长度」。
一个 $O(n)$ 的操作往下优化,通常就是优化成 $O(\log{n})$,$O(\log{n})$ 基本上我们可以先猜一个「二分」查找。
然后我们再来分析是否可以二分:假设我们有满足要求的长度 `ans`,那么在以 `ans` 为分割点的数轴上(数轴的范围是滑动窗口长度的范围:`[1, n]`):
1. 所有满足 `<= ans` 的点的修改成本必然满足 `<= maxCost`
2. 所有满足 `> ans` 的点的修改成本必然满足 `> maxCost` (否则 `ans` 就不会是答案)
因此 `ans` 在数轴 `[1, n]` 上具有二段性,我们可以使用「二分」找 `ans`。得证「二分」的合理性。
**可见二分的本质是二段性,而非单调性。**
##### 编码细节:
1. 为了方便的预处理前缀和和减少边界处理,我会往字符串头部添加一个空格,使之后的数组下标从 1 开始
2. 二分出来滑动窗口长度,需要在返回时再次检查,因为可能没有符合条件的有效滑动窗口长度
代码:
```Java
class Solution {
public int equalSubstring(String ss, String tt, int max) {
int n = ss.length();
ss = " " + ss;
tt = " " + tt;
char[] s = ss.toCharArray();
char[] t = tt.toCharArray();
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + Math.abs(s[i] - t[i]);
int l = 1, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(sum, mid, max)) {
l = mid;
} else {
r = mid - 1;
}
}
return check(sum, r, max) ? r : 0;
}
boolean check(int[] nums, int mid, int max) {
for (int i = mid; i < nums.length; i++) {
int tot = nums[i] - nums[i - mid];
if (tot <= max) return true;
}
return false;
}
}
```
* 时间复杂度:预处理出前缀和的复杂度为 $O(n)$;二分出「滑动窗口长度」的复杂度为 $O(\log{n})$,对于每个窗口长度,需要扫描一遍数组进行检查,复杂度为 $O(n)$,因此二分的复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:使用了前缀和数组。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1210. 穿过迷宫的最少移动次数（困难）.md | 1210. 穿过迷宫的最少移动次数 | null | 困难 | [
"BFS"
] | 你还记得那条风靡全球的贪吃蛇吗?
我们在一个 `n*n` 的网格上构建了新的迷宫地图,蛇的长度为 `2`,也就是说它会占去两个单元格。蛇会从左上角(`(0, 0)` 和 `(0, 1)`)开始移动。我们用 `0` 表示空单元格,用 `1` 表示障碍物。
蛇需要移动到迷宫的右下角(`(n-1, n-2)` 和 `(n-1, n-1)`)。
每次移动,蛇可以这样走:
* 如果没有障碍,则向右移动一个单元格。并仍然保持身体的水平/竖直状态。
* 如果没有障碍,则向下移动一个单元格。并仍然保持身体的水平/竖直状态。
* 如果它处于水平状态并且其下面的两个单元都是空的,就顺时针旋转 `90` 度。蛇从(`(r, c)`、`(r, c+1)`)移动到 (`(r, c)`、`(r+1, c)`)。
* 如果它处于竖直状态并且其右面的两个单元都是空的,就逆时针旋转 `90` 度。蛇从(`(r, c)`、`(r+1, c)`)移动到(`(r, c)`、`(r, c+1)`)。
返回蛇抵达目的地所需的最少移动次数。
如果无法到达目的地,请返回 `-1`。
示例 1:
```
输入:grid = [[0,0,0,0,0,1],
[1,1,0,0,1,0],
[0,0,0,0,1,1],
[0,0,1,0,1,0],
[0,1,1,0,0,0],
[0,1,1,0,0,0]]
输出:11
解释:
一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。
```
示例 2:
```
输入:grid = [[0,0,1,1,1,1],
[0,0,0,0,1,1],
[1,1,0,0,0,1],
[1,1,1,0,0,1],
[1,1,1,0,0,1],
[1,1,1,0,0,0]]
输出:9
```
提示:
* $2 <= n <= 100$
* $0 <= grid[i][j] <= 1$
* 蛇保证从空单元格开始出发。 | ### BFS
题目要我们求从特定起点到特定终点的最少步数,由于我们蛇的长度固定为 $2$,因此我们可用三元组 $(x, y, cd)$ 来代表蛇的实际位置。其中 $(x, y)$ 代表蛇尾位置,$cd$ 代表当前蛇的方向状态,$0$ 代表水平状态,$1$ 代表竖直状态。
蛇尾加上方向状态可确定其蛇头位置 :`tx = cd == 0 ? nx : nx + 1`、`ty = cd == 0 ? ny + 1 : ny`。
对四种移动规则所导致三元组变化进行分情况讨论:
1. 往右移动:对于蛇尾而言,只有维度 $y$ 进行加一,其余维度不变。三元组变化总结为 $(0, 1, 0)$
2. 往下移动:对于蛇尾而言,只有维度 $x$ 进行加一,其余维度不变。三元组变化总结为 $(1, 0, 0)$
3. 旋转:对于蛇尾,只有 $cd$ 维度对进行翻转,其余维度不变。三元组变化总结定为 $(0, 0, 1)$
综上,所有移动规则可总结为 `int[][] dirs = new int[][]{{1,0,0},{0,1,0},{0,0,1}}`。
在进行 `BFS` 时,通过遍历 `dirs` 来得到新的三元组:原位置 `(x, y, cd)` 转换到新位置 `(x + dir[0], y + dir[1], cd ^ dir[2])`。
在得到新蛇尾位置 $(nx, ny)$ 之后,计算新蛇头的位置 $(tx, ty)$。需要确保整条蛇没有越界,没有碰到障碍物,并且旋转转移时,额外检查 $(x + 1, y + 1)$ 位置是否合法。
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{1,0,0},{0,1,0},{0,0,1}};
public int minimumMoves(int[][] g) {
int n = g.length;
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{0,0,0,0});
boolean[][][] vis = new boolean[n][n][2];
vis[0][0][0] = true;
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1], cd = info[2], step = info[3];
for (int[] dir : dirs) {
int nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2]; // 新蛇尾位置和方向
int tx = nd == 0 ? nx : nx + 1, ty = nd == 0 ? ny + 1 : ny; // 新蛇头
if (nx >= n || ny >= n || tx >= n || ty >= n) continue; // 整条蛇不越界
if (g[nx][ny] == 1 || g[tx][ty] == 1) continue; // 没有触及障碍物
if (vis[nx][ny][nd]) continue;
if (cd != nd && g[x + 1][y + 1] == 1) continue; // 旋转时,额外检查多一个位置
if (nx == n - 1 && ny == n - 2 && nd == 0) return step + 1;
d.addLast(new int[]{nx, ny, nd, step + 1});
vis[nx][ny][nd] = true;
}
}
return -1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minimumMoves(vector<vector<int>>& g) {
vector<vector<int>> dirs = {{1,0,0}, {0,1,0}, {0,0,1}};
int n = g.size();
queue<vector<int>> d;
d.push({0, 0, 0, 0});
vector<vector<vector<bool>>> vis(n, vector<vector<bool>>(n, vector<bool>(2, false)));
vis[0][0][0] = true;
while (!d.empty()) {
vector<int> info = d.front();
d.pop();
int x = info[0], y = info[1], cd = info[2], step = info[3];
for (vector<int>& dir : dirs) {
int nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2];
int tx = nd == 0 ? nx : nx + 1, ty = nd == 0 ? ny + 1 : ny;
if (nx >= n || ny >= n || tx >= n || ty >= n) continue;
if (g[nx][ny] == 1 || g[tx][ty] == 1) continue;
if (vis[nx][ny][nd]) continue;
if (cd != nd && g[x + 1][y + 1] == 1) continue;
if (nx == n - 1 && ny == n - 2 && nd == 0) return step + 1;
d.push({nx, ny, nd, step + 1});
vis[nx][ny][nd] = true;
}
}
return -1;
}
};
```
Python 代码:
```Python
class Solution:
def minimumMoves(self, g: List[List[int]]) -> int:
dirs = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
n = len(g)
d = deque([(0,0,0,0)])
vis = [[[0]*2 for _ in range(n)] for _ in range(n)]
vis[0][0][0] = 1
while d:
x, y, cd, step = d.popleft()
for dir in dirs:
nx, ny, nd = x + dir[0], y + dir[1], cd ^ dir[2]
tx, ty = nx + (nd == 1), ny + (nd == 0)
if nx >= n or ny >= n or tx >= n or ty >= n: continue
if g[nx][ny] == 1 or g[tx][ty] == 1: continue
if vis[nx][ny][nd]: continue
if cd != nd and g[x + 1][y + 1] == 1: continue
if nx == n - 1 and ny == n - 2 and nd == 0: return step + 1
d.append((nx, ny, nd, step + 1))
vis[nx][ny][nd] = 1
return -1
```
TypeScript 代码:
```TypeScript
function minimumMoves(g: number[][]): number {
const n = g.length;
const d: [number, number, number, number][] = [[0,0,0,0]];
const vis: boolean[][][] = Array.from({ length: n }, () => Array.from({ length: n }, () => [false, false]));
vis[0][0][0] = true;
const dirs: [number, number, number][] = [[1,0,0], [0,1,0], [0,0,1]];
while (d.length > 0) {
const [x, y, cd, step] = d.shift()!;
for (const dir of dirs) {
const nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2];
const tx = nd === 0 ? nx : nx + 1, ty = nd === 0 ? ny + 1 : ny;
if (nx >= n || ny >= n || tx >= n || ty >= n) continue;
if (g[nx][ny] === 1 || g[tx][ty] === 1) continue
if (vis[nx][ny][nd]) continue;
if (cd !== nd && g[x + 1][y + 1] === 1) continue;
if (nx === n - 1 && ny === n - 2 && nd === 0) return step + 1;
d.push([nx, ny, nd, step + 1]);
vis[nx][ny][nd] = true;
}
}
return -1;
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2 \times C)$,其中 $C = 2$ 代表蛇可变状态方向 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1210` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/121-130/124. 二叉树中的最大路径和（困难）.md | 124. 二叉树中的最大路径和 | https://leetcode.cn/problems/binary-tree-maximum-path-sum/solutions/2451624/gong-shui-san-xie-jian-dan-di-gui-shu-xi-nlci/ | 困难 | [
"递归",
"二叉树",
"DFS",
"树形 DP",
"动态规划"
] | 二叉树中的 路径 被定义为一条节点序列,序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点,且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 `root`,返回其 最大路径和 。
示例 1:
```
输入:root = [1,2,3]
输出:6
解释:最优路径是 2 -> 1 -> 3 ,路径和为 2 + 1 + 3 = 6
```
示例 2:
```
输入:root = [-10,9,20,null,null,15,7]
输出:42
解释:最优路径是 15 -> 20 -> 7 ,路径和为 15 + 20 + 7 = 42
```
提示:
* 树中节点数目范围是 $[1, 3 \times 10^4]$
* $-1000 <= Node.val <= 1000$ | ### 递归
一个简单的做法是直接递归来做:设计 `DFS` 函数,传入当前节点 `cur`,返回以该节点“往下”延伸所能取得的最大路径和。
即在 **仅使用当前节点**、**使用当前节点和左子树路径** 和 **使用当前节点和右子树路径** 三者中取最大值进行返回。
同时在 `DFS` 过程中,我们计算「以当前节点 `cur` 为路径最高点」时的最大路径和,并用此来更新全局变量 `ans`。
具体的,在以节点 `cur` 为路径最高点时的最大路径和,首先包含当前节点本身(`cur.val`),以及可选的左右节点路径和(`dfs(cur.left)` 和 `dfs(cur.right)`)。当左右节点路径和不为负数时,说明能够对当前路径起到正向贡献作用,将其添加到路径中。
Java 代码:
```Java
class Solution {
int ans = Integer.MIN_VALUE;
public int maxPathSum(TreeNode root) {
dfs(root);
return ans;
}
int dfs(TreeNode root) {
if (root == null) return 0;
int left = dfs(root.left), right = dfs(root.right);
int t = root.val;
if (left >= 0) t += left;
if (right >= 0) t += right;
ans = Math.max(ans, t);
return Math.max(root.val, Math.max(left, right) + root.val);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int ans = INT_MIN;
int maxPathSum(TreeNode* root) {
dfs(root);
return ans;
}
int dfs(TreeNode* root) {
if (root == nullptr) return 0;
int left = dfs(root->left), right = dfs(root->right);
int t = root->val;
if (left >= 0) t += left;
if (right >= 0) t += right;
ans = max(ans, t);
return max(root->val, max(left, right) + root->val);
}
};
```
Python 代码:
```Python
class Solution:
def maxPathSum(self, root: Optional[TreeNode]) -> int:
ans = float('-inf')
def dfs(root):
nonlocal ans
if not root: return 0
l, r = dfs(root.left), dfs(root.right)
t = root.val
if l >= 0: t += l
if r >= 0: t += r
ans = max(ans, t)
return max(root.val, max(l, r) + root.val)
dfs(root)
return ans
```
TypeScript 代码:
```TypeScript
function maxPathSum(root: TreeNode | null): number {
let ans = -0x3f3f3f3f;
const dfs = function(root: TreeNode | null): number {
if (root == null) return 0;
const l = dfs(root.left), r = dfs(root.right);
let t = root.val;
if (l >= 0) t += l;
if (r >= 0) t += r;
ans = Math.max(ans, t);
return Math.max(root.val, Math.max(l, r) + root.val);
};
dfs(root);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 树形 DP
另一个做法是使用「树形 DP」思路来做。
将某个节点所在最佳路径根据方向进行拆分:**往左子节点进行延伸**、**往右子节点进行延伸** 和 **往父节点进行延伸**。
若能分别求解出三个方向的最大路径和,从中选择路径和最大(路径和非零)的两个方向进行累加,便是当前节点的最大路径和。
具体的,创建哈希表记录某个节点三个方向的路径和情况:节点对象作为哈希表的键,三个方向路径和情况作为值。
即键值对格式:`节点对象: [父节点方向最大路径和, 左子节点方向最大路径和, 右子节点方向最大路径和]`。
然后是常规的树形 DP 求解思路:第一次 `DFS` 先求解两个“方向往下”的最大路径和。第二次 `DFS` 根据 **首次 `DFS` 已算好的“方向往下”的路径和情况** 以及 **本轮 `DFS` 已递归处理好的当前节点“方向往上”的路径和情况**,来求解 当前节点子节点 的“方向往上”路径和情况。
> 对「树形 DP」接触不深的同学,可以看 [前置 🧀](https://leetcode-cn.com/problems/minimum-height-trees/solution/by-ac_oier-7xio/)
Java 代码:
```Java
class Solution {
Map<TreeNode, int[]> map = new HashMap<>(); // 节点: [父, 左, 右]
public int maxPathSum(TreeNode root) {
dfs1(root, null);
dfs2(root, null);
int ans = Integer.MIN_VALUE;
for (TreeNode cur : map.keySet()) {
int t = cur.val;
int[] info = map.get(cur);
Arrays.sort(info);
if (info[2] >= 0) t += info[2];
if (info[1] >= 0) t += info[1];
ans = Math.max(ans, t);
}
return ans;
}
int dfs1(TreeNode cur, TreeNode fa) {
if (cur == null) return 0;
int left = dfs1(cur.left, cur), right = dfs1(cur.right, cur);
int[] info = map.getOrDefault(cur, new int[3]);
info[1] = left; info[2] = right;
map.put(cur, info);
return Math.max(cur.val, cur.val + Math.max(left, right));
}
void dfs2(TreeNode cur, TreeNode fa) {
if (cur == null) return ;
int[] curInfo = map.get(cur);
if (cur.left != null) {
int[] leftInfo = map.get(cur.left);
leftInfo[0] = Math.max(cur.val, cur.val + Math.max(curInfo[0], curInfo[2]));
}
if (cur.right != null) {
int[] rightInfo = map.get(cur.right);
rightInfo[0] = Math.max(cur.val, cur.val + Math.max(curInfo[0], curInfo[1]));
}
dfs2(cur.left, cur);
dfs2(cur.right, cur);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.124` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/121-130/127. 单词接龙（困难）.md | 127. 单词接龙 | https://leetcode-cn.com/problems/word-ladder/solution/gong-shui-san-xie-ru-he-shi-yong-shuang-magjd/ | 困难 | [
"双向 BFS",
"启发式搜索",
"AStar 算法"
] | 字典 `wordList` 中从单词 `beginWord `和 `endWord` 的 转换序列 是一个按下述规格形成的序列:
* 序列中第一个单词是 `beginWord` 。
* 序列中最后一个单词是 `endWord` 。
* 每次转换只能改变一个字母。
* 转换过程中的中间单词必须是字典 `wordList` 中的单词。
给你两个单词 `beginWord `和 `endWord `和一个字典 `wordList `,找到从 `beginWord `到 `endWord `的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列,返回 $0$。
示例 1:
```
输入:beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出:5
解释:一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。
```
示例 2:
```
输入:beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出:0
解释:endWord "cog" 不在字典中,所以无法进行转换。
```
提示:
* $1 <= beginWord.length <= 10$
* $endWord.length == beginWord.length$
* $1 <= wordList.length <= 5000$
* $wordList[i].length == beginWord.length$
* `beginWord`、`endWord` 和 `wordList[i]` 由小写英文字母组成
* `beginWord != endWord`
* `wordList` 中的所有字符串 互不相同 | ### 基本分析
根据题意,每次只能替换一个字符,且每次产生的新单词必须在 `wordList` 出现过。
一个朴素的实现方法是,使用 BFS 的方式求解。
从 `beginWord` 出发,枚举所有替换一个字符的方案,如果方案存在于 `wordList` 中,则加入队列中,这样队列中就存在所有替换次数为 $1$ 的单词。然后从队列中取出元素,继续这个过程,直到遇到 `endWord` 或者队列为空为止。
同时为了「防止重复枚举到某个中间结果」和「记录每个中间结果是经过多少次转换而来」,我们需要建立一个「哈希表」进行记录。
哈希表的 KV 形式为 `{ 单词 : 由多少次转换得到 }`。
当枚举到新单词 `str` 时,需要先检查是否已经存在与「哈希表」中,如果不存在则更新「哈希表」并将新单词放入队列中。
**这样的做法可以确保「枚举到所有由 `beginWord` 到 `endWord` 的转换路径」,并且由 `beginWord` 到 `endWord` 的「最短转换路径」必然会最先被枚举到。**
---
### 双向 BFS
经过分析,BFS 确实可以做,但本题的数据范围较大:`1 <= beginWord.length <= 10`
朴素的 BFS 可能会带来「搜索空间爆炸」的情况。
想象一下,如果我们的 `wordList` 足够丰富(包含了所有单词),对于一个长度为 $10$ 的 `beginWord` 替换一次字符可以产生 $10 \times 25$ 个新单词(每个替换点可以替换另外 $25$ 个小写字母),第一层就会产生 $250$ 个单词;第二层会产生超过 $6 \times 10^4$ 个新单词 ...
**随着层数的加深,这个数字的增速越快,这就是「搜索空间爆炸」问题。**
**在朴素的 BFS 实现中,空间的瓶颈主要取决于搜索空间中的最大宽度。**
那么有没有办法让我们不使用这么宽的搜索空间,同时又能保证搜索到目标结果呢?
「双向 BFS」 可以很好的解决这个问题:
**同时从两个方向开始搜索,一旦搜索到相同的值,意味着找到了一条联通起点和终点的最短路径。**
「双向 BFS」的基本实现思路如下:
1. 创建「两个队列」分别用于两个方向的搜索;
2. 创建「两个哈希表」用于「解决相同节点重复搜索」和「记录转换次数」;
3. 为了尽可能让两个搜索方向“平均”,每次从队列中取值进行扩展时,先判断哪个队列容量较少;
4. 如果在搜索过程中「搜索到对方搜索过的节点」,说明找到了最短路径。
「双向 BFS」基本思路对应的伪代码大致如下:
```Java
d1、d2 为两个方向的队列
m1、m2 为两个方向的哈希表,记录每个节点距离起点的
// 只有两个队列都不空,才有必要继续往下搜索
// 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点
while(!d1.isEmpty() && !d2.isEmpty()) {
if (d1.size() < d2.size()) {
update(d1, m1, m2);
} else {
update(d2, m2, m1);
}
}
// update 为将当前队列 d 中包含的元素取出,进行「一次完整扩展」的逻辑(按层拓展)
void update(Deque d, Map cur, Map other) {}
```
回到本题,我们看看如何使用「双向 BFS」进行求解。
估计不少同学是第一次接触「双向 BFS」,因此这次我写了大量注释。
建议大家带着对「双向 BFS」的基本理解去阅读。
Java 代码:
```Java
class Solution {
String s, e;
Set<String> set = new HashSet<>();
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
s = beginWord; e = endWord;
// 将所有 word 存入 set,如果目标单词不在 set 中,说明无解
for (String w : wordList) set.add(w);
if (!set.contains(e)) return 0;
int ans = bfs();
return ans == -1 ? 0 : ans + 1;
}
int bfs() {
// d1 代表从起点 beginWord 开始搜索(正向)
// d2 代表从结尾 endWord 开始搜索(反向)
Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque();
/*
* m1 和 m2 分别记录两个方向出现的单词是经过多少次转换而来
* e.g.
* m1 = {"abc":1} 代表 abc 由 beginWord 替换 1 次字符而来
* m2 = {"xyz":3} 代表 xyz 由 endWord 替换 3 次字符而来
*/
Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
d1.add(s);
m1.put(s, 0);
d2.add(e);
m2.put(e, 0);
/*
* 只有两个队列都不空,才有必要继续往下搜索
* 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点
* e.g.
* 例如,如果 d1 为空了,说明从 beginWord 搜索到底都搜索不到 endWord,反向搜索也没必要进行了
*/
while (!d1.isEmpty() && !d2.isEmpty()) {
int t = -1;
// 为了让两个方向的搜索尽可能平均,优先拓展队列内元素少的方向
if (d1.size() <= d2.size()) {
t = update(d1, m1, m2);
} else {
t = update(d2, m2, m1);
}
if (t != -1) return t;
}
return -1;
}
// update 代表从 deque 中取出一个单词进行扩展,
// cur 为当前方向的距离字典;other 为另外一个方向的距离字典
int update(Deque<String> deque, Map<String, Integer> cur, Map<String, Integer> other) {
int m = deque.size();
while (m-- > 0) {
// 获取当前需要扩展的原字符串
String poll = deque.pollFirst();
int n = poll.length();
// 枚举替换原字符串的哪个字符 i
for (int i = 0; i < n; i++) {
// 枚举将 i 替换成哪个小写字母
for (int j = 0; j < 26; j++) {
// 替换后的字符串
String sub = poll.substring(0, i) + String.valueOf((char)('a' + j)) + poll.substring(i + 1);
if (set.contains(sub)) {
// 如果该字符串在「当前方向」被记录过(拓展过),跳过即可
if (cur.containsKey(sub) && cur.get(sub) <= cur.get(poll) + 1) continue;
// 如果该字符串在「另一方向」出现过,说明找到了联通两个方向的最短路
if (other.containsKey(sub)) {
return cur.get(poll) + 1 + other.get(sub);
} else {
// 否则加入 deque 队列
deque.addLast(sub);
cur.put(sub, cur.get(poll) + 1);
}
}
}
}
}
return -1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
string s, e;
unordered_set<string> wordSet;
int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
s = beginWord; e = endWord;
for (string w : wordList) wordSet.insert(w);
if (wordSet.find(e) == wordSet.end()) return 0;
int ans = bfs();
return ans == -1 ? 0 : ans + 1;
}
int bfs() {
deque<string> dq1, dq2;
unordered_map<string, int> m1, m2;
dq1.push_back(s);
m1[s] = 0;
dq2.push_back(e);
m2[e] = 0;
while (!dq1.empty() && !dq2.empty()) {
int t = -1;
if (dq1.size() <= dq2.size()) t = update(dq1, m1, m2);
else t = update(dq2, m2, m1);
if (t != -1) return t;
}
return -1;
}
int update(deque<string>& dq, unordered_map<string, int>& cur, unordered_map<string, int>& other) {
int m = dq.size();
while (m-- > 0) {
string poll = dq.front();
dq.pop_front();
int n = poll.length();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
string sub = poll.substr(0, i) + static_cast<char>('a' + j) + poll.substr(i + 1);
if (wordSet.find(sub) != wordSet.end()) {
if (cur.find(sub) != cur.end() && cur[sub] <= cur[poll] + 1) continue;
if (other.find(sub) != other.end()) {
return cur[poll] + 1 + other[sub];
} else {
dq.push_back(sub);
cur[sub] = cur[poll] + 1;
}
}
}
}
}
return -1;
}
};
```
Python 代码:
```Python
class Solution:
def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
def bfs():
dq1, dq2 = deque(), deque()
m1, m2 = {}, {}
dq1.append(s)
m1[s] = 0
dq2.append(e)
m2[e] = 0
while dq1 and dq2:
t = update(dq1, m1, m2) if len(dq1) <= len(dq2) else update(dq2, m2, m1)
if t != -1: return t
return -1
def update(dq, cur, other):
m = len(dq)
for _ in range(m):
poll = dq.popleft()
n = len(poll)
for i in range(n):
for j in range(26):
sub = poll[:i] + chr(ord('a') + j) + poll[i+1:]
if sub in wordSet:
if sub in cur and cur[sub] <= cur[poll] + 1: continue
if sub in other:
return cur[poll] + 1 + other[sub]
else:
dq.append(sub)
cur[sub] = cur[poll] + 1
return -1
s, e = beginWord, endWord
wordSet = set(wordList)
if e not in wordSet: return 0
ans = bfs()
return 0 if ans == -1 else ans + 1
```
* 时间复杂度:令 `wordList` 长度为 $n$,`beginWord` 字符串长度为 $m$。由于所有的搜索结果必须都在 `wordList` 出现过,因此算上起点最多有 $n + 1$ 节点,最坏情况下,所有节点都联通,搜索完整张图复杂度为 $O(n^2)$ ;从 `beginWord` 出发进行字符替换,替换时进行逐字符检查,复杂度为 $O(m)$。整体复杂度为 $O(m \times n^2)$
* 空间复杂度:同等空间大小。$O(m \times n^2)$
---
### 总结
**这本质其实是一个「所有边权均为 `1`」最短路问题:将 `beginWord` 和所有在 `wordList` 出现过的字符串看做是一个点。每一次转换操作看作产生边权为 `1` 的边。问题求以 `beginWord` 为源点,以 `endWord` 为汇点的最短路径。**
借助这个题,我向你介绍了「双向 BFS」,「双向 BFS」可以有效解决「搜索空间爆炸」问题。
**对于那些搜索节点随着层数增加呈倍数或指数增长的搜索问题,可以使用「双向 BFS」进行求解。**
---
### 启发式搜索 `AStar`
可以直接根据本题规则来设计 AStar 的「启发式函数」。
比如对于两个字符串 `a` `b` 直接使用它们不同字符的数量来充当估值距离,我觉得是合适的。
因为不同字符数量的差值可以确保不会超过真实距离(是一个理论最小替换次数)。
注意:本题数据比较弱,用 AStar 过了,但通常我们需要「确保有解」,AStar 的启发搜索才会发挥真正价值。而本题,除非 `endWord` 本身就不在 `wordList` 中,其余情况我们无法很好提前判断「是否有解」。这时候 AStar 将不能带来「搜索空间的优化」,效果不如「双向 BFS」。
Java 代码:
```Java
class Solution {
class Node {
String str;
int val;
Node (String _str, int _val) {
str = _str;
val = _val;
}
}
String s, e;
int INF = 0x3f3f3f3f;
Set<String> set = new HashSet<>();
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
s = beginWord; e = endWord;
for (String w : wordList) set.add(w);
if (!set.contains(e)) return 0;
int ans = astar();
return ans == -1 ? 0 : ans + 1;
}
int astar() {
PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);
Map<String, Integer> dist = new HashMap<>();
dist.put(s, 0);
q.add(new Node(s, f(s)));
while (!q.isEmpty()) {
Node poll = q.poll();
String str = poll.str;
int distance = dist.get(str);
if (str.equals(e)) {
break;
}
int n = str.length();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
String sub = str.substring(0, i) + String.valueOf((char)('a' + j)) + str.substring(i + 1);
if (!set.contains(sub)) continue;
if (!dist.containsKey(sub) || dist.get(sub) > distance + 1) {
dist.put(sub, distance + 1);
q.add(new Node(sub, dist.get(sub) + f(sub)));
}
}
}
}
return dist.containsKey(e) ? dist.get(e) : -1;
}
int f(String str) {
if (str.length() != e.length()) return INF;
int n = str.length();
int ans = 0;
for (int i = 0; i < n; i++) {
ans += str.charAt(i) == e.charAt(i) ? 0 : 1;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
struct Node {
string str;
int val;
Node(string _str, int _val) : str(_str), val(_val) {}
};
string s, e;
const int INF = 0x3f3f3f3f;
unordered_set<string> set;
int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
s = beginWord; e = endWord;
for (const string& w : wordList) set.insert(w);
if (set.find(e) == set.end()) return 0;
int ans = astar();
return ans == -1 ? 0 : ans + 1;
}
int astar() {
priority_queue<Node, vector<Node>, function<bool(Node, Node)>> q([](Node a, Node b) {
return a.val > b.val;
});
unordered_map<string, int> dist;
dist[s] = 0;
q.push(Node(s, f(s)));
while (!q.empty()) {
Node poll = q.top();
q.pop();
string str = poll.str;
int distance = dist[str];
if (str == e) break;
int n = str.length();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
string sub = str.substr(0, i) + char('a' + j) + str.substr(i + 1);
if (set.find(sub) == set.end()) continue;
if (dist.find(sub) == dist.end() || dist[sub] > distance + 1) {
dist[sub] = distance + 1;
q.push(Node(sub, dist[sub] + f(sub)));
}
}
}
}
return dist.find(e) != dist.end() ? dist[e] : -1;
}
int f(string str) {
if (str.length() != e.length()) return INF;
int n = str.length(), ans = 0;
for (int i = 0; i < n; i++) ans += str[i] == e[i] ? 0 : 1;
return ans;
}
};
```
* 时间复杂度:启发式搜索分析时空复杂度意义不大
* 空间复杂度:启发式搜索分析时空复杂度意义不大 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.127` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1217. 玩筹码（简单）.md | 1217. 玩筹码 | https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position/solution/by-ac_oier-j6js/ | 简单 | [
"贪心",
"枚举"
] | 有 `n` 个筹码。第 $i$ 个筹码的位置是 `position[i]`。
我们需要把所有筹码移到同一个位置。在一步中,我们可以将第 $i$ 个筹码的位置从 $position[i]$ 改变为:
* `position[i] + 2 或 position[i] - 2`,此时 `cost = 0`
* `position[i] + 1 或 position[i] - 1`,此时 `cost = 1`
返回将所有筹码移动到同一位置上所需要的 最小代价 。
示例 1:
```
输入:position = [1,2,3]
输出:1
解释:第一步:将位置3的筹码移动到位置1,成本为0。
第二步:将位置2的筹码移动到位置1,成本= 1。
总成本是1。
```
示例 2:
```
输入:position = [2,2,2,3,3]
输出:2
解释:我们可以把位置3的两个筹码移到位置2。每一步的成本为1。总成本= 2。
```
示例 3:
```
输入:position = [1,1000000000]
输出:1
```
提示:
* $1 <= chips.length <= 100$
* $1 <= chips[i] <= 10^9$ | ### 贪心 + 枚举目标位置
假设移动的目标位置是 $a$,当前所在位置是 $b$,将小球从 $b$ 移动到 $a$ 的成本取决于两位置距离的「奇偶性」,距离为偶数时成本固定为 $0$,距离为奇数时成本固定为 $1$。
同时我们可以通过「分情况讨论」来证明,所有小球移动到一个全新位置(起始没有小球的位置),结果不会变好,假设所选择的最终(全新)位置为 $t$:
* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离均为偶数,此时总成本为 $0$,同时可知所有数的位置奇偶性相同,此时选择所有数中的任意一个的位置,同样可得总成本为 $0$ 的结果,因此选全新的位置不会让结果变好;
* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离均为奇数,此时总成本为 $n$,同时可知所有数的位置奇偶性相同,此时选择所有数中的任意一个的位置,可得总成本为 $0$ 的结果,因此选全新的位置会让结果变差;
* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离奇数结果为 $c1$,偶数结果为 $c2$,可知 $n = c1 + c2$,同时我们通过调整 $t$ 的奇偶性来确保 $c1 <= c2$。此时总的成本为 $c1$,同时可知所有与 $t$ 距离为奇数的数所在位置奇偶性相同,所有与 $t$ 距离为偶数的数所在位置奇偶性也相同,此时将 $t$ 调整为与 $t$ 奇偶性相同的原有数的位置,同样能够得到总成本为 $c1$ 的结果,因此选全新的位置不会让结果变好。
综上,我们可以枚举所有已有的位置为目标位置,并通过奇偶性统计其余位置到目标位置的成本,在所有已有位置中取最小的总成本即是答案。
代码:
```Java
class Solution {
public int minCostToMoveChips(int[] ps) {
int n = ps.length, ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int a = ps[i], cur = 0;
for (int j = 0; j < n; j++) {
int b = ps[j];
cur += Math.abs(a - b) % 2;
}
ans = Math.min(ans, cur);
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$
---
### 贪心 + 统计奇偶性
更进一步,我们可以发现要使得「总的移动成本最优」的目标位置有无数个,只要目标位置的奇偶性不变,即可确保总成本不变。
因此我们可以省去枚举具体位置的操作,转而统计原有数的奇偶位置个数,假设偶数位置有 $a$ 个,奇数位置有 $b$ 个,最终目标位置选为偶数的成本为 $b$,最终目标位置选为奇数的成本为 $a$,即两者中的最小值即是答案。
代码:
```Java
class Solution {
public int minCostToMoveChips(int[] ps) {
int n = ps.length, a = 0;
for (int i : ps) a += i % 2;
return Math.min(a, n - a);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1218. 最长定差子序列（中等）.md | 1218. 最长定差子序列 | https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference/solution/gong-shui-san-xie-jie-he-tan-xin-de-zhua-dj1k/ | 中等 | [
"贪心",
"序列 DP",
"状态机 DP",
"哈希表"
] | 给你一个整数数组 `arr` 和一个整数 `difference`,请你找出并返回 `arr` 中最长等差子序列的长度,该子序列中相邻元素之间的差等于 `difference` 。
子序列 是指在不改变其余元素顺序的情况下,通过删除一些元素或不删除任何元素而从 `arr` 派生出来的序列。
示例 1:
```
输入:arr = [1,2,3,4], difference = 1
输出:4
解释:最长的等差子序列是 [1,2,3,4]。
```
示例 2:
```
输入:arr = [1,3,5,7], difference = 1
输出:1
解释:最长的等差子序列是任意单个元素。
```
示例 3:
```
输入:arr = [1,5,7,8,5,3,4,2,1], difference = -2
输出:4
解释:最长的等差子序列是 [7,5,3,1]。
```
提示:
* $1 <= arr.length <= 10^5$
* $-10^4 <= arr[i], difference <= 10^4$ | ### 状态机序列 DP + 哈希表
**定义 $f[i][j]$($j$ 非 $0$ 即 $1$) 为代表考虑前 $i$ 个数,且第 $i$ 个数的选择情况为 $j$ 时,得到的最长定差子序列长度。**
最终答案为 $\max(f[n - 1][0], f[n - 1][1])$,同时我们有显然的初始化条件 $f[0][0] = 0$ 和 $f[0][1] = 1$。
不失一般性考虑 $f[i][j]$ 如何转移:
* $f[i][0]$:明确了第 $i$ 个不选,那么此时最大长度为前一个位置的结果。即有:
$$
f[i][0] = \max(f[i - 1][0], f[i - 1][1])
$$
* $f[i][1]$:明确了第 $i$ 个要选,此时进行分情况讨论:
* $arr[i]$ 独立成为一个子序列,此时有:$f[i][1] = 1$;
* $arr[i]$ 接在某一个数的后面,由于给定了差值 $difference$,可直接算得上一位的值为 $prev = arr[i] - difference$,此时应当找到值为 $prev$,下标最大(下标小于 $i$)的位置,然后从该位置转移过来,即有:$f[i][1] = f[hash[prev]][1] + 1$;
> 容易证明:如果存在多个位置的值为 $prev$,从中选择一个下标最大的位置(下标小于 $i$)进行转移,结果相比于最优位置不会变差。因此我们「贪心」选择下标最大的位置(下标小于 $i$)即可,这引导我们在转移过程中使用「哈希表」记录处理过的位置的值信息。
综上,我们有:
$$
f[i][1] = \begin{cases}
1 & hash[arr[i] - difference] = -1 \\
f[hash[prev]][1] + 1 & hash[arr[i] - difference] \neq -1
\end{cases}
$$
代码(使用数组充当哈希表的代码在 $P2$):
```Java
class Solution {
public int longestSubsequence(int[] arr, int d) {
int n = arr.length;
Map<Integer, Integer> map = new HashMap<>();
int[][] f = new int[n][2];
f[0][1] = 1;
map.put(arr[0], 0);
for (int i = 1; i < n; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = 1;
int prev = arr[i] - d;
if (map.containsKey(prev)) f[i][1] = Math.max(f[i][1], f[map.get(prev)][1] + 1);
map.put(arr[i], i);
}
return Math.max(f[n - 1][0], f[n - 1][1]);
}
}
```
```Java
class Solution {
int N = 40009, M = N / 2;
public int longestSubsequence(int[] arr, int d) {
int n = arr.length;
int[] hash = new int[N];
Arrays.fill(hash, -1);
int[][] f = new int[n][2];
f[0][1] = 1;
hash[arr[0] + M] = 0;
for (int i = 1; i < n; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = 1;
int prev = arr[i] - d;
if (hash[prev + M] != -1) f[i][1] = Math.max(f[i][1], f[hash[prev + M]][1] + 1);
hash[arr[i] + M] = i;
}
return Math.max(f[n - 1][0], f[n - 1][1]);
}
}
```
* 时间复杂度:令 $n$ 为数组长度,共有 $n * 2$ 个状态需要被计算,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 优化状态定义
不难发现,我们多定义一维状态来区分某个位置的值是否被选择,目的是为了正确转移出第 $i$ 位被选择的情况。
事实上,利用哈希表本身我们就能轻松做到这一点。
我们调整状态定义为:**$f[i]$ 为考虑前 $i$ 个数(第 $i$ 个数必选)时,得到的最长定差子序列长度。**
不失一般性考虑 $f[i]$ 该如何转移,分情况讨论:
* $arr[i]$ 独立成为一个子序列,此时有:$f[i] = 1$;
* $arr[i]$ 接在某一个数的后面,由于给定了差值 $difference$,可直接算得上一位的值为 $prev = arr[i] - difference$,此时应当找到 $arr[j]$ 为 $prev$ 的最新位置(下标最大,同时满足 $j < i$)当时的转移结果,在此基础上加一即可,即有:$f[i] = hash[prev] + 1$;
综上,我们有($hash$ 初始化为 $0$):
$$
f[i] = hash[prev] + 1
$$
代码(使用数组充当哈希表的代码在 $P2$):
```Java
class Solution {
public int longestSubsequence(int[] arr, int d) {
int ans = 1;
Map<Integer, Integer> map = new HashMap<>();
for (int i : arr) {
map.put(i, map.getOrDefault(i - d, 0) + 1);
ans = Math.max(ans, map.get(i));
}
return ans;
}
}
```
```Java
class Solution {
int N = 40009, M = N / 2;
public int longestSubsequence(int[] arr, int d) {
int ans = 1;
int[] hash = new int[N];
for (int i : arr) {
hash[i + M] = hash[i - d + M] + 1;
ans = Math.max(ans, hash[i + M]);
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为数组长度,共有 $n$ 个状态需要被计算,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1219. 黄金矿工（中等）.md | 1219. 黄金矿工 | https://leetcode-cn.com/problems/path-with-maximum-gold/solution/gong-shui-san-xie-hui-su-suan-fa-yun-yon-scxo/ | 中等 | [
"图论搜索",
"DFS",
"回溯算法"
] | 你要开发一座金矿,地质勘测学家已经探明了这座金矿中的资源分布,并用大小为 `m * n` 的网格 $grid$ 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量;如果该单元格是空的,那么就是 $0$。
为了使收益最大化,矿工需要按以下规则来开采黄金:
* 每当矿工进入一个单元,就会收集该单元格中的所有黄金。
* 矿工每次可以从当前位置向上下左右四个方向走。
* 每个单元格只能被开采(进入)一次。
* 不得开采(进入)黄金数目为 $0$ 的单元格。
* 矿工可以从网格中 **任意一个** 有黄金的单元格出发或者是停止。
示例 1:
```
输入:grid = [[0,6,0],[5,8,7],[0,9,0]]
输出:24
解释:
[[0,6,0],
[5,8,7],
[0,9,0]]
一种收集最多黄金的路线是:9 -> 8 -> 7。
```
示例 2:
```
输入:grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]
输出:28
解释:
[[1,0,7],
[2,0,6],
[3,4,5],
[0,3,0],
[9,0,20]]
一种收集最多黄金的路线是:1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。
```
提示:
* $1 <= grid.length, grid[i].length <= 15$
* $0 <= grid[i][j] <= 100$
* 最多 $254 个单元格中有黄金。 | ### 回溯算法
根据题意,我们可以枚举每个黄金点作为起点,然后使用 `DFS` 回溯搜索以该点作为起点所能得到的最大收益。
代码:
```Java
class Solution {
int[][] g;
boolean[][] vis;
int m, n;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
public int getMaximumGold(int[][] grid) {
g = grid;
m = g.length; n = g[0].length;
vis = new boolean[m][n];
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] != 0) {
vis[i][j] = true;
ans = Math.max(ans, dfs(i, j));
vis[i][j] = false;
}
}
}
return ans;
}
int dfs(int x, int y) {
int ans = g[x][y];
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (g[nx][ny] == 0) continue;
if (vis[nx][ny]) continue;
vis[nx][ny] = true;
ans = Math.max(ans, g[x][y] + dfs(nx, ny));
vis[nx][ny] = false;
}
return ans;
}
}
```
* 时间复杂度:爆搜复杂度为指数级别,分析时空复杂度意义不大
* 空间复杂度:爆搜复杂度为指数级别,分析时空复杂度意义不大 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1220. 统计元音字母序列的数目（困难）.md | 1220. 统计元音字母序列的数目 | https://leetcode-cn.com/problems/count-vowels-permutation/solution/gong-shui-san-xie-yi-ti-shuang-jie-xian-n8f4o/ | 困难 | [
"线性 DP",
"矩阵快速幂"
] | 给你一个整数 `n`,请你帮忙统计一下我们可以按下述规则形成多少个长度为 `n` 的字符串:
字符串中的每个字符都应当是小写元音字母('a', 'e', 'i', 'o', 'u')
* 每个元音 `'a'` 后面都只能跟着 `'e'`
* 每个元音 `'e'` 后面只能跟着 `'a'` 或者是 `'i'`
* 每个元音 `'i'` 后面 不能 再跟着另一个 `'i'`
* 每个元音 `'o'` 后面只能跟着 `'i'` 或者是 `'u'`
* 每个元音 `'u'` 后面只能跟着 `'a'`
由于答案可能会很大,所以请你返回 模 $10^9 + 7$ 之后的结果。
示例 1:
```
输入:n = 1
输出:5
解释:所有可能的字符串分别是:"a", "e", "i" , "o" 和 "u"。
```
示例 2:
```
输入:n = 2
输出:10
解释:所有可能的字符串分别是:"ae", "ea", "ei", "ia", "ie", "io", "iu", "oi", "ou" 和 "ua"。
```
示例 3:
```
输入:n = 5
输出:68
```
提示:
* $1 <= n <= 2 * 10^4$ | ### 线性 DP
**定义 $f[i][j]$ 为考虑长度为 $i + 1$ 的字符串,且结尾元素为 $j$ 的方案数(其中 $j$ 代表数组 `['a', 'e', 'i', 'o', 'u']` 下标)。**
不失一般性考虑 $f[i][j]$ 该如何计算。
**我们可以从题意给定的规则进行出发,从 $f[i]$ 出发往前更新 $f[i + 1]$,也可以直接利用对称性进行反向分析。**
为了方便大家理解,还是将常规的「从 $f[i]$ 出发往前更新 $f[i + 1]$」作为主要分析方法吧。
根据条件可以容易写出转移方程:
* 每个元音 `'a'` 后面都只能跟着 `'e'` :$f[i + 1][1] += f[i][0]$;
* 每个元音 `'e'` 后面只能跟着 `'a'` 或者是 `'i'` :$f[i + 1][0] += f[i][1]$、$f[i + 1][2] += f[i][1]$;
* 每个元音 `'i'` 后面 不能 再跟着另一个 `'i'` :$f[i + 1][j] += f[i][2], (j 不能为 2)$;
* 每个元音 `'o'` 后面只能跟着 `'i'` 或者是 `'u'` :$f[i + 1][2] += f[i][3]$、$f[i + 1][4] += f[i][3]$;
* 每个元音 `'u'` 后面只能跟着 `'a'` :$f[i + 1][0] += f[i][4]$。
**代码(利用对称性统计方案数代码见 $P2$,感谢 [@Benhao](/u/himymben/) 和 [@5cm/s 🌸](/u/megurine/) 提供的、我根本看不懂的、试图把困难题也做成「全鱼宴」题解的代码 🤣 ):**
```Java
class Solution {
int MOD = (int)1e9+7;
public int countVowelPermutation(int n) {
long[][] f = new long[n][5];
Arrays.fill(f[0], 1);
for (int i = 0; i < n - 1; i++) {
// 每个元音 'a' 后面都只能跟着 'e'
f[i + 1][1] += f[i][0];
// 每个元音 'e' 后面只能跟着 'a' 或者是 'i'
f[i + 1][0] += f[i][1];
f[i + 1][2] += f[i][1];
// 每个元音 'i' 后面 不能 再跟着另一个 'i'
f[i + 1][0] += f[i][2];
f[i + 1][1] += f[i][2];
f[i + 1][3] += f[i][2];
f[i + 1][4] += f[i][2];
// 每个元音 'o' 后面只能跟着 'i' 或者是 'u'
f[i + 1][2] += f[i][3];
f[i + 1][4] += f[i][3];
// 每个元音 'u' 后面只能跟着 'a'
f[i + 1][0] += f[i][4];
for (int j = 0; j < 5; j++) f[i + 1][j] %= MOD;
}
long ans = 0;
for (int i = 0; i < 5; i++) ans += f[n - 1][i];
return (int)(ans % MOD);
}
}
```
-
```Java
class Solution {
int MOD = (int)1e9+7;
public int countVowelPermutation(int n) {
long[][] f = new long[n][5];
Arrays.fill(f[0], 1);
for (int i = 1; i < n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = f[i - 1][0] + f[i - 1][2];
f[i][2] = f[i - 1][0] + f[i - 1][1] + f[i - 1][3] + f[i - 1][4];
f[i][3] = f[i - 1][2] + f[i - 1][4];
f[i][4] = f[i - 1][0];
for (int j = 0; j < 5; j++) f[i][j] %= MOD;
}
long ans = 0;
for (int i = 0; i < 5; i++) ans += f[n - 1][i];
return (int)(ans % MOD);
}
}
```
-
```Python
MOD = int(1e9) + 7
class Solution:
def countVowelPermutation(self, n: int) -> int:
f = [[1] * 5] + [[0] * 5 for _ in range(n - 1)]
for i in range(1, n):
f[i][0] = f[i-1][1]
f[i][1] = (f[i-1][0] + f[i-1][2]) % MOD
f[i][2] = ((((f[i-1][0] + f[i-1][1]) % MOD + f[i-1][3]) % MOD) + f[i-1][4]) % MOD
f[i][3] = (f[i-1][2] + f[i-1][4]) % MOD
f[i][4] = f[i-1][0]
return (((((f[-1][0] + f[-1][1]) % MOD + f[-1][2]) % MOD + f[-1][3]) % MOD) + f[-1][4]) % MOD
```
-
```Go
const MOD int = 1e9 + 7
func countVowelPermutation(n int) int {
f := make([][]int, n)
f[0] = []int{1, 1, 1, 1, 1}
for i := 1; i < n; i++ {
f[i] = make([]int, 5)
f[i][0] = f[i-1][1]
f[i][1] = (f[i-1][0] + f[i-1][2]) % MOD
f[i][2] = (((f[i-1][0] + f[i-1][1]) % MOD + f[i-1][3]) % MOD + f[i-1][4]) % MOD
f[i][3] = (f[i-1][2] + f[i-1][4]) % MOD
f[i][4] = f[i-1][0]
}
return ((((f[n-1][0] + f[n-1][1]) % MOD + f[n-1][2]) % MOD + f[n-1][3]) % MOD + f[n-1][4]) % MOD
}
```
-
```Elixir
defmodule Solution do
@spec count_vowel_permutation(n :: integer) :: integer
def count_vowel_permutation(n) do
solve(n, 1, 1, 1, 1, 1)
end
def solve(1, a, e, i, o, u) do
rem((a + e + i + o + u), 1000000007)
end
def solve(n, a, e, i, o, u) do
solve(n - 1, add(e, i, u), add(a, i), add(e, o), i, add(i, o))
end
def add(n1, n2) do
add(n1, n2, 0)
end
def add(n1, n2, n3) do
rem(n1 + n2 + n3, 1000000007)
end
end
```
-
```Erlang
-spec count_vowel_permutation(N :: integer()) -> integer().
count_vowel_permutation(N) ->
solve(N, 1, 1, 1, 1, 1).
solve(1, A, E, I, O, U) ->
(A + E + I + O + U) rem 1000000007;
solve(N, A, E, I, O, U) ->
solve(N - 1, add(E, I, U), add(A, I), add(E, O), I, add(I, O)).
add(N1, N2) ->
add(N1, N2, 0).
add(N1, N2, N3) ->
(N1 + N2 + N3) rem 1000000007.
```
-
```Racket
(define/contract (count-vowel-permutation n)
(-> exact-integer? exact-integer?)
(define MOD 1000000007)
(define (ad nums [tot 0])
(cond
[(empty? nums) (remainder tot MOD)]
[else (ad (cdr nums) (+ tot (car nums)))]
)
)
(let loop([n n] [a 1] [e 1] [i 1] [o 1] [u 1])
(cond
[(= n 1) (ad (list a e i o u))]
[else (loop (- n 1) (ad (list e i u)) (ad (list a i)) (ad (list e o)) i (ad (list i o)))]
)
)
)
```
-
```JS
const MOD = 10 ** 9 + 7;
const add = (...nums) => nums.reduce((a, b) => a + b) % MOD
var countVowelPermutation = function(n,a=1,e=1,i=1,o=1,u=1) {
return n === 1
? add(a, e, i, o, u)
: countVowelPermutation(n - 1, add(e, i, u), add(a, i), add(e, o), i, add(i, o))
};
```
-
```JS
const MOD = 10 ** 9 + 7;
const add = (...nums) => nums.reduce((a, b) => a + b) % MOD
var countVowelPermutation = function(n) {
let [a, e, i, o, u] = [1, 1, 1, 1, 1]
while(--n)
([a, e, i, o, u] = [add(e, i, u), add(a + i), add(e + o), i, add(i, o)])
return add(a, e, i, o, u)
};
```
* 时间复杂度:令 $C$ 为字符集大小,本题 $C$ 固定为 $5$。整体复杂度为 $O(n * C)$
* 空间复杂度:$O(n * C)$
---
### 矩阵快速幂
**通常考虑递推能否使用「矩阵快速幂」来加速,主要依据为该递推过程是否为存在「结合律」线性递推过程。**
如果是存在「结合律」的线性数列递推,诸如「斐波那契数列」等,都能使用「矩阵快速幂」来加速数列递推。
对「矩阵快速幂」不了解的同学,可以先看「矩阵快速幂の三部曲」(学过三部曲的同学做这道题应该是降维打击):
1. [简单题学「矩阵快速幂」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488198&idx=1&sn=8272ca6b0ef6530413da4a270abb68bc&chksm=fd9cb9d9caeb30cf6c2defab0f5204adc158969d64418916e306f6bf50ae0c38518d4e4ba146&token=684485087&lang=zh_CN#rd)
2. [简单题学「矩阵快速幂」II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488373&idx=1&sn=2845f7d6966658f1bb82e1dfb086dfad&chksm=fd9cb86acaeb317c3cba3aea9e63ae728749b74482494448151643bedb783d6597d7c640774b&token=684485087&lang=zh_CN#rd)
3. [矩阵快速幂的运用 :从「状态机 DP」到「矩阵快速幂」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488607&idx=1&sn=060d3e6c34344e05218f81878651fe02&chksm=fd9cbf40caeb3656f9308ea0190fac700801838356e63196c3b1b3459a5f01c646e7e9abe2fd&token=684485087&lang=zh_CN#rd)
我们最终需要求的是 $\sum_{i = 0}^{4} f[n - 1][i]$,将需要求得的部分列成列向量:
$$
ans = \begin{bmatrix}
f[n - 1][0]\\
f[n - 1][1]\\
f[n - 1][2]\\
f[n - 1][3]\\
f[n - 1][4]
\end{bmatrix}
$$
同时我们有起始的矩阵(每个元音字母独立成为一个字符):
$$
ori =
\begin{bmatrix}
f[0][0]\\
f[0][1]\\
f[0][2]\\
f[0][3]\\
f[0][4]
\end{bmatrix} = \begin{bmatrix}
1\\
1\\
1\\
1\\
1
\end{bmatrix}
$$
我们知道 $f[i][X]$ 依赖于 $f[i - 1][X]$,同时在「解法一」中明确了各个 $f[i][j]$ 与 $f[i - 1][X]$ 的关系。
根据「矩阵乘法」,不难发现:
$$
\begin{bmatrix}
f[i][0]\\
f[i][1]\\
f[i][2]\\
f[i][3]\\
f[i][4]
\end{bmatrix} =
\begin{bmatrix}
0& 1& 0& 0& 0\\
1& 0& 1& 0& 0\\
1& 1& 0& 1& 1\\
0& 0& 1& 0& 1\\
1& 0& 0& 0& 0
\end{bmatrix}
*
\begin{bmatrix}
f[i - 1][0]\\
f[i - 1][1]\\
f[i - 1][2]\\
f[i - 1][3]\\
f[i - 1][4]
\end{bmatrix}
$$
我们令:
$$
mat = \begin{bmatrix}
0& 1& 0& 0& 0\\
1& 0& 1& 0& 0\\
1& 1& 0& 1& 1\\
0& 0& 1& 0& 1\\
1& 0& 0& 0& 0
\end{bmatrix}
$$
根据递推关系,可得:
$$
ans = mat * mat * ... * mat * ori
$$
再根据矩阵乘法具有「结合律」,最终可得:
$$
ans = mat^{n - 1} * ori
$$
**代码(感谢 [@Benhao](/u/himymben/) 同学提供的「行向量」写法):**
```Java
class Solution {
int MOD = (int)1e9+7;
long[][] mul(long[][] a, long[][] b) {
int r = a.length, c = b[0].length, z = b.length;
long[][] ans = new long[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < z; k++) {
ans[i][j] += a[i][k] * b[k][j];
ans[i][j] %= MOD;
}
}
}
return ans;
}
public int countVowelPermutation(int n) {
long[][] ans = new long[][]{
{1}, {1}, {1}, {1}, {1}
};
long[][] mat = new long[][]{
{0, 1, 0, 0, 0},
{1, 0, 1, 0, 0},
{1, 1, 0, 1, 1},
{0, 0, 1, 0, 1},
{1, 0, 0, 0, 0},
};
int x = n - 1;
while (x != 0) {
if ((x & 1) != 0) ans = mul(mat, ans);
mat = mul(mat, mat);
x >>= 1;
}
long sum = 0;
for (int i = 0; i < 5; i++) sum += ans[i][0];
return (int)(sum % MOD);
}
}
```
-
```python
import numpy as np
MOD = 10 ** 9 + 7
dtype = np.dtype('uint64')
class Solution:
def countVowelPermutation(self, n: int) -> int:
ans, mat = np.ones(5, dtype=dtype), np.array([[0, 1, 1, 0, 1], [1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0]],dtype=dtype)
n -= 1
while n:
if n & 1:
ans = ans @ mat % MOD
mat = mat @ mat % MOD
n >>= 1
return int(ans.sum()) % MOD
```
-
```Go
const MOD int = 1e9 + 7
func countVowelPermutation(n int) (res int) {
mul := func(X, Y [][]int) [][]int{
res := make([][]int, len(X))
for i := 0;i < len(res);i++{res[i] = make([]int, len(Y[0]))}
for i := 0;i < len(res);i++{
for j := 0;j < len(res[0]);j++{
for k := 0;k < len(Y);k++{
res[i][j] = (res[i][j] + X[i][k] * Y[k][j] % MOD) % MOD
}
}
}
return res
}
ans, mat := [][]int{{1, 1, 1, 1, 1}}, [][]int{{0, 1, 1, 0, 1}, {1, 0, 1, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 1, 0, 0}, {0, 0, 1, 1, 0}}
n--
for n > 0 {
if(n & 1 != 0){
tmp := mul(ans, mat)
ans = tmp
}
tmpMat := mul(mat, mat)
mat = tmpMat
n >>= 1
}
for _, row := range ans {
for _, cell := range row{
res = (res + cell) % MOD
}
}
return
}
```
* 时间复杂度:共需要执行 $\log{n}$ 次矩阵操作,运算量最大的矩阵操作为 $mat * mat$,复杂度为 $C^3$。整体复杂度为 $O(\log{n} * C^3)$
* 空间复杂度:复杂度上界为 $mat$ 大小,复杂度为 $O(C^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1129. 颜色交替的最短路径（中等）.md | 1129. 颜色交替的最短路径 | null | 中等 | [
"BFS",
"最短路"
] | 在一个有向图中,节点分别标记为 `0, 1, ..., n-1`。
图中每条边为红色或者蓝色,且存在自环或平行边。
`red_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的红色有向边。
类似地,`blue_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的蓝色有向边。
返回长度为 `n` 的数组 `answer`,其中 `answer[X]` 是从节点 `0` 到节点 `X` 的红色边和蓝色边交替出现的最短路径的长度。
如果不存在这样的路径,那么 `answer[x] = -1`。
示例 1:
```
输入:n = 3, red_edges = [[0,1],[1,2]], blue_edges = []
输出:[0,1,-1]
```
示例 2:
```
输入:n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]
输出:[0,1,-1]
```
示例 3:
```
输入:n = 3, red_edges = [[1,0]], blue_edges = [[2,1]]
输出:[0,-1,-1]
```
示例 4:
```
输入:n = 3, red_edges = [[0,1]], blue_edges = [[1,2]]
输出:[0,1,2]
```
示例 5:
```
输入:n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]]
输出:[0,1,1]
```
提示:
* `1 <= n <= 100`
* `red_edges.length <= 400`
* `blue_edges.length <= 400`
* `red_edges[i].length = blue_edges[i].length = 2`
* `0 <= red_edges[i][j], blue_edges[i][j] < n` | ### 朴素 BFS
为了方便,将 `redEdges` 记为 `rs`,将 `blueEdges` 记为 `bs`。
使用两数组进行建图,利用点数和边数关系(稀疏图),使用「邻接表」方式进行建图。
将所有红色有向边权值记为 `1`,将所有蓝色有向边权值记为 `-1`。注意这里的权重仅表示该边的颜色,并非代表经过该边的真实成本。
也正是经过所有边的成本均相同,对于原问题「从 `0` 号节点进行出发,求到所有点的颜色交替的最短路径」,我们容易想到使用 `BFS` 进行求解。
`BFS` 过程中将三元组 $(point, last, step)$ 进行入队:
* `point` 代表当前所在点编号
* `last` 代表到达 `point` 所使用的边的颜色,默认为 `0` 代表不需要经过任何边到达起点
* `step` 代表到达 `point` 所使用的步数
利用数据范围不大(点数为 $100$,边数为 $800$),可以直接对每个点进行一次独立的 `BFS` 来求最短路。由于图存在重边和自环,因此在求解最短路的过程需要对边进行去重。
Java 代码:
```Java
class Solution {
static int N = 110, M = 810, idx = 0;
static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
w[idx] = c;
ne[idx] = he[a];
he[a] = idx++;
}
public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {
idx = 0;
Arrays.fill(he, -1);
for (int[] e : rs) add(e[0], e[1], 1);
for (int[] e : bs) add(e[0], e[1], -1);
int[] ans = new int[n];
boolean[] vis = new boolean[rs.length + bs.length];
out:for (int k = 1; k < n; k++) {
ans[k] = -1;
Arrays.fill(vis, false);
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{0, 0, 0}); // point, last, step
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int p = info[0], last = info[1], step = info[2];
for (int i = he[p]; i != -1; i = ne[i]) {
int j = e[i], c = w[i];
if (vis[i]) continue;
if (c + last == 0 || last == 0) {
if (j == k) {
ans[k] = step + 1;
continue out;
} else {
d.addLast(new int[]{j, c, step + 1});
vis[i] = true;
}
}
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int he[110], e[810], ne[810], w[810], idx = 0;
void add(int a, int b, int c) {
e[idx] = b;
w[idx] = c;
ne[idx] = he[a];
he[a] = idx++;
}
vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {
idx = 0;
fill(he, he + n, -1);
for (auto& e : rs) add(e[0], e[1], 1);
for (auto& e : bs) add(e[0], e[1], -1);
vector<int> ans(n);
vector<bool> vis(rs.size() + bs.size());
for (int k = 1; k < n; k++) {
ans[k] = -1;
fill(vis.begin(), vis.end(), false);
queue<vector<int>> q;
q.push({ 0, 0, 0 }); // point, last, step
bool out = false;
while (!q.empty()) {
if (out) break;
vector<int> info = q.front(); q.pop();
int p = info[0], last = info[1], step = info[2];
for (int i = he[p]; i != -1; i = ne[i]) {
int j = e[i], c = w[i];
if (vis[i]) continue;
if (c + last == 0 || last == 0) {
if (j == k) {
ans[k] = step + 1;
out = true;
break;
} else {
q.push({ j, c, step + 1 });
vis[i] = true;
}
}
}
}
}
return ans;
}
};
```
* 时间复杂度:将点数记为 `n` ,边数记为 `m`。建图复杂度为 $O(m)$;构造答案复杂度为 $O(n \times (n + m))$。整体复杂度为 $O(n \times (n + m))$
* 空间复杂度:$O(n + m)$
---
### 优化
实际上,我们并没有对每个点进行独立 `BFS` 的必要。
为了获取所有从节点 `0` 出发的最短路,可直接从节点 `0` 进行出发(对边进行去重),所有能够从节点 `0` 沿交替路径到达的节点必然都会被访问到,且节点首次被访问到时必然是最短路径。
因此我们只需要初始化所有的 `ans[i] = -1`,并从节点 `0` 开始进行一次 `BFS` 即可。
Java 代码:
```Java
class Solution {
static int N = 110, M = 810, idx = 0;
static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
w[idx] = c;
ne[idx] = he[a];
he[a] = idx++;
}
public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {
idx = 0;
Arrays.fill(he, -1);
for (int[] e : rs) add(e[0], e[1], 1);
for (int[] e : bs) add(e[0], e[1], -1);
int[] ans = new int[n];
Arrays.fill(ans, -1);
ans[0] = 0;
boolean[] vis = new boolean[rs.length + bs.length];
Arrays.fill(vis, false);
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{0, 0, 0}); // point, last, step
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int p = info[0], last = info[1], step = info[2];
for (int i = he[p]; i != -1; i = ne[i]) {
if (vis[i]) continue;
int j = e[i], c = w[i];
if (c + last == 0 || last == 0) {
ans[j] = ans[j] == -1 ? step + 1 : Math.min(ans[j], step + 1);
d.addLast(new int[]{j, c, step + 1});
vis[i] = true;
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int he[110], e[810], ne[810], w[810], idx = 0;
void add(int a, int b, int c) {
e[idx] = b;
w[idx] = c;
ne[idx] = he[a];
he[a] = idx++;
}
vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {
idx = 0;
fill(he, he + n, -1);
for (auto& e : rs) add(e[0], e[1], 1);
for (auto& e : bs) add(e[0], e[1], -1);
vector<int> ans(n, -1);
ans[0] = 0;
vector<bool> vis(rs.size() + bs.size(), false);
deque<vector<int>> d;
d.push_back({0, 0, 0}); // point, last, step
while (!d.empty()) {
vector<int> info = d.front();
d.pop_front();
int p = info[0], last = info[1], step = info[2];
for (int i = he[p]; i != -1; i = ne[i]) {
if (vis[i]) continue;
int j = e[i], c = w[i];
if (c + last == 0 || last == 0) {
ans[j] = ans[j] == -1 ? step + 1 : min(ans[j], step + 1);
d.push_back({j, c, step + 1});
vis[i] = true;
}
}
}
return ans;
}
};
```
* 时间复杂度:将点数记为 `n` ,边数记为 `m`。建图复杂度为 $O(m)$;构造答案复杂度为 $O(n + m)$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1129` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1221. 分割平衡字符串（简单）.md | 1221. 分割平衡字符串 | https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wumnk/ | 简单 | [
"贪心",
"双指针"
] | 在一个 平衡字符串 中,'L' 和 'R' 字符的数量是相同的。
给你一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串。
注意:分割得到的每个字符串都必须是平衡字符串。
返回可以通过分割得到的平衡字符串的 最大数量 。
示例 1:
```
输入:s = "RLRRLLRLRL"
输出:4
解释:s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
```
示例 2:
```
输入:s = "RLLLLRRRLR"
输出:3
解释:s 可以分割为 "RL"、"LLLRRR"、"LR" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
```
示例 3:
```
输入:s = "LLLLRRRR"
输出:1
解释:s 只能保持原样 "LLLLRRRR".
```
示例 4:
```
输入:s = "RLRRRLLRLL"
输出:2
解释:s 可以分割为 "RL"、"RRRLLRLL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
```
提示:
* 1 <= s.length <= 1000
* s[i] = 'L' 或 'R'
* s 是一个 平衡 字符串 | ### 基本分析
题目确保了 `s` 为一个平衡字符串,即必然能分割成若干个 `LR` 子串。
一个合法的 `LR` 子串满足 `L` 字符和 `R` 字符数量相等,常规检查一个字符串是否为合格的 `LR` 子串可以使用 $O(n)$ 的遍历方式,可以使用记录前缀信息的数据结构,而对于成对结构的元素统计,更好的方式是转换为数学判定,使用 `1` 来代指 `L` 得分,使用 `-1` 来代指 `R` 得分。
那么一个子串为合格 `LR` 子串的充要条件为 **整个 `LR` 子串的总得分为 $0$**。
这种方式最早应该在 [(题解) 301. 删除无效的括号](https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/) 详细讲过,可延伸到任意的成对结构元素统计题目里去。
---
### 贪心
回到本题,题目要求分割的 `LR` 子串尽可能多,直观上应该是尽可能让每个分割串尽可能短。
**我们使用「归纳法」来证明该猜想的正确性。**
首先题目数据保证给定的 `s` 本身是合法的 `LR` 子串,假设从 $[0...a]$ 可以从 `s` 中分割出 **长度最小** 的 `LR` 子串,而从 $[0...b]$ 能够分割出 **长度更大** 的 `LR` 子串(即 `a <= b` )。
**我们来证明起始时(第一次分割)「将从 `b` 分割点将 `s` 断开」调整为「从 `a` 分割点将 `s` 断开」结果不会变差:**
1. 从 `b` 点首次分割调整为从 `a` 点首次分割,两种分割形式分割点两端仍为合法 `LR` 子串,因此不会从“有解”变成“无解”;
2. 从 `b` 分割后的剩余部分长度小于从 `a` 分割后的剩余部分,同时由 `b` 分割后的剩余部分会被由 `a` 分割后的剩余部分所严格覆盖,因此「对 `a` 分割的剩余部分再分割所得的子串数量」**至少** 与「从 `b` 点分割的剩余部分再分割所得的子串数量」相等(不会变少)。
**至此,我们证明了对于首次分割,将任意合格分割点调整为最小分割点,结果不会变得更差(当 `a < b` 时还会更好)。**
**同时,由于首次分割后的剩余部分仍为合格的 `LR` 子串,因此归纳分析所依赖的结构没有发生改变,可以将上述的推理分析推广到每一个决策的回合(新边界)中。**
**至此,我们证明了只要每一次都从最小分割点进行分割,就可以得到最优解。**
代码:
```Java
class Solution {
public int balancedStringSplit(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
int ans = 0;
for (int i = 0; i < n; ) {
int j = i + 1, score = cs[i] == 'L' ? 1 : -1;
while (j < n && score != 0) score += cs[j++] == 'L' ? 1 : -1;
i = j;
ans++;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:调用 `toCharArray` 会拷贝新数组进行返回(为遵循 `String` 的不可变原则),因此使用 `toCharArray` 复杂度为 $O(n)$,使用 `charAt` 复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1221` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1222. 可以攻击国王的皇后（中等）.md | 1222. 可以攻击国王的皇后 | https://leetcode.cn/problems/queens-that-can-attack-the-king/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hlgkx/ | 中等 | [
"模拟",
"BFS"
] | 在一个 `8x8` 的棋盘上,放置着若干「黑皇后」和一个「白国王」。
给定一个由整数坐标组成的数组 `queens`,表示黑皇后的位置;以及一对坐标 `king`,表示白国王的位置,返回所有可以攻击国王的皇后的坐标(任意顺序)。
示例 1:
```
输入:queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
输出:[[0,1],[1,0],[3,3]]
解释:
[0,1] 的皇后可以攻击到国王,因为他们在同一行上。
[1,0] 的皇后可以攻击到国王,因为他们在同一列上。
[3,3] 的皇后可以攻击到国王,因为他们在同一条对角线上。
[0,4] 的皇后无法攻击到国王,因为她被位于 [0,1] 的皇后挡住了。
[4,0] 的皇后无法攻击到国王,因为她被位于 [1,0] 的皇后挡住了。
[2,4] 的皇后无法攻击到国王,因为她和国王不在同一行/列/对角线上。
```
示例 2:
```
输入:queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]
输出:[[2,2],[3,4],[4,4]]
```
示例 3:
```
输入:queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]
输出:[[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]
```
提示:
* $1 <= queens.length <= 63$
* $queens[i].length = 2$
* $0 <= queens[i][j] < 8$
* $king.length = 2$
* $0 <= king[0], king[1] < 8$
* 一个棋盘格上最多只能放置一枚棋子。 | ### 模拟
创建一个二维数组 `dirs` 来表示八个方向的坐标偏移,同时使用变量 `step` 来表示从国王位置出发的步数。
在每个方向 `i` 上,通过 `step` 步可以到达的坐标为 $(x + dirs[i][0] \times step, y + dirs[i][1] \times step)$。
模拟过程中,我们可使用布尔数组 `checked` 来记录已处理的方向,当我们遇到皇后或越过棋盘时,可标记该方向已处理。
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
public List<List<Integer>> queensAttacktheKing(int[][] qs, int[] k) {
boolean[][] vis = new boolean[10][10];
for (int[] q : qs) vis[q[0]][q[1]] = true;
int x = k[0], y = k[1], step = 1;
List<List<Integer>> ans = new ArrayList<>();
boolean[] checked = new boolean[8];
while (step <= 8) {
for (int i = 0; i < 8; i++) {
if (checked[i]) continue;
int nx = x + dirs[i][0] * step, ny = y + dirs[i][1] * step;
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {
checked[i] = true;
} else {
if (!vis[nx][ny]) continue;
List<Integer> list = new ArrayList<>();
list.add(nx); list.add(ny);
ans.add(list);
checked[i] = true;
}
}
step++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {
vector<vector<int>> dirs {{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
vector<vector<int>> ans;
vector<vector<bool>> vis(8, vector<bool>(8, false));
for (auto& queen : queens) vis[queen[0]][queen[1]] = true;
int x = king[0], y = king[1], step = 1;
vector<bool> checked(8, false);
while (step <= 8) {
for (int i = 0; i < 8; i++) {
if (checked[i]) continue;
int nx = x + step * dirs[i][0];
int ny = y + step * dirs[i][1];
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {
checked[i] = true;
} else {
if (!vis[nx][ny]) continue;
ans.push_back({nx, ny});
checked[i] = true;
}
}
step++;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def queensAttacktheKing(self, queens: List[List[int]], king: List[int]) -> List[List[int]]:
dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]]
vis = [[False] * 8 for _ in range(8)]
for q in queens:
vis[q[0]][q[1]] = True
x, y = king
ans = []
checked = [False] * 8
step = 1
while step <= 8:
for i in range(8):
if checked[i]: continue
nx, ny = x + dirs[i][0] * step, y + dirs[i][1] * step
if nx < 0 or nx >= 8 or ny < 0 or ny >= 8:
checked[i] = True
else:
if not vis[nx][ny]: continue
ans.append([nx, ny])
checked[i] = True
step += 1
return ans
```
TypeScript 代码:
```TypeScript
function queensAttacktheKing(queens: number[][], king: number[]): number[][] {
let dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]];
let vis: boolean[][] = Array.from({length:8},()=>Array(8).fill(false));
for (let q of queens) vis[q[0]][q[1]] = true;
let x = king[0], y = king[1], step = 1;
let ans: number[][] = [];
let checked: boolean[] = Array(8).fill(false);
while (step <= 8) {
for (let i = 0; i < 8; i++) {
if (checked[i]) continue;
let nx = x + dirs[i][0] * step, ny = y + dirs[i][1] * step;
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {
checked[i] = true;
} else {
if (!vis[nx][ny]) continue;
ans.push([nx, ny]);
checked[i] = true;
}
}
step++;
}
return ans;
};
```
* 时间复杂度:$O(C)$,其中 $C = 8 \times 8$ 为棋盘总大小
* 空间复杂度:$O(C)$,其中 $C = 8 \times 8$ 为棋盘总大小
---
### BFS
上述模拟过程也可以使用 `BFS` 方式进行。
相比于直接模拟,`BFS` 无须使用额外变量记录处理过的方向以及当前位置与国王的距离。
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
public List<List<Integer>> queensAttacktheKing(int[][] qs, int[] k) {
boolean[][] vis = new boolean[10][10];
for (int[] q : qs) vis[q[0]][q[1]] = true;
Deque<int[]> d = new ArrayDeque<>();
for (int i = 0; i < 8; i++) {
int x = k[0] + dirs[i][0], y = k[1] + dirs[i][1];
if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;
d.addLast(new int[]{x, y, i});
}
List<List<Integer>> ans = new ArrayList<>();
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1], p = info[2];
if (vis[x][y]) {
List<Integer> list = new ArrayList<>();
list.add(x); list.add(y);
ans.add(list);
} else {
int nx = x + dirs[p][0], ny = y + dirs[p][1];
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;
d.addLast(new int[]{nx, ny, p});
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {
vector<vector<int>> dirs = {{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
vector<vector<bool>> vis(8, vector<bool>(8, false));
for (vector<int>& queen : queens) vis[queen[0]][queen[1]] = true;
deque<vector<int>> d;
for (int i = 0; i < 8; i++) {
int x = king[0] + dirs[i][0], y = king[1] + dirs[i][1];
if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;
d.push_back({x, y, i});
}
vector<vector<int>> res;
while (!d.empty()) {
vector<int> cur = d.front();
d.pop_front();
if (vis[cur[0]][cur[1]]) {
res.push_back({cur[0], cur[1]});
} else {
int nx = cur[0] + dirs[cur[2]][0], ny = cur[1] + dirs[cur[2]][1];
if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;
d.push_back({nx, ny, cur[2]});
}
}
return res;
}
};
```
Python 代码:
```Python
class Solution:
def queensAttacktheKing(self, queens, king):
dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]]
vis = [[False]*8 for _ in range(8)]
for q in queens: vis[q[0]][q[1]] = True
d = deque()
for i in range(8):
x = king[0] + dirs[i][0]
y = king[1] + dirs[i][1]
if x < 0 or x >= 8 or y < 0 or y >= 8: continue
d.append([x, y, i])
ans = []
while d:
cur = d.popleft()
if vis[cur[0]][cur[1]]:
ans.append([cur[0], cur[1]])
else:
x = cur[0] + dirs[cur[2]][0]
y = cur[1] + dirs[cur[2]][1]
if x < 0 or x >= 8 or y < 0 or y >= 8: continue
d.append([x, y, cur[2]])
return ans
```
TypeScript 代码:
```TypeScript
function queensAttacktheKing(queens: number[][], king: number[]): number[][] {
let dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]];
let vis: boolean[][] = Array(8).fill(false).map(() => Array(8).fill(false));
queens.forEach(q => vis[q[0]][q[1]] = true);
let d: number[][] = [];
for (let i = 0; i < 8; i++) {
let x = king[0] + dirs[i][0], y = king[1] + dirs[i][1];
if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;
d.push([x, y, i]);
}
let res = [];
while (d.length !== 0) {
let cur = d.shift();
if (vis[cur[0]][cur[1]]) {
res.push([cur[0], cur[1]]);
} else {
let x = cur[0] + dirs[cur[2]][0], y = cur[1] + dirs[cur[2]][1];
if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;
d.push([x, y, cur[2]]);
}
}
return res;
};
```
* 时间复杂度:$O(C)$,其中 $C = 4 \times 8$ 为四条线的总步数
* 空间复杂度:$O(C)$,其中 $C = 8 \times 8$ 为棋盘总大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1222` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1224. 最大相等频率（困难）.md | 1224. 最大相等频率 | https://leetcode.cn/problems/maximum-equal-frequency/solution/by-ac_oier-fviv/ | 困难 | [
"模拟",
"哈希表",
"计数"
] | 给你一个正整数数组 `nums`,请你帮忙从该数组中找出能满足下面要求的最长前缀,并返回该前缀的长度:
* 从前缀中 恰好删除一个 元素后,剩下每个数字的出现次数都相同。
如果删除这个元素后没有剩余元素存在,仍可认为每个数字都具有相同的出现次数(也就是 $0$ 次)。
示例 1:
```
输入:nums = [2,2,1,1,5,3,3,5]
输出:7
解释:对于长度为 7 的子数组 [2,2,1,1,5,3,3],如果我们从中删去 nums[4] = 5,就可以得到 [2,2,1,1,3,3],里面每个数字都出现了两次。
```
示例 2:
```
输入:nums = [1,1,1,2,2,2,3,3,3,4,4,4,5]
输出:13
```
提示:
* $2 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^5$ | ### 模拟(计数 + 分情况讨论)
我们使用 `cnt` 数组记录每个数的出现次数(即 `cnt[i] = x` 含义为数值 $i$ 的出现次数为 $x$ 次),以及使用 `sum` 来记录出现次数为某个值的数有多少个(即 `sum[i] = x` 含义为出现次数为 $i$ 的数值共有 $x$ 个),同时使用 `max` 来记录最大出现次数 $cnt[i]$。
从前往后处理 `nums`,假设当前处理到的数值为 $t = nums[i]$(前缀所含数量为 $len = i + 1$)有如下几种情况,我们可以更新最大长度 `ans`:
* $max = 1$:说明当前处理到的所有 $nums[i]$ 均只出现了一次,此时任意删除一个均满足要求;
* $max \times sum[max] + 1 = len$:说明有一个数值单独出现了一次(其余出现次数为 `max` 的数值 + 被删除的一个数 = 总数量 $len$),删除后即满足要求;
* $(max - 1) \times (sum[max - 1] + 1) + 1 = len$:说明出现次数为 `max` 的数值只有一个,其余出现次数均为 `max - 1`,对其删除一次后即满足要求(删除该出现次数为 `max` 的数值后,会导致出现次数为 `max - 1` 的数值多一个,此时有「出现次数为 `max - 1` 的数值 + 被删除的一个数 = 总数量 $len$」)。
Java 代码:
```Java
class Solution {
static int[] cnt = new int[100010], sum = new int[100010];
public int maxEqualFreq(int[] nums) {
Arrays.fill(cnt, 0); Arrays.fill(sum, 0);
int n = nums.length, max = 0, ans = 0;
for (int i = 0; i < n; i++) {
int t = nums[i], cur = ++cnt[t], len = i + 1;
sum[cur]++; sum[cur - 1]--;
max = Math.max(max, cur);
if (max == 1) ans = len;
if (max * sum[max] + 1 == len) ans = len;
if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maxEqualFreq(nums: number[]): number {
let n = nums.length, max = 0, ans = 0
const cnt = new Array<number>(100010).fill(0), sum = new Array<number>(100010).fill(0)
for (let i = 0; i < n; i++) {
let t = nums[i], len = i + 1, cur = ++cnt[t]
sum[cur]++; sum[cur - 1]--;
max = Math.max(max, cur)
if (max == 1) ans = len
if (max * sum[max] + 1 == len) ans = len
if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1233. 删除子文件夹（中等）.md | 1233. 删除子文件夹 | null | 中等 | [
"字典树"
] | 你是一位系统管理员,手里有一份文件夹列表 `folder`,你的任务是要删除该列表中的所有 子文件夹,并以 任意顺序 返回剩下的文件夹。
如果文件夹 `folder[i]` 位于另一个文件夹 `folder[j]` 下,那么 `folder[i]` 就是 `folder[j]` 的 子文件夹 。
文件夹的「路径」是由一个或多个按以下格式串联形成的字符串:`'/'` 后跟一个或者多个小写英文字母。
例如,`"/leetcode"` 和 `"/leetcode/problems"` 都是有效的路径,而空字符串和 "/" 不是。
示例 1:
```
输入:folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
输出:["/a","/c/d","/c/f"]
解释:"/a/b" 是 "/a" 的子文件夹,而 "/c/d/e" 是 "/c/d" 的子文件夹。
```
示例 2:
```
输入:folder = ["/a","/a/b/c","/a/b/d"]
输出:["/a"]
解释:文件夹 "/a/b/c" 和 "/a/b/d" 都会被删除,因为它们都是 "/a" 的子文件夹。
```
示例 3:
```
输入: folder = ["/a/b/c","/a/b/ca","/a/b/d"]
输出: ["/a/b/c","/a/b/ca","/a/b/d"]
```
提示:
* $1 <= folder.length <= 4 \times 10^4$
* $2 <= folder[i].length <= 100$
* `folder[i]` 只包含小写字母和 `'/'`
* `folder[i]` 总是以字符 `'/'` 起始
* 每个文件夹名都是 唯一 的 | ### 字典树
一道字典树裸题,不熟悉字典树的同学可以看前置 🧀 : [【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。
定义类 `Trie` 代表字典树节点,对应物理含义为某个文件夹。该节点含有属性 `s`、`isEnd` 和 `stries`,分别代表「当前节点所代表文件夹名」、「是否为当前路径的最终文件夹」以及「当前文件夹下的子文件夹集合」。
并且由于每个文件夹名的长度不定,我们使用 `Map<String, Trie>` 结构来构建 `stries`。
起始先将所有的 $folder[i]$ 加入字典树,随后查询每个 $folder[i]$ 是否为子文件夹,将所有非子文件夹加入答案。
代码:
```Java
class Solution {
class Trie {
String s;
boolean isEnd = false;
Map<String, Trie> stries = new HashMap<>();
Trie (String _s) {
s = _s;
}
}
void add(String f) {
String[] ss = f.split("/");
Trie p = root;
for (int i = 1; i < ss.length; i++) {
String s = ss[i];
if (!p.stries.containsKey(s)) p.stries.put(s, new Trie(s));
p = p.stries.get(s);
}
p.isEnd = true;
}
boolean isSubFolder(String f) {
String[] ss = f.split("/");
Trie p = root;
for (int i = 1; i < ss.length - 1; i++) {
String s = ss[i];
if (p.stries.get(s).isEnd) return true;
p = p.stries.get(s);
}
return false;
}
Trie root = new Trie("");
public List<String> removeSubfolders(String[] folder) {
for (String f : folder) add(f);
List<String> ans = new ArrayList<>();
for (String f : folder) {
if (!isSubFolder(f)) ans.add(f);
}
return ans;
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1} folder[i].length)$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1} folder[i].length)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1231-1240/1235. 规划兼职工作（困难）.md | 1235. 规划兼职工作 | https://leetcode.cn/problems/maximum-profit-in-job-scheduling/solution/by-ac_oier-rgup/ | 困难 | [
"序列 DP",
"二分",
"排序"
] | 你打算利用空闲时间来做兼职工作赚些零花钱。
这里有 `n` 份兼职工作,每份工作预计从 `startTime[i]` 开始到 `endTime[i]` 结束,报酬为 `profit[i]`。
给你一份兼职工作表,包含开始时间 `startTime`,结束时间 `endTime` 和预计报酬 `profit` 三个数组,请你计算并返回可以获得的最大报酬。
注意,时间上出现重叠的 `2` 份工作不能同时进行。
如果你选择的工作在时间 `X` 结束,那么你可以立刻进行在时间 `X` 开始的下一份工作。
示例 1:
```
输入:startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
输出:120
解释:
我们选出第 1 份和第 4 份工作,
时间范围是 [1-3]+[3-6],共获得报酬 120 = 50 + 70。
```
示例 2:
```
输入:startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
输出:150
解释:
我们选择第 1,4,5 份工作。
共获得报酬 150 = 20 + 70 + 60。
```
示例 3:
```
输入:startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
输出:6
```
提示:
* $1 <= startTime.length == endTime.length == profit.length <= 5 \times 10^4$
* $1 <= startTime[i] < endTime[i] <= 10^9$
* $1 <= profit[i] <= 10^4$ | ### 序列 DP + 二分
为了方便,我们令 `startTime` 为 `st`,`endTime` 为 `endTime`,`profit` 为 `ps`,同时定义三元组 $job[i] = (st[i], et[i], ps[i])$ 来代指某份工作。
我们知道,在理想情况下,若能将所有工作排成不重叠的直线,我们便能通过完成所有工作来取得最大收益。
归结到每个工作,我们总有「选择完成该工作」和「选择不完成该工作」两种决策。
**定义 $f[i]$ 为考虑前 $i$ 个工作,所能取得的最大收益(注意 $job[i]$ 不一定被选择完成),为了方便,我们令下标从 $1$ 开始:**
* 当不选择该工作时:由于 $job[i]$ 明确不会产生价值,可知 $f[i] = f[i - 1]$;
* 当选择该工作时:可分为「仅选择完成该工作」或「选择 **考虑** 将该工作接在某个工作后面完成」两种情况:
* 当「仅选择完成该工作」时,我们有 $f[i] = job[i][2]$;
* 当「选择 **考虑** 将该工作接在某个工作后面完成」时,我们需要在所有满足「$job[j][1] <= job[i][0]$」中选择最适合的 $job[j]$ 接在 $job[i]$ 的前面。
即在所有能够在 $job[i]$ 开始前顺利结束的 $job[j]$ 中取最大的 $f[j]$,此时有 $f[i] = f[j] + job[i][2]$
> 需要注意:这里的“接在”是指将 $job[j]$ 纳入考虑,但具体方案中,并不一定选择 $job[j]$ 来执行(好好想想我们的 $f[i]$ 状态定义)
最终 $f[i]$ 为上述三种方案中的最大值,并且最终的 $f[n]$ 即是我们的答案。
**当我们处理到 $job[i]$ 时,为了能够「将所有所能拼接在 $job[i]$ 前面的 $job[j]$ 归结到一边」并且「所能更新 $f[i]$ 的 $f[j]$ 均被计算」,我们可以通过对所有的 $job[i]$ 进行右端点(结束时间)进行排升序,并按照从小到大的方式处理每个 $job[i]$。**
此处排序的意义有两点:
* 由于我们是根据右端点排序,当我们处理到某个 $job[i]$ 时,由于有 $job[X][0] < job[X][1]$,因此所能接在 $job[i]$ 前面(结束时间小于等于 $job[i]$ 开始时间)的 $job[j]$ 必然位于 $[0, i)$ 之间;
* 由于我们对 $f[i]$ 的定义并不限定了必须选 $job[i]$,因此在 $[0, i)$ 范围内以 $job[j]$ 为分割点的数组的具有「二段性」:坐标范围小于等于 $j$ 的 $job[X]$ 均可“接在” $job[i]$ 前面。因此我们可通过「二分」来找所能接在 $job[i]$ 前面的坐标最大的 $job[j]$。
Java 代码:
```Java
class Solution {
public int jobScheduling(int[] st, int[] et, int[] ps) {
int n = st.length;
List<int[]> list = new ArrayList<>();
for (int i = 0; i < n; i++) list.add(new int[]{st[i], et[i], ps[i]});
Collections.sort(list, (a, b)->a[1] - b[1]);
int[] f = new int[n + 10];
for (int i = 1; i <= n; i++) {
int[] info = list.get(i - 1);
int a = info[0], b = info[1], c = info[2];
f[i] = Math.max(f[i - 1], c);
int l = 0, r = i - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid)[1] <= a) l = mid;
else r = mid - 1;
}
if (list.get(r)[1] <= a) f[i] = Math.max(f[i], f[r + 1] + c);
}
return f[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
int n = startTime.size();
vector<vector<int>> list(n);
for (int i = 0; i < n; i++) list[i] = {startTime[i], endTime[i], profit[i]};
sort(list.begin(), list.end(), [](vector<int> a, vector<int> b)->bool{return a[1] < b[1];});
vector<int> f(n + 10, 0);
for(int i = 1; i <= n; i++) {
int a = list[i - 1][0], b = list[i - 1][1], c = list[i - 1][2];
f[i] = max(f[i - 1], c);
int l = 0, r = i - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list[mid][1] <= a) l = mid;
else r = mid - 1;
}
if (list[r][1] <= a) f[i] = max(f[i], f[r + 1] + c);
}
return f[n];
}
};
```
Python 代码:
```Python
class Solution:
def jobScheduling(self, st: List[int], et: List[int], ps: List[int]) -> int:
n = len(st)
jobs = [(st[i], et[i], ps[i]) for i in range(n)]
jobs.sort(key=lambda x: x[1])
f = [0] * (n + 10)
for i in range(1, n + 1):
a, b, c = jobs[i - 1]
f[i] = max(f[i - 1], c)
l, r = 0, i - 1
while l < r:
mid = l + r + 1 >> 1
if jobs[mid][1] <= a:
l = mid
else:
r = mid - 1
if jobs[r][1] <= a:
f[i] = max(f[i], f[r + 1] + c)
return f[n]
```
TypeScript 代码:
```TypeScript
function jobScheduling(st: number[], et: number[], ps: number[]): number {
const n = st.length
const list = new Array<Array<number>>()
for (let i = 0; i < n; i++) list.push([st[i], et[i], ps[i]])
list.sort((a,b)=>a[1]-b[1])
const f = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) {
const info = list[i - 1]
const a = info[0], b = info[1], c = info[2]
f[i] = Math.max(f[i - 1], c)
let l = 0, r = i - 1
while (l < r) {
const mid = l + r + 1 >> 1
if (list[mid][1] <= a) l = mid
else r = mid - 1
}
if (list[r][1] <= a) f[i] = Math.max(f[i], f[r + 1] + c)
}
return f[n]
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;`DP` 过程共有 $n$ 个状态需要转移,每次转移需要进行二分,单次复杂度为 $O(\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1231-1240/1239. 串联字符串的最大长度（中等）.md | 1239. 串联字符串的最大长度 | https://leetcode-cn.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/solution/gong-shui-san-xie-yi-ti-san-jie-jian-zhi-nfeb/ | 中等 | [
"DFS",
"二进制枚举",
"模拟退火",
"随机化",
"启发式搜索"
] | 给定一个字符串数组 `arr`,字符串 `s` 是将 `arr` 某一子序列字符串连接所得的字符串,如果 `s` 中的每一个字符都只出现过一次,那么它就是一个可行解。
请返回所有可行解 `s` 中最长长度。
示例 1:
```
输入:arr = ["un","iq","ue"]
输出:4
解释:所有可能的串联组合是 "","un","iq","ue","uniq" 和 "ique",最大长度为 4。
```
示例 2:
```
输入:arr = ["cha","r","act","ers"]
输出:6
解释:可能的解答有 "chaers" 和 "acters"。
```
示例 3:
```
输入:arr = ["abcdefghijklmnopqrstuvwxyz"]
输出:26
```
提示:
* $1 <= arr.length <= 16$
* $1 <= arr[i].length <= 26$
* `arr[i]` 中只含有小写英文字母 | ### 基本分析
根据题意,可以将本题看做一类特殊的「数独问题」:在给定的 `arr` 字符数组中选择,尽可能多的覆盖一个 $1 \times 26$ 的矩阵。
对于此类「精确覆盖」问题,换个角度也可以看做「组合问题」。
通常有几种做法:`DFS`、剪枝 `DFS`、二进制枚举、模拟退火、`DLX`。
其中一头一尾解法过于简单和困难,有兴趣的同学自行了解与实现。
---
### 剪枝 DFS
根据题意,可以有如下的剪枝策略:
1. 预处理掉「本身具有重复字符」的无效字符串,并去重;
2. 由于只关心某个字符是否出现,而不关心某个字符在原字符串的位置,因此可以将字符串使用 `int` 进行表示;
3. 由于使用 `int` 进行表示,因而可以使用「位运算」来判断某个字符是否可以被追加到当前状态中;
4. `DFS` 过程中维护一个 `total`,代表后续未经处理的字符串所剩余的“最大价值”是多少,从而实现剪枝;
5. 使用 `lowbit` 计算某个状态对应的字符长度是多少;
6. 使用「全局哈希表」记录某个状态对应的字符长度是多少(使用 `static` 修饰,确保某个状态在所有测试数据中只会被计算一次);
7. 【未应用】由于存在第 $4$ 点这样的「更优性剪枝」,理论上我们可以根据「字符串所包含字符数量」进行从大到小排序,然后再进行 `DFS` 这样效果理论上会更好。想象一下如果存在一个包含所有字母的字符串,先选择该字符串,后续所有字符串将不能被添加,那么由它出发的分支数量为 $0$;而如果一个字符串只包含单个字母,先决策选择该字符串,那么由它出发的分支数量必然大于 $0$。但该策略实测效果不好,没有添加到代码中。
代码:
```Java
class Solution {
// 本来想使用如下逻辑将「所有可能用到的状态」打表,实现 O(1) 查询某个状态有多少个字符,但是被卡了
// static int N = 26, M = (1 << N);
// static int[] cnt = new int[M];
// static {
// for (int i = 0; i < M; i++) {
// for (int j = 0; j < 26; j++) {
// if (((i >> j) & 1) == 1) cnt[i]++;
// }
// }
// }
static Map<Integer, Integer> map = new HashMap<>();
int get(int cur) {
if (map.containsKey(cur)) {
return map.get(cur);
}
int ans = 0;
for (int i = cur; i > 0; i -= lowbit(i)) ans++;
map.put(cur, ans);
return ans;
}
int lowbit(int x) {
return x & -x;
}
int n;
int ans = Integer.MIN_VALUE;
int[] hash;
public int maxLength(List<String> _ws) {
n = _ws.size();
HashSet<Integer> set = new HashSet<>();
for (String s : _ws) {
int val = 0;
for (char c : s.toCharArray()) {
int t = (int)(c - 'a');
if (((val >> t) & 1) != 0) {
val = -1;
break;
}
val |= (1 << t);
}
if (val != -1) set.add(val);
}
n = set.size();
if (n == 0) return 0;
hash = new int[n];
int idx = 0;
int total = 0;
for (Integer i : set) {
hash[idx++] = i;
total |= i;
}
dfs(0, 0, total);
return ans;
}
void dfs(int u, int cur, int total) {
if (get(cur | total) <= ans) return;
if (u == n) {
ans = Math.max(ans, get(cur));
return;
}
// 在原有基础上,选择该数字(如果可以)
if ((hash[u] & cur) == 0) {
dfs(u + 1, hash[u] | cur, total - (total & hash[u]));
}
// 不选择该数字
dfs(u + 1, cur, total);
}
}
```
---
### 二进制枚举
首先还是对所有字符串进行预处理。
然后使用「二进制枚举」的方式,枚举某个字符串是否被选择。
举个🌰,$(110)_{2}$ 代表选择前两个字符串,$(011)_{2}$ 代表选择后两个字符串,这样我们便可以枚举出所有组合方案。
代码:
```Java
class Solution {
static Map<Integer, Integer> map = new HashMap<>();
int get(int cur) {
if (map.containsKey(cur)) {
return map.get(cur);
}
int ans = 0;
for (int i = cur; i > 0; i -= lowbit(i)) ans++;
map.put(cur, ans);
return ans;
}
int lowbit(int x) {
return x & -x;
}
int n;
int ans = Integer.MIN_VALUE;
Integer[] hash;
public int maxLength(List<String> _ws) {
n = _ws.size();
HashSet<Integer> set = new HashSet<>();
for (String s : _ws) {
int val = 0;
for (char c : s.toCharArray()) {
int t = (int)(c - 'a');
if (((val >> t) & 1) != 0) {
val = -1;
break;
}
val |= (1 << t);
}
if (val != -1) set.add(val);
}
n = set.size();
if (n == 0) return 0;
hash = new Integer[n];
int idx = 0;
for (Integer i : set) hash[idx++] = i;
for (int i = 0; i < (1 << n); i++) {
int cur = 0, val = 0;
for (int j = 0; j < n; j++) {
if (((i >> j) & 1) == 1) {
if ((cur & hash[j]) == 0) {
cur |= hash[j];
val += get(hash[j]);
} else {
cur = -1;
break;
}
}
}
if (cur != -1) ans = Math.max(ans, val);
}
return ans;
}
}
```
---
### 模拟退火
事实上,可以将原问题看作求「最优前缀序列」问题,从而使用「模拟退火」进行求解。
具体的,我们可以定义「最优前缀序列」为 **组成最优解所用到的字符串均出现在排列的前面。**
举个🌰,假如构成最优解使用到的字符串集合为 `[a,b,c]`,那么对应 `[a,b,c,...]`、`[a,c,b,...]` 均称为「最优前缀序列」。
不难发现,答案与最优前缀序列是一对多关系,这指导我们可以将「参数」调得宽松一些。
**具有「一对多」关系的问题十分适合使用「模拟退火」,使用「模拟退火」可以轻松将本题 `arr.length` 数据范围上升到 $60$ 甚至以上。**
调整成比较宽松的参数可以跑赢「二进制枚举」,但为了以后增加数据不容易被 hack,还是使用 `N=400` & `fa=0.90` 的搭配。
「模拟退火」的几个参数的作用在 [这里](https://leetcode-cn.com/problems/find-minimum-time-to-finish-all-jobs/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-4epdd/) 说过了,不再赘述。
代码:
```Java
class Solution {
static Map<Integer, Integer> map = new HashMap<>();
int get(int cur) {
if (map.containsKey(cur)) {
return map.get(cur);
}
int ans = 0;
for (int i = cur; i > 0; i -= lowbit(i)) ans++;
map.put(cur, ans);
return ans;
}
int lowbit(int x) {
return x & -x;
}
int n;
int ans = Integer.MIN_VALUE;
Random random = new Random(20210619);
double hi = 1e4, lo = 1e-4, fa = 0.90;
int N = 400;
int calc() {
int mix = 0, cur = 0;
for (int i = 0; i < n; i++) {
int hash = ws[i];
if ((mix & hash) == 0) {
mix |= hash;
cur += get(hash);
} else {
break;
}
}
ans = Math.max(ans, cur);
return cur;
}
void shuffle(int[] nums) {
for (int i = n; i > 0; i--) {
int idx = random.nextInt(i);
swap(nums, idx, i - 1);
}
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
void sa() {
shuffle(ws);
for (double t = hi; t > lo; t *= fa) {
int a = random.nextInt(n), b = random.nextInt(n);
int prev = calc();
swap(ws, a, b);
int cur = calc();
int diff = cur - prev;
if (Math.log(-diff / t) > random.nextDouble()) swap(ws, a, b);
}
}
int[] ws;
public int maxLength(List<String> _ws) {
// 预处理字符串:去重,剔除无效字符
// 结果这一步后:N 可以下降到 100;fa 可以下降到 0.70,耗时约为 78 ms
// 为了预留将来添加测试数据,题解还是保持 N = 400 & fa = 0.90 的配置
n = _ws.size();
HashSet<Integer> set = new HashSet<>();
for (String s : _ws) {
int val = 0;
for (char c : s.toCharArray()) {
int t = (int)(c - 'a');
if (((val >> t) & 1) != 0) {
val = -1;
break;
}
val |= (1 << t);
}
if (val != -1) set.add(val);
}
n = set.size();
if (n == 0) return 0;
ws = new int[n];
int idx = 0;
for (Integer i : set) ws[idx++] = i;
while (N-- > 0) sa();
return ans;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1252. 奇数值单元格的数目（简单）.md | 1252. 奇数值单元格的数目 | https://leetcode.cn/problems/cells-with-odd-values-in-a-matrix/solution/by-ac_oier-p0za/ | 简单 | [
"模拟",
"位运算",
"计数"
] | 给你一个 $m \times n$ 的矩阵,最开始的时候,每个单元格中的值都是 $0$。
另有一个二维索引数组 `indices`,$indices[i] = [r_i, c_i]$ 指向矩阵中的某个位置,其中 $r_i$ 和 $c_i$ 分别表示指定的行和列(从 $0$ 开始编号)。
对 $indices[i]$ 所指向的每个位置,应同时执行下述增量操作:
* $r_i$ 行上的所有单元格,加 $1$ 。
* $c_i$ 列上的所有单元格,加 $1$ 。
给你 $m$、$n$ 和 $indices$ 。请你在执行完所有 $indices$ 指定的增量操作后,返回矩阵中 奇数值单元格 的数目。
示例 1:
```
输入:m = 2, n = 3, indices = [[0,1],[1,1]]
输出:6
解释:最开始的矩阵是 [[0,0,0],[0,0,0]]。
第一次增量操作后得到 [[1,2,1],[0,1,0]]。
最后的矩阵是 [[1,3,1],[1,3,1]],里面有 6 个奇数。
```
示例 2:
```
输入:m = 2, n = 2, indices = [[1,1],[0,0]]
输出:0
解释:最后的矩阵是 [[2,2],[2,2]],里面没有奇数。
```
提示:
* $1 <= m, n <= 50$
* $1 <= indices.length <= 100$
* $0 <= r_i < m$
* $0 <= c_i < n$
进阶:你可以设计一个时间复杂度为 $O(n + m + indices.length)$ 且仅用 $O(n + m)$ 额外空间的算法来解决此问题吗? | ### 基本分析
容易想到时间复杂度为 $O(l + m \times n)$,空间复杂度为 $O(m + n)$ 的做法,在此不再赘述。
对于某个位置最终累加值为奇数的充要条件为「所在行被累加次数的奇偶性」与「所在列被累加次数的奇偶性」不同。
因此我们可以统计累加次数为奇数的行数 $a$(累加次数为偶数的行数为 $m - a$),累加次数为奇数的列数 $b$(累加次数为偶数的列数为 $n - b$),根据乘法原理,最终答案为 $a \times (n - b) + (m - a) \times b$。
---
### 计数模拟
由于我们只需关系某个位置的奇偶性,而不关心具体的累加值,我们可以创建两个数组 `r` 和 `c`,统计每行和每列的累加值的奇偶性。
当 $r[idx]$ 为 `True` 含义为第 $idx$ 行的累加值为奇数,否则为偶数。列数组 `c` 的统计规则同理。
Java 代码:
```Java
class Solution {
public int oddCells(int m, int n, int[][] ins) {
boolean[] r = new boolean[m], c = new boolean[n];
int a = 0, b = 0;
for (int[] info : ins) {
a += (r[info[0]] = !r[info[0]]) ? 1 : -1;
b += (c[info[1]] = !c[info[1]]) ? 1 : -1;
}
return a * (n - b) + (m - a) * b;
}
}
```
TypeScript 代码:
```TypeScript
function oddCells(m: number, n: number, ins: number[][]): number {
const r = new Array<boolean>(m).fill(false), c = new Array<boolean>(n).fill(false)
let a = 0, b = 0
for (const [i, j] of ins) {
a += (r[i] = !r[i]) ? 1 : -1
b += (c[j] = !c[j]) ? 1 : -1
}
return a * (n - b) + (m - a) * b
};
```
Python 代码:
```Python3
class Solution:
def oddCells(self, m: int, n: int, ins: List[List[int]]) -> int:
r, c = [False] * m, [False] * n
for i, j in ins:
r[i] ^= 1
c[j] ^= 1
a, b = sum(r), sum(c)
return a * (n - b) + (m - a) * b
```
* 时间复杂度:构建计数数组的复杂度为 $O(m + n)$,统计奇数行和奇数列复杂度为 $O(l)$,其中 $l$ 为数组 `ins` 的长度,复杂度为 $O(m + n + l)$
* 空间复杂度:$O(m + n)$
---
### 位运算
更进一步,我们可以使用两个 `long` 变量 $c1$ 和 $c2$ 来分别充当行和列的计数数组,当 $c1$ 的第 $k$ 位为 $1$,代表第 $k$ 行累加值为奇数,当 $c1$ 的第 $k$ 位为 $0$,代表第 $k$ 行累加值为偶数;$c2$ 的计数规则同理。而翻转二进制中的某一位可使用「异或」操作。
当处理完所有的 `ins` 之后,可通过「遍历 $c1$ 的低 $m$ 位 + 遍历 $c2$ 的低 $n$ 位」来得到行数中奇数个数 $a$,列数中奇数个数 $b$,复杂度为 $O(m + n)$;也可以使用 `bitCount` 统计 `long` 二进制数中 $1$ 的个数(本质是分治操作),复杂度为 $O(\log{64})$。
Java 代码:
```Java
class Solution {
public int oddCells(int m, int n, int[][] ins) {
long c1 = 0, c2 = 0;
for (int[] info : ins) {
c1 ^= 1L << info[0];
c2 ^= 1L << info[1];
}
int a = 0, b = 0;
for (int i = 0; i < m; i++) a += ((c1 >> i) & 1);
for (int i = 0; i < n; i++) b += ((c2 >> i) & 1);
return a * (n - b) + (m - a) * b;
}
}
```
Java 代码:
```Java
class Solution {
public int oddCells(int m, int n, int[][] ins) {
long c1 = 0, c2 = 0;
for (int[] info : ins) {
c1 ^= 1L << info[0];
c2 ^= 1L << info[1];
}
int a = Long.bitCount(c1), b = Long.bitCount(c2);
return a * (n - b) + (m - a) * b;
}
}
```
TypeScript 代码:
```TypeScript
function oddCells(m: number, n: number, ins: number[][]): number {
const c1 = [0, 0], c2 = [0, 0]
for (const [i, j] of ins) {
c1[Math.ceil(i / 32)] ^= (1 << (i % 32))
c2[Math.ceil(j / 32)] ^= (1 << (j % 32))
}
let a = 0, b = 0
for (let i = 0; i < m; i++) a += (c1[Math.ceil(i / 32)] >> (i % 32) & 1)
for (let i = 0; i < n; i++) b += (c2[Math.ceil(i / 32)] >> (i % 32) & 1)
return a * (n - b) + (m - a) * b
};
```
Python 代码:
```Python3
class Solution:
def oddCells(self, m: int, n: int, ins: List[List[int]]) -> int:
c1, c2 = 0, 0
for i, j in ins:
c1 ^= (1 << i)
c2 ^= (1 << j)
a, b = 0, 0
for i in range(m):
a += (c1 >> i) & 1
for i in range(n):
b += (c2 >> i) & 1
return a * (n - b) + (m - a) * b
```
* 时间复杂度:处理所有的 `ins` 复杂度为 $O(l)$,其中 $l$ 为数组 `ins` 的长度;使用遍历方式统计奇数行和奇数列个数复杂度为 $O(m + n)$;使用 `bitCount` 操作统计二进制中 $1$ 个数,复杂度为 $O(\log{C})$,其中 $C = 64$ 为 `long` 二进制数长度,整体复杂度为 $O(l + m + n)$ 或 $O(l + \log{C})$
* 空间复杂度:$O(1)$
---
### 答疑
评论区有同学提到 `bitCount` 的复杂度问题,如下是 `Long.bitCount` 操作的源码:
```Java
public static int bitCount(long i) {
// HD, Figure 5-14
i = i - ((i >>> 1) & 0x5555555555555555L);
i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
i = i + (i >>> 8);
i = i + (i >>> 16);
i = i + (i >>> 32);
return (int)i & 0x7f;
}
```
这自然不是通过遍历统计位数的 $O(n)$ 做法,普遍会认为是 $O(1)$。
但上述操作目的是进行成组统计(分治),而能够这样写是因为默认了 `long` 是 $64$ 长度,因此严格意义来说这段代码复杂度是 $O(\log{64})$ 的。
作为对比,可以把 `Integer.bitCount` 的源码看一下:
```Java
public static int bitCount(int i) {
// HD, Figure 5-2
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
```
统计原理如出一辙,而能够这样统计,是因为默认了 `int` 长度为 $32$,其分组统计所需要的操作次数也与二进制数的长度相关,因此复杂度为 $O(\log{32})$。
将上述两个 `bitCount` 视为 $O(1)$ 都是不对的。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1252` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1253. 重构 2 行二进制矩阵（中等）.md | 1253. 重构 2 行二进制矩阵 | null | 中等 | [
"模拟",
"贪心",
"构造"
] | 给你一个 `2` 行 `n` 列的二进制数组:
* 矩阵是一个二进制矩阵,这意味着矩阵中的每个元素不是 0 就是 1。
* 第 `0` 行的元素之和为 `upper`。
* 第 `1` 行的元素之和为 `lower`。
* 第 `i` 列(从 `0` 开始编号)的元素之和为 `colsum[i]`,`colsum` 是一个长度为 `n` 的整数数组。
你需要利用 `upper`,`lower` 和 `colsum` 来重构这个矩阵,并以二维整数数组的形式返回它。
如果有多个不同的答案,那么任意一个都可以通过本题。
如果不存在符合要求的答案,就请返回一个空的二维数组。
示例 1:
```
输入:upper = 2, lower = 1, colsum = [1,1,1]
输出:[[1,1,0],[0,0,1]]
解释:[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正确答案。
```
示例 2:
```
输入:upper = 2, lower = 3, colsum = [2,2,1,1]
输出:[]
```
示例 3:
```
输入:upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
输出:[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]
```
提示:
* $1 <= colsum.length <= 10^5$
* $0 <= upper, lower <= colsum.length$
* $0 <= colsum[i] <= 2$ | ### 贪心 + 构造
创建数组 `a` 和 `b` 分别代表目标二进制矩阵的第 `0` 行和第 `1` 行。
从前往后处理 `colsum`,复用 `upper` 和 `lower` 分别代表两行剩余 $1$ 的个数。
根据当前的 $colsum[i]$ 进行分情况讨论:
* 若 $colsum[i] = 0$,只有一种情况,当前位置两行均为 $0$
* 若 $colsum[i] = 2$,只有一种情况,当前位置两行均为 $1$
* 若 $colsum[i] = 1$,选剩余 `1` 个数较大的行,填入 $1$,另外行则填入 $0$
若处理完 `colsum` 后,两行剩余 $1$ 个数恰好均为 $0$,说明构造出了合法方案。
容易证明:**不存在某个决策回合中,必须先填入剩余个数少的一方,才能顺利构造。**
可用反证法进行证明,若存在某个回合必须填入剩余个数少的一方(假设该回合上填 `1` 下填 `0`),必然能够找到同为 $colsum[j] = 1$ 的回合进行交换,同时不影响合法性(上下行的总和不变,同时 $colsum[i] = colsum[j] = 1$)。
Java 代码:
```Java
class Solution {
public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum) {
int n = colsum.length;
List<List<Integer>> ans = new ArrayList<>();
List<Integer> a = new ArrayList<>(), b = new ArrayList<>();
for (int i = 0; i < n; i++) {
int m = colsum[i];
if (m == 0) {
a.add(0); b.add(0);
} else if (m == 2) {
upper--; lower--;
a.add(1); b.add(1);
} else {
if (upper >= lower) {
upper--;
a.add(1); b.add(0);
} else {
lower--;
a.add(0); b.add(1);
}
}
}
if (upper == 0 && lower == 0) {
ans.add(a); ans.add(b);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> reconstructMatrix(int upper, int lower, vector<int>& colsum) {
int n = colsum.size();
vector<vector<int>> ans;
vector<int> a, b;
for (int i = 0; i < n; i++) {
int m = colsum[i];
if (m == 0) {
a.push_back(0); b.push_back(0);
} else if (m == 2) {
upper--; lower--;
a.push_back(1); b.push_back(1);
} else {
if (upper >= lower) {
upper--;
a.push_back(1); b.push_back(0);
} else {
lower--;
a.push_back(0); b.push_back(1);
}
}
}
if (upper == 0 && lower == 0) {
ans.push_back(a); ans.push_back(b);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:
n = len(colsum)
ans = []
a, b = [], []
for i in range(n):
m = colsum[i]
if m == 0:
a.append(0)
b.append(0)
elif m == 2:
upper, lower = upper - 1, lower - 1
a.append(1)
b.append(1)
else:
a.append(1 if upper >= lower else 0)
b.append(0 if upper >= lower else 1)
if upper >= lower: upper -= 1
else: lower -= 1
if upper == lower == 0:
ans.append(a)
ans.append(b)
return ans
```
TypeScript 代码:
```TypeScript
function reconstructMatrix(upper: number, lower: number, colsum: number[]): number[][] {
const n = colsum.length;
let ans: number[][] = [];
let a: number[] = [], b: number[] = [];
for (let i = 0; i < n; i++) {
const m = colsum[i];
if (m === 0) {
a.push(0); b.push(0);
} else if (m === 2) {
upper--; lower--;
a.push(1); b.push(1);
} else {
if (upper >= lower) {
upper--;
a.push(1); b.push(0);
} else {
lower--;
a.push(0); b.push(1);
}
}
}
if (upper === 0 && lower === 0) {
ans.push(a); ans.push(b);
}
return ans;
};
```
* 时间复杂度:$O(C \times n)$,其中 $C = 2$ 代表行数
* 空间复杂度:$O(C \times n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1253` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1260. 二维网格迁移（简单）.md | 1260. 二维网格迁移 | https://leetcode.cn/problems/shift-2d-grid/solution/by-ac_oier-1blt/ | 简单 | [
"模拟",
"构造"
] | 给你一个 `m` 行 `n` 列的二维网格 `grid` 和一个整数 `k`。
你需要将 `grid` 迁移 `k` 次。
每次「迁移」操作将会引发下述活动:
* 位于 `grid[i][j]` 的元素将会移动到 `grid[i][j + 1]`
* 位于 `grid[i][n - 1]` 的元素将会移动到 `grid[i + 1][0]`
* 位于 `grid[m - 1][n - 1]` 的元素将会移动到 `grid[0][0]`
* 请你返回 `k` 次迁移操作后最终得到的 二维网格
示例 1:
```
输入:grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
输出:[[9,1,2],[3,4,5],[6,7,8]]
```
示例 2:
```
输入:grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
输出:[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]
```
示例 3:
```
输入:grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9
输出:[[1,2,3],[4,5,6],[7,8,9]]
```
提示:
* $m == grid.length$
* $n == grid[i].length$
* $1 <= m <= 50$
* $1 <= n <= 50$
* $-1000 <= grid[i][j] <= 1000$
* $0 <= k <= 100$ | ### 模拟
为了方便,我们令 `grid` 为 `g`,令 `n` 和 `m` 分别为 `g` 的行数和列数。
由于迁移过程存在明显规律性,因此我们可以直接 $O(1)$ 算得**每一列最终所在的列下标** `tcol = (i + k) % m`(其中 `i` 为原本的列下标),同时 $O(1)$ 算得**当前列的首行元素在新列中的行下标** `trow = ((i + k) / m) % n`,之后就是简单的遍历赋值操作。
Java 代码:
```Java
class Solution {
public List<List<Integer>> shiftGrid(int[][] g, int k) {
int n = g.length, m = g[0].length;
int[][] mat = new int[n][m];
for (int i = 0; i < m; i++) {
int tcol = (i + k) % m, trow = ((i + k) / m) % n, idx = 0;
while (idx != n) {
mat[trow++][tcol] = g[idx++][i];
if (trow == n) trow = 0;
}
}
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
List<Integer> alist = new ArrayList<>();
for (int j = 0; j < m; j++) alist.add(mat[i][j]);
ans.add(alist);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> shiftGrid(vector<vector<int>>& g, int k) {
int n = g.size(), m = g[0].size();
vector<vector<int>> mat(n, vector<int>(m));
for(int i = 0; i < m; ++i) {
int tcol = (i + k) % m, trow = ((i + k) / m) % n, idx = 0;
while(idx != n) {
mat[trow++][tcol] = g[idx++][i];
if(trow == n) trow = 0;
}
}
return mat;
}
};
```
Python 代码:
```Python
class Solution:
def shiftGrid(self, g: List[List[int]], k: int) -> List[List[int]]:
n, m = len(g), len(g[0])
mat = [[0]*m for _ in range(n)]
for i in range(m):
tcol = (i + k) % m
trow = ((i + k) // m) % n
idx = 0
while idx != n:
mat[trow][tcol] = g[idx][i]
trow, idx = (trow + 1) % n, idx + 1
return mat
```
TypeScript 代码:
```TypeScript
function shiftGrid(g: number[][], k: number): number[][] {
const n = g.length, m = g[0].length
const ans: number[][] = new Array<Array<number>>()
for (let i = 0; i < n; i++) ans[i] = new Array<number>(m).fill(0)
for (let i = 0; i < m; i++) {
let tcol = (i + k) % m, trow = Math.floor(((i + k) / m)) % n, idx = 0
while (idx != n) {
ans[trow++][tcol] = g[idx++][i]
if (trow == n) trow = 0
}
}
return ans
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1261-1270/1268. 搜索推荐系统（中等）.md | 1268. 搜索推荐系统 | https://leetcode.cn/problems/search-suggestions-system/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-gnmu/ | 中等 | [
"排序",
"字典树",
"哈希表",
"二分"
] | 给你一个产品数组 `products` 和一个字符串 `searchWord`,`products` 数组中每个产品都是一个字符串。
请你设计一个推荐系统,在依次输入单词 `searchWord` 的每一个字母后,推荐 `products` 数组中前缀与 `searchWord` 相同的最多三个产品。如果前缀相同的可推荐产品超过三个,请按字典序返回最小的三个。
请你以二维列表的形式,返回在输入 `searchWord` 每个字母后相应的推荐产品的列表。
示例 1:
```
输入:products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"
输出:[
["mobile","moneypot","monitor"],
["mobile","moneypot","monitor"],
["mouse","mousepad"],
["mouse","mousepad"],
["mouse","mousepad"]
]
解释:按字典序排序后的产品列表是 ["mobile","moneypot","monitor","mouse","mousepad"]
输入 m 和 mo,由于所有产品的前缀都相同,所以系统返回字典序最小的三个产品 ["mobile","moneypot","monitor"]
输入 mou, mous 和 mouse 后系统都返回 ["mouse","mousepad"]
```
示例 2:
```
输入:products = ["havana"], searchWord = "havana"
输出:[["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]
```
示例 3:
```
输入:products = ["bags","baggage","banner","box","cloths"], searchWord = "bags"
输出:[["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]
```
示例 4:
```
输入:products = ["havana"], searchWord = "tatiana"
输出:[[],[],[],[],[],[],[]]
```
提示:
* $1 <= products.length <= 1000$
* $1 <= Σ products[i].length <= 2 \times 10^4$
* `products[i]` 中所有的字符都是小写英文字母。
* $1 <= searchWord.length <= 1000$
* `searchWord` 中所有字符都是小写英文字母。 | ### 排序 + 字典树 + 哈希表
为了方便,将 `products` 记为 `ps`,将 `searchWord` 记为 `w`。
这是一个 `"Suggestion string"` 问题,容易想到字典树进行求解,不了解字典树的同学,可看 [前置 🧀](https://mp.weixin.qq.com/s/DBTQyNYsEgmN0Vb5fbolUg)。
由于题目要求「若有超过三个的产品可推荐,返回字典序最小的三个」,我们不妨先对 `ps` 进行排序,使 `ps` 从前往后满足字典序从小到大。
**将所有 `ps[i]` 按顺序添加到字典树 `tr` 中,添加过程中,使用两个哈希表 `minMap` 和 `maxMap` 分别记录经过某个 `tr[i][j]` 时的最小 `ps` 下标和最大 `ps` 下标**。即哈希表的 `key` 为具体的 `tr[i][j]`,对应 `value` 为经过该节点的最小或最大下标。
构建答案时,**根据当前 `w` 子串到字典树 `tr` 中查询,定位到该子串对应的 `tr[i][j]` 为何值,再从哈希表中获取建议字符串在 `ps` 中的左右端点 `l` 和 `r`**,并根据在 `ps[l:r]` (可能为空集)中最多取三个的原则来构建答案。
考虑实现字典树的两个关键方法,**添加** 和 **查询**:
* 添加函数 `void add(String s, int num)` :其中 `s` 为待添加到字典树的字符串,`num` 则是该字符串在 `ps` 中的下标编号。
往字典树添加过程中,按照首次访问字典树节点 `tr[i][j]` 的下标存入 `minMap`,最后一次访问字典树节点 `tr[i][j]` 的下标存入 `maxMap` 的规则来更新哈希表。
* 查询函数 `int[] query(String s)`:其中 `s` 为某个 `w` 子串,通过查询该子串(最后字符)在字典树的节点值,来得知建议列表对应 `ps` 的左右端点下标为何值,从而构建答案。
Java 代码:
```Java
class Solution {
int[][] tr = new int[20010][26];
int idx = 0;
Map<Integer, Integer> min = new HashMap<>(), max = new HashMap<>();
void add(String s, int num) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) {
tr[p][u] = ++idx;
min.put(tr[p][u], num);
}
max.put(tr[p][u], num);
p = tr[p][u];
}
}
int[] query(String s) {
int a = -1, b = -1, p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) return new int[]{-1, -1};
a = min.get(tr[p][u]); b = max.get(tr[p][u]);
p = tr[p][u];
}
return new int[]{a, b};
}
public List<List<String>> suggestedProducts(String[] ps, String w) {
Arrays.sort(ps);
List<List<String>> ans = new ArrayList<>();
for (int i = 0; i < ps.length; i++) add(ps[i], i);
for (int i = 0; i < w.length(); i++) {
List<String> list = new ArrayList<>();
int[] info = query(w.substring(0, i + 1));
int l = info[0], r = info[1];
for (int j = l; j <= Math.min(l + 2, r) && l != -1; j++) list.add(ps[j]);
ans.add(list);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int tr[20010][26] = {0};
int idx = 0;
unordered_map<int, int> minMap, maxMap;
void add(string s, int num) {
int p = 0;
for (char c : s) {
int u = c - 'a';
if (tr[p][u] == 0) {
tr[p][u] = ++idx;
minMap[tr[p][u]] = num;
}
maxMap[tr[p][u]] = num;
p = tr[p][u];
}
}
pair<int, int> query(string s) {
int a = -1, b = -1, p = 0;
for (char c : s) {
int u = c - 'a';
if (tr[p][u] == 0) return {-1, -1};
a = minMap[tr[p][u]];
b = maxMap[tr[p][u]];
p = tr[p][u];
}
return {a, b};
}
vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {
sort(ps.begin(), ps.end());
vector<vector<string>> ans;
for (int i = 0; i < ps.size(); i++) add(ps[i], i);
for (int i = 0; i < w.length(); i++) {
vector<string> list;
pair<int, int> info = query(w.substr(0, i + 1));
int l = info.first, r = info.second;
for (int j = l; j <= min(l + 2, r) && l != -1; j++) list.push_back(ps[j]);
ans.push_back(list);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:
tr = defaultdict(lambda: defaultdict(int))
idx = 0
minMap, maxMap = {}, {}
def add(s, num):
nonlocal idx
p = 0
for c in s:
u = ord(c) - ord('a')
if tr[p][u] == 0:
idx += 1
tr[p][u] = idx
minMap[tr[p][u]] = num
maxMap[tr[p][u]] = num
p = tr[p][u]
def query(s):
a, b, p = -1, -1, 0
for c in s:
u = ord(c) - ord('a')
if tr[p][u] == 0:
return (-1, -1)
a = minMap[tr[p][u]]
b = maxMap[tr[p][u]]
p = tr[p][u]
return (a, b)
ps.sort()
ans = []
for i in range(len(ps)):
add(ps[i], i)
for i in range(len(w)):
l, r = query(w[:i + 1])
lst = [ps[j] for j in range(l, min(l + 3, r + 1)) if l != -1]
ans.append(lst)
return ans
```
TypeScript 代码:
```TypeScript
let tr: number[][];
let idx: number;
let minMap: Map<number, number>, maxMap: Map<number, number>;
function add(s: string, num: number): void {
let p = 0;
for (let i = 0; i < s.length; i++) {
const u = s.charCodeAt(i) - 'a'.charCodeAt(0);
if (tr[p][u] === 0) {
idx++;
tr[p][u] = idx;
minMap.set(tr[p][u], num);
}
maxMap.set(tr[p][u], num);
p = tr[p][u];
}
}
function query(s: string): number[] {
let a = -1, b = -1, p = 0;
for (let i = 0; i < s.length; i++) {
const u = s.charCodeAt(i) - 'a'.charCodeAt(0);
if (tr[p][u] === 0) return [-1, -1];
a = minMap.get(tr[p][u])!;
b = maxMap.get(tr[p][u])!;
p = tr[p][u];
}
return [a, b];
}
function suggestedProducts(ps: string[], w: string): string[][] {
tr = new Array(20010).fill(0).map(() => new Array(26).fill(0));
idx = 0;
minMap = new Map(), maxMap = new Map();
ps.sort();
const ans = [];
for (let i = 0; i < ps.length; i++) add(ps[i], i);
for (let i = 0; i < w.length; i++) {
const list = [];
const [l, r] = query(w.substring(0, i + 1));
for (let j = l; j <= Math.min(l + 2, r) && l !== -1; j++) list.push(ps[j]);
ans.push(list);
}
return ans;
};
```
* 时间复杂度:将 `ps` 长度记为 `n`,`w` 长度记为 `m`。对 `ps` 进行排序复杂度为 $O(n\log{n})$;构建字典树复杂度为 $O(\sum_{i = 0}^{n - 1}ps[i].length)$;根据 `w` 构建答案复杂度为 $O(m^2)$;整体复杂度为 $O(\sum_{i = 0}^{n - 1}ps[i].length + m^2)$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}ps[i].length \times C)$,其中 $C = 26$ 为字符集大小
---
### 排序 + 二分
由于每个 `w` 子串只会对应最多三个的建议字符串,同时又可以先通过排序来确保 `ps` 的有序性。
因此对于每个 `w` 子串而言,可以 **先找到满足要求的,字典序最小的建议字符串 `ps[i]`,接着往后逐个检查,组成最终的建议字符串列表(最多检查三个)**。
这个「在 `ps` 中找符合要求,字典序最小的建议字符串」操作,除了能够利用上述解法来做(省掉一个 `maxMap`)以外,还能利用字符串本身的有序性进行「二分」,因为该操作本质上,是在**找第一个满足 `ps[i]` 大于等于当前子串的位置**。
Java 代码:
```Java
class Solution {
public List<List<String>> suggestedProducts(String[] ps, String w) {
Arrays.sort(ps);
int n = ps.length;
List<List<String>> ans = new ArrayList<>();
for (int i = 0; i < w.length(); i++) {
String cur = w.substring(0, i + 1);
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (ps[mid].compareTo(cur) >= 0) r = mid;
else l = mid + 1;
}
List<String> list = new ArrayList<>();
if (ps[r].compareTo(cur) >= 0) {
for (int j = r; j <= Math.min(n - 1, r + 2); j++) {
if (ps[j].length() < cur.length()) break;
if (!ps[j].substring(0, i + 1).equals(cur)) break;
list.add(ps[j]);
}
}
ans.add(list);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {
sort(ps.begin(), ps.end());
int n = ps.size();
vector<vector<string>> ans;
for (int i = 0; i < w.length(); i++) {
string cur = w.substr(0, i + 1);
int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) >> 1;
if (ps[mid].compare(cur) >= 0) r = mid;
else l = mid + 1;
}
vector<string> list;
if (ps[r].compare(cur) >= 0) {
for (int j = r; j <= min(n - 1, r + 2); j++) {
if (ps[j].length() < cur.length()) break;
if (ps[j].substr(0, i + 1) != cur) break;
list.push_back(ps[j]);
}
}
ans.push_back(list);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:
ps.sort()
n = len(ps)
ans = []
for i in range(len(w)):
cur = w[:i + 1]
l, r = 0, n - 1
while l < r:
mid = (l + r) // 2
if ps[mid] >= cur:
r = mid
else:
l = mid + 1
lst = []
if ps[r] >= cur:
for j in range(r, min(n - 1, r + 2) + 1):
if len(ps[j]) < len(cur) or ps[j][:i + 1] != cur:
break
lst.append(ps[j])
ans.append(lst)
return ans
```
TypeScript 代码:
```TypeScript
function suggestedProducts(ps: string[], w: string): string[][] {
ps.sort();
const n = ps.length;
const ans = [];
for (let i = 0; i < w.length; i++) {
const cur = w.substring(0, i + 1);
let l = 0, r = n - 1;
while (l < r) {
const mid = (l + r) >> 1;
if (ps[mid].localeCompare(cur) >= 0) r = mid;
else l = mid + 1;
}
const list: string[] = [];
if (ps[r].localeCompare(cur) >= 0) {
for (let j = r; j <= Math.min(n - 1, r + 2); j++) {
if (ps[j].length < cur.length || !ps[j].startsWith(cur)) break;
list.push(ps[j]);
}
}
ans.push(list);
}
return ans;
};
```
* 时间复杂度:将 `ps` 长度记为 `n`,`w` 长度记为 `m`。对 `ps` 进行排序复杂度为 $O(n\log{n})$;每次二分需要进行字符串比较,复杂度为 $O(m\log{n})$;二分到左端点后需要往后检查最多三个字符串,复杂度为 $O(m)$。整体复杂度为 $O(n\log{n} + m\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1261-1270/1269. 停在原地的方案数（困难）.md | 1269. 停在原地的方案数 | https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps/solution/gong-shui-san-xie-xiang-jie-xian-xing-dp-m9q9/ | 困难 | [
"线性 DP"
] | 有一个长度为 arrLen 的数组,开始有一个指针在索引 0 处。
每一步操作中,你可以将指针向左或向右移动 1 步,或者停在原地(指针不能被移动到数组范围外)。
给你两个整数 steps 和 arrLen ,请你计算并返回:在恰好执行 steps 次操作以后,指针仍然指向索引 0 处的方案数。
由于答案可能会很大,请返回方案数 模 $10^9$ + 7 后的结果。
示例 1:
```
输入:steps = 3, arrLen = 2
输出:4
解释:3 步后,总共有 4 种不同的方法可以停在索引 0 处。
向右,向左,不动
不动,向右,向左
向右,不动,向左
不动,不动,不动
```
示例 2:
```
输入:steps = 2, arrLen = 4
输出:2
解释:2 步后,总共有 2 种不同的方法可以停在索引 0 处。
向右,向左
不动,不动
```
示例 3:
```
输入:steps = 4, arrLen = 2
输出:8
```
提示:
* 1 <= steps <= 500
* 1 <= arrLen <= $10^6$ | ### 动态规划
这道题的可变维度分析不算复杂,因此这次就不从 `DFS` 开始给大家分析了。
**定义 $f[i][j]$ 代表当前剩余操作数为 $i$,所在位置为 $j$ 的所有方案数。**
起始位置为 $0$,操作次数为 $step$,即有初始化条件 $f[step][0] = 1$,$f[0][0]$ 则是我们的最终答案。
不失一般性的考虑 $f[i][j]$ 可以由哪些状态转移而来:
* 由「原地」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j]$ 转移而来
* 由「向左」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j + 1]$ 转移而来
* 由「向右」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j - 1]$ 转移而来
求的是方案数,即最终的 $f[i][j]$ 为三者累加值。
同时我们发现 $f[i][x]$ 依赖于 $f[i + 1][y]$,因此我们需要按照「$step$ 从大到小」的顺序进行转移。
同时我们根据「最终回到下标 $0$ 位置」可以推断出,最远到达的位置为 $step / 2$(再远就回不来了)。将最远到达位置与数组最大下标取 $min$ 即可确定维度 $step$ 的范围。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numWays(int steps, int len) {
int max = Math.min(steps / 2, len - 1);
int[][] f = new int[steps + 1][max + 1];
f[steps][0] = 1;
for (int i = steps - 1; i >= 0; i--) {
for (int j = 0; j <= max; j++) {
f[i][j] = (f[i][j] + f[i + 1][j]) % mod;
if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;
if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;
}
}
return f[0][0];
}
}
```
* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$
* 空间复杂度:$O(step * max)$
---
### 优化
**1. 对时间复杂度进行「常数级别的优化」**
$f[0][0]$ 并不依赖于操作次数同为 $0$ 的其他位置的状态,而只依赖于操作次数为 $1$ 的特定位置的状态。同理其他状态也是。
因此我们会发现**随着「可操作次数」的减少,「可达到的最远位置」下标也会逐步缩小。从目标状态 $f[0][0]$ 进行倒推的话,会发现「可达到的最远位置」等于「可操作次数」。**
**所以其实可以从两者取一个 $min$ 就能够有效减少「无效状态」的计算。数据量越大,这个性质带来的剪枝效果越好。**
*PS. 为了方便你看到优化前后的差别,我增加了打印注释,使用测试数据 (500, 100000) 并打开注释,可以看到少计算了多少「无效状态」。*
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numWays(int steps, int len) {
int max = Math.min(steps / 2, len - 1);
int[][] f = new int[steps + 1][max + 1];
f[steps][0] = 1;
for (int i = steps - 1; i >= 0; i--) {
int edge = Math.min(i, max);
// if (edge != max) System.out.println(edge + " " + max);
for (int j = 0; j <= edge; j++) {
f[i][j] = (f[i][j] + f[i + 1][j]) % mod;
if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;
if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;
}
}
return f[0][0];
}
}
```
* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$
* 空间复杂度:$O(step * max)$
**2. 对空间复杂度进行「维度级别的优化」**
这个优化思维难度就要低很多了,利用 $f[i][x]$ 依赖于 $f[i + 1][y]$,使用「滚动数组」方式进行优化即可。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numWays(int steps, int len) {
int max = Math.min(steps / 2, len - 1);
int[][] f = new int[2][max + 1];
f[steps&1][0] = 1;
for (int i = steps - 1; i >= 0; i--) {
int edge = Math.min(i, max);
int a = i & 1, b = (i + 1) & 1;
for (int j = 0; j <= edge; j++) {
f[a][j] = 0;
f[a][j] = (f[a][j] + f[b][j]) % mod;
if (j - 1 >= 0) f[a][j] = (f[a][j] + f[b][j - 1]) % mod;
if (j + 1 <= max) f[a][j] = (f[a][j] + f[b][j + 1]) % mod;
}
}
return f[0][0];
}
}
```
* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$
* 空间复杂度:$O(max)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1269` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1281-1290/1282. 用户分组（中等）.md | 1282. 用户分组 | https://leetcode.cn/problems/group-the-people-given-the-group-size-they-belong-to/solution/by-ac_oier-z1bg/ | 中等 | [
"哈希表",
"模拟"
] | 有 `n` 个人被分成数量未知的组。每个人都被标记为一个从 $0$ 到 $n - 1$ 的唯一`ID` 。
给定一个整数数组 `groupSizes`,其中 `groupSizes[i]` 是第 $i$ 个人所在的组的大小。例如,如果 `groupSizes[1] = 3`,则第 $1$ 个人必须位于大小为 $3$ 的组中。
返回一个组列表,使每个人 $i$ 都在一个大小为 `groupSizes[i]` 的组中。
每个人应该恰好只出现在 一个组中,并且每个人必须在一个组中。如果有多个答案,返回其中任何一个。可以保证给定输入至少有一个有效的解。
示例 1:
```
输入:groupSizes = [3,3,3,3,3,1,3]
输出:[[5],[0,1,2],[3,4,6]]
解释:
第一组是 [5],大小为 1,groupSizes[5] = 1。
第二组是 [0,1,2],大小为 3,groupSizes[0] = groupSizes[1] = groupSizes[2] = 3。
第三组是 [3,4,6],大小为 3,groupSizes[3] = groupSizes[4] = groupSizes[6] = 3。
其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。
```
示例 2:
```
输入:groupSizes = [2,1,3,3,3,2]
输出:[[1],[0,5],[2,3,4]]
```
提示:
* $groupSizes.length == n$
* $1 <= n <= 500$
* $1 <= groupSizes[i] <= n$ | ### 哈希表 + 模拟
我们可以使用「哈希表」将所属组大小相同的下标放到一起。假设组大小为 $k$ 的元素有 $m$ 个,然后我们再将这 $m$ 个元素按照 $k$ 个一组进行划分即可。
Java 代码:
```Java
class Solution {
public List<List<Integer>> groupThePeople(int[] gs) {
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < gs.length; i++) {
List<Integer> list = map.getOrDefault(gs[i], new ArrayList<>());
list.add(i);
map.put(gs[i], list);
}
List<List<Integer>> ans = new ArrayList<>();
for (int k : map.keySet()) {
List<Integer> list = map.get(k), cur = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
cur.add(list.get(i));
if (cur.size() == k) {
ans.add(cur);
cur = new ArrayList<>();
}
}
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function groupThePeople(gs: number[]): number[][] {
const map = new Map<number, Array<number>>()
for (let i = 0; i < gs.length; i++) {
if (!map.has(gs[i])) map.set(gs[i], new Array<number>())
map.get(gs[i]).push(i)
}
const ans = new Array<Array<number>>()
for (let k of map.keys()) {
let list = map.get(k), cur = new Array<number>()
for (let i = 0; i < list.length; i++) {
cur.push(list[i])
if (cur.length == k) {
ans.push(cur)
cur = new Array<number>()
}
}
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1302. 层数最深叶子节点的和（中等）.md | 1302. 层数最深叶子节点的和 | https://leetcode.cn/problems/deepest-leaves-sum/solution/by-ac_oier-srst/ | 中等 | [
"DFS",
"BFS",
"树的遍历"
] | 给你一棵二叉树的根节点 `root`,请你返回 层数最深的叶子节点的和 。
示例 1:
```
输入:root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
输出:15
```
示例 2:
```
输入:root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
输出:19
```
提示:
* 树中节点数目在范围 $[1, 10^4]$ 之间。
* $1 <= Node.val <= 100$ | ### BFS
使用 `BFS` 进行树的遍历,处理过程中记录最大深度 `depth` 以及使用哈希表记录每层元素和。
Java 代码:
```Java
class Solution {
public int deepestLeavesSum(TreeNode root) {
Map<Integer, Integer> map = new HashMap<>();
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
int depth = 0;
while (!d.isEmpty()) {
int sz = d.size();
while (sz-- > 0) {
TreeNode node = d.pollFirst();
map.put(depth, map.getOrDefault(depth, 0) + node.val);
if (node.left != null) d.addLast(node.left);
if (node.right != null) d.addLast(node.right);
}
depth++;
}
return map.get(depth - 1);
}
}
```
TypeScript 代码:
```TypeScript
function deepestLeavesSum(root: TreeNode | null): number {
const map: Map<number, number> = new Map<number, number>()
const stk: TreeNode[] = new Array<TreeNode>(10010)
let he = 0, ta = 0, depth = 0
stk[ta++] = root
while (he < ta) {
let sz = ta - he
while (sz-- > 0) {
const node = stk[he++]
if (!map.has(depth)) map.set(depth, 0)
map.set(depth, map.get(depth) + node.val)
if (node.left != null) stk[ta++] = node.left
if (node.right != null) stk[ta++] = node.right
}
depth++
}
return map.get(depth - 1)
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### DFS
使用 `DFS` 进行树的遍历,处理过程中记录最大深度 `depth` 以及使用哈希表记录每层元素和。
Java 代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
int max;
public int deepestLeavesSum(TreeNode root) {
dfs(root, 0);
return map.get(max);
}
void dfs(TreeNode root, int depth) {
if (root == null) return ;
max = Math.max(max, depth);
map.put(depth, map.getOrDefault(depth, 0) + root.val);
dfs(root.left, depth + 1);
dfs(root.right, depth + 1);
}
}
```
TypeScript 代码:
```TypeScript
const map: Map<number, number> = new Map<number, number>()
let max: number
function deepestLeavesSum(root: TreeNode | null): number {
map.clear()
max = 0
dfs(root, 0)
return map.get(max)
};
function dfs(root: TreeNode | null, depth: number): void {
if (root == null) return
max = Math.max(max, depth)
if (!map.has(depth)) map.set(depth, 0)
map.set(depth, map.get(depth) + root.val)
dfs(root.left, depth + 1)
dfs(root.right, depth + 1)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1302` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1305. 两棵二叉搜索树中的所有元素（中等）.md | 1305. 两棵二叉搜索树中的所有元素 | https://leetcode-cn.com/problems/all-elements-in-two-binary-search-trees/solution/by-ac_oier-c8fv/ | 中等 | [
"中序遍历",
"归并排序"
] | 给你 `root1` 和` root2` 这两棵二叉搜索树。请你返回一个列表,其中包含 两棵树 中的所有整数并按 升序 排序。.
示例 1:
```
输入:root1 = [2,1,4], root2 = [1,0,3]
输出:[0,1,1,2,3,4]
```
示例 2:
```
输入:root1 = [1,null,8], root2 = [8,1]
输出:[1,1,8,8]
```
提示:
* 每棵树的节点数在 $[0, 5000]$ 范围内
* $-10^5 <= Node.val <= 10^5$ | ### 中序遍历 + 归并排序
利用 `BST` 中序遍历的有序性质,我们可以先对两棵树进行中序遍历,从而将树的结构转换为线性结构。
将两个有序序列合并成一个有序序列则是利用了经典的「归并排序」。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
List<Integer> ans = new ArrayList<>();
List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();
dfs(root1, l1); dfs(root2, l2);
int n = l1.size(), m = l2.size(), i = 0, j = 0;
while (i < n || j < m) {
int a = i < n ? l1.get(i) : INF, b = j < m ? l2.get(j) : INF;
if (a <= b) {
ans.add(a); i++;
} else {
ans.add(b); j++;
}
}
return ans;
}
void dfs(TreeNode root, List<Integer> list) {
if (root == null) return ;
dfs(root.left, list);
list.add(root.val);
dfs(root.right, list);
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为两棵树的节点数量,跑中序遍历的复杂度为 $O(n + m)$,构建答案复杂度为 $O(\max(m, n))$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1310. 子数组异或查询（中等）.md | 1310. 子数组异或查询 | https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/ | 中等 | [
"数学",
"树状数组",
"前缀和"
] | 有一个正整数数组 arr,现给你一个对应的查询数组 queries,其中 queries[i] = [Li, Ri]。
对于每个查询 i,请你计算从 Li 到 Ri 的 XOR 值(即 arr[Li] xor arr[Li+1] xor ... xor arr[Ri])作为本次查询的结果。
并返回一个包含给定查询 queries 所有结果的数组。
示例 1:
```
输入:arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
输出:[2,7,14,8]
解释:
数组中元素的二进制表示形式是:
1 = 0001
3 = 0011
4 = 0100
8 = 1000
查询的 XOR 值为:
[0,1] = 1 xor 3 = 2
[1,2] = 3 xor 4 = 7
[0,3] = 1 xor 3 xor 4 xor 8 = 14
[3,3] = 8
```
示例 2:
```
输入:arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]
输出:[8,0,4,4]
```
提示:
* 1 <= arr.length <= 3 * $10^4$
* 1 <= arr[i] <= $10^9$
* 1 <= queries.length <= 3 * $10^4$
* queries[i].length == 2
* 0 <= queries[i][0] <= queries[i][1] < arr.length | ### 基本分析
令数组 `arr` 和数组 `queries` 的长度分别为 `n` 和 `m`。
`n` 和 `m` 的数据范围均为 $10^4$,因此 $O(m * n)$ 的暴力做法我们不用考虑了。
数据范围要求我们做到「对数复杂度」或「线性复杂度」。
**本题主要利用异或运算中的「相同数值进行运算结果为 $0$」的特性。**
对于特定数组 $[a1, a2, a3, ... , an]$,要求得任意区间 $[l, r]$ 的异或结果,可以通过 $[1, r]$ 和 $[1, l - 1]$ 的异或结果得出:
$$
xor(l, r) = xor(1, r) ⊕ xor(1, l - 1)
$$
**本质上还是利用集合(区间结果)的容斥原理。只不过前缀和需要利用「减法(逆运算)」做容斥,而前缀异或是利用「相同数值进行异或结果为 $0$(偶数次的异或结果为 $0$)」的特性实现容斥。**
对于「区间求值」问题,之前在 [【题解】307. 区域和检索 - 数组可修改](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 也做过总结。
针对不同的题目,有不同的方案可以选择(假设有一个数组):
1. 数组不变,求区间和:「前缀和」、「树状数组」、「线段树」
2. 多次修改某个数,求区间和:「树状数组」、「线段树」
3. 多次整体修改某个区间,求区间和:「线段树」、「树状数组」(看修改区间的数据范围)
4. 多次将某个区间变成同一个数,求区间和:「线段树」、「树状数组」(看修改区间的数据范围)
虽然「线段树」能解决的问题最多,但「线段树」代码很长,且常数很大,实际表现不算好。我们只有在不得不用的情况下才考虑「线段树」。
本题我们使用「树状数组」和「前缀和」来求解。
---
### 树状数组
使用「树状数组」分段记录我们某些区间的「异或结果」,再根据 `queries` 中的询问将分段「异或结果」汇总(执行异或运算),得出最终答案。
代码:
```Java
class Solution {
int n;
int[] c = new int[100009];
int lowbit(int x) {
return x & -x;
}
void add(int x, int u) {
for (int i = x; i <= n; i += lowbit(i)) c[i] ^= u;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans ^= c[i];
return ans;
}
public int[] xorQueries(int[] arr, int[][] qs) {
n = arr.length;
int m = qs.length;
for (int i = 1; i <= n; i++) add(i, arr[i - 1]);
int[] ans = new int[m];
for (int i = 0; i < m; i++) {
int l = qs[i][0] + 1, r = qs[i][1] + 1;
ans[i] = query(r) ^ query(l - 1);
}
return ans;
}
}
```
* 时间复杂度:令 `arr` 数组长度为 `n`,`qs` 数组的长度为 `m`。创建树状数组复杂度为 $O(n\log{n})$;查询的复杂度为 $O(m\log{n})$。整体复杂度为 $O((n + m) \log{n})$
* 空间复杂度:$O(n)$
---
### 前缀异或
「树状数组」的查询复杂度为 $O(\log{n})$,而本题其实不涉及「修改操作」,我们可以使用「前缀异或」来代替「树状数组」。
虽说「树状数组」也有 $O(n)$ 的创建方式,但这里使用「前缀异或」主要是为了降低查询的复杂度。
代码:
```Java
class Solution {
public int[] xorQueries(int[] arr, int[][] qs) {
int n = arr.length, m = qs.length;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];
int[] ans = new int[m];
for (int i = 0; i < m; i++) {
int l = qs[i][0] + 1, r = qs[i][1] + 1;
ans[i] = sum[r] ^ sum[l - 1];
}
return ans;
}
}
```
* 时间复杂度:令 `arr` 数组长度为 `n`,`qs` 数组的长度为 `m`。预处理前缀和数组复杂度为 $O(n)$;查询的复杂度为 $O(m)$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/131. 分割回文串（中等）.md | 131. 分割回文串 | https://leetcode-cn.com/problems/palindrome-partitioning/solution/wei-sha-yao-zhe-yang-bao-sou-ya-shi-ru-h-41gf/ | 中等 | [
"回文串",
"回溯算法",
"动态规划"
] | 给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文串。
返回 `s` 所有可能的分割方案。
回文串是正着读和反着读都一样的字符串。
示例 1:
```
输入:s = "aab"
输出:[["a","a","b"],["aa","b"]]
```
示例 2:
```
输入:s = "a"
输出:[["a"]]
```
提示:
* $1 <= s.length <= 16$
* `s` 仅由小写英文字母组成 | ### 动态规划 + 回溯算法
求所有的分割方案,凡是求所有方案的题基本上都没有什么优化方案,就是「爆搜」。
问题在于,爆搜什么?显然我们可以爆搜每个回文串的起点。如果有连续的一段是回文串,我们再对剩下连续的一段继续爆搜。
为什么能够直接接着剩下一段继续爆搜?
因为任意的子串最终必然能够分割成若干的回文串(最坏的情况下,每个回文串都是一个字母)。
所以我们每次往下爆搜时,只需要保证自身连续一段是回文串即可。
举个🌰 来感受下我们的爆搜过程,假设有样例 `abababa`,刚开始我们从起点第一个 a 进行爆搜:
1. 发现 `a` 是回文串,先将 `a` 分割出来,再对剩下的 `bababa` 进行爆搜
2. 发现 `aba` 是回文串,先将 `aba` 分割出来,再对剩下的 `baba` 进行爆搜
3. 发现 `ababa` 是回文串,先将 `ababa` 分割出来,再对剩下的 `ba` 进行爆搜
4. 发现 `abababa` 是回文串,先将 `abababa` 分割出来,再对剩下的 `` 进行爆搜
...
然后再对下一个起点(下个字符) `b` 进行爆搜?
不需要。
因为单个字符本身构成了回文串,所以以 `b` 为起点,`b` 之前构成回文串的方案,必然覆盖在我们以第一个字符为起点所展开的爆搜方案内(在这里就是对应了上述的第一步所展开的爆搜方案中)。
**因此我们只需要以首个字符为起点,枚举以其开头所有的回文串方案,加入集合,然后对剩下的字符串部分继续爆搜。就能做到以任意字符作为回文串起点进行分割的效果了。**
一定要好好理解上面那句话 ~
剩下的问题是,我们如何快速判断连续一段 `[i, j]` 是否为回文串,因为爆搜的过程每个位置都可以作为分割点,复杂度为 $O(2^n)$ 的。
因此我们不可能每次都使用双指针去线性扫描一遍 `[i, j]` 判断是否回文。
一个直观的做法是,我们先预处理除所有的 `f[i][j]`,`f[i][j]` 代表 `[i, j]` 这一段是否为回文串。
预处理 `f[i][j]` 的过程可以用递推去做。
要想 `f[i][j] == true` ,必须满足以下两个条件:
1. `f[i + 1][j - 1] == true`
2. `s[i] == s[j]`
由于状态 `f[i][j]` 依赖于状态 `f[i + 1][j - 1]`,因此需要我们左端点 `i` 是**从大到小**进行遍历;而右端点 `j` 是**从小到大**进行遍历。
因此,我们的遍历过程可以整理为:**右端点 `j` 一直往右移动(从小到大),在 `j` 固定情况下,左端点 `i` 在 `j` 在左边开始,一直往左移动(从大到小)**
Java 代码:
```Java
class Solution {
public List<List<String>> partition(String s) {
int n = s.length();
char[] cs = s.toCharArray();
// f[i][j] 代表 [i, j] 这一段是否为回文串
boolean[][] f = new boolean[n][n];
for (int j = 0; j < n; j++) {
for (int i = j; i >= 0; i--) {
// 当 [i, j] 只有一个字符时,必然是回文串
if (i == j) {
f[i][j] = true;
} else {
// 当 [i, j] 长度为 2 时,满足 cs[i] == cs[j] 即回文串
if (j - i + 1 == 2) {
f[i][j] = cs[i] == cs[j];
// 当 [i, j] 长度大于 2 时,满足 (cs[i] == cs[j] && f[i + 1][j - 1]) 即回文串
} else {
f[i][j] = cs[i] == cs[j] && f[i + 1][j - 1];
}
}
}
}
List<List<String>> ans = new ArrayList<>();
List<String> cur = new ArrayList<>();
dfs(s, 0, ans, cur, f);
return ans;
}
/**
* s: 要搜索的字符串
* u: 以 s 中的那一位作为回文串分割起点
* ans: 最终结果集
* cur: 当前结果集
* f: 快速判断 [i,j] 是否为回文串
*/
void dfs(String s, int u, List<List<String>> ans, List<String> cur, boolean[][] f) {
int n = s.length();
if (u == n) ans.add(new ArrayList<>(cur));
for (int i = u; i < n; i++) {
if (f[u][i]) {
cur.add(s.substring(u, i + 1));
dfs(s, i + 1, ans, cur, f);
cur.remove(cur.size() - 1);
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<string>> partition(string s) {
int n = s.length();
vector<vector<string>> ans;
vector<string> cur;
vector<vector<bool>> f(n, vector<bool>(n, false));
for (int j = 0; j < n; j++) {
for (int i = j; i >= 0; i--) {
if (i == j) {
f[i][j] = true;
} else if (j - i + 1 == 2) {
f[i][j] = s[i] == s[j];
} else {
f[i][j] = s[i] == s[j] && f[i + 1][j - 1];
}
}
}
dfs(s, 0, ans, cur, f);
return ans;
}
void dfs(string& s, int u, vector<vector<string>>& ans, vector<string>& cur, vector<vector<bool>>& f) {
int n = s.length();
if (u == n) ans.push_back(cur);
for (int i = u; i < n; i++) {
if (f[u][i]) {
cur.push_back(s.substr(u, i - u + 1));
dfs(s, i + 1, ans, cur, f);
cur.pop_back();
}
}
}
};
```
Python 代码:
```Python
class Solution:
def partition(self, s: str) -> List[List[str]]:
def dfs(s: str, u: int, ans: List[List[str]], cur: List[str], f: List[List[bool]]):
n = len(s)
if u == n:
ans.append(cur[:])
for i in range(u, n):
if f[u][i]:
cur.append(s[u:i + 1])
dfs(s, i + 1, ans, cur, f)
cur.pop()
n = len(s)
ans, cur = [], []
f = [[False] * n for _ in range(n)]
for j in range(n):
for i in range(j, -1, -1):
if i == j:
f[i][j] = True
elif j - i + 1 == 2:
f[i][j] = s[i] == s[j]
else:
f[i][j] = s[i] == s[j] and f[i + 1][j - 1]
dfs(s, 0, ans, cur, f)
return ans
```
TypeScript 代码:
```TypeScript
function partition(s: string): string[][] {
const dfs = function(s: string, u: number, ans: string[][], cur: string[], f: boolean[][]): void {
const n = s.length;
if (u == n) ans.push([...cur]);
for (let i = u; i < n; i++) {
if (f[u][i]) {
cur.push(s.substring(u, i + 1));
dfs(s, i + 1, ans, cur, f);
cur.pop();
}
}
};
const n = s.length;
const ans = [], cur = [];
const f = Array.from({ length: n }, () => Array(n).fill(false));
for (let j = 0; j < n; j++) {
for (let i = j; i >= 0; i--) {
if (i == j) {
f[i][j] = true;
} else if (j - i + 1 === 2) {
f[i][j] = s[i] == s[j];
} else {
f[i][j] = s[i] == s[j] && f[i + 1][j - 1];
}
}
}
dfs(s, 0, ans, cur, f);
return ans;
};
```
* 时间复杂度:动态规划预处理的复杂度为 $O(n^2)$;爆搜过程中每个字符都可以作为分割点,并且有分割与不分割两种选择,方案数量为 $2^{n - 1}$,每个字符都需要往后检查剩余字符的分割情况,复杂度为 $O(n)$。整体复杂度为 $O(n \times 2^n)$
* 空间复杂度:动态规划部分的复杂度为 $O(n^2)$;方案数量最多为 $2^{n - 1}$,每个方案都是完整字符串 `s` 的分割,复杂度为 $O(n)$,整体复杂度为 $O(n \times 2^n)$
---
### 总结
对于此类要枚举所有方案的题目,我们都应该先想到「回溯算法」。
「回溯算法」从算法定义上来说,不一定要用 DFS 实现,但通常结合 DFS 来做,难度是最低的。
「回溯算法」根据当前决策有多少种选择,对应了两套模板。
每一次独立的决策只对应 选择 和 不选 两种情况:
1. 确定结束回溯过程的 base case
2. 遍历每个位置,对每个位置进行决策(做选择 -> 递归 -> 撤销选择)
```java
void dfs(当前位置, 路径(当前结果), 结果集) {
if (当前位置 == 结束位置) {
结果集.add(路径);
return;
}
选择当前位置;
dfs(下一位置, 路径(当前结果), 结果集);
撤销选择当前位置;
dfs(下一位置, 路径(当前结果), 结果集);
}
```
每一次独立的决策都对应了多种选择(通常对应了每次决策能选择什么,或者每次决策能选择多少个 ...):
1. 确定结束回溯过程的 base case
2. 遍历所有的「选择」
3. 对选择进行决策 (做选择 -> 递归 -> 撤销选择)
```java
void dfs(选择列表, 路径(当前结果), 结果集) {
if (满足结束条件) {
结果集.add(路径);
return;
}
for (选择 in 选择列表) {
做选择;
dfs(路径’, 选择列表, 结果集);
撤销选择;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.131` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/132. 分割回文串 II（困难）.md | 132. 分割回文串 II | https://leetcode-cn.com/problems/palindrome-partitioning-ii/solution/xiang-jie-liang-bian-dong-tai-gui-hua-ji-s5xr/ | 困难 | [
"回文串",
"线性 DP"
] | 给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文。
返回符合要求的 最少分割次数 。
示例 1:
```
输入:s = "aab"
输出:1
解释:只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
```
示例 2:
```
输入:s = "a"
输出:0
```
示例 3:
```
输入:s = "ab"
输出:1
```
提示:
* $1 <= s.length <= 2000$
* `s` 仅由小写英文字母组成 | ### 动态规划
如果在 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd) 你有使用到 DP 进行预处理的话。
这道题就很简单了,就是一道常规的动态规划题。
为了方便,我们约定所有下标从 $1$ 开始。
即对于长度为 $n$ 的字符串,我们使用 $[1,n]$ 进行表示。估计不少看过三叶题解的同学都知道,这样做的目的是为了减少边界情况判断,这本身也是对于「哨兵」思想的运用。
* **递推「最小分割次数」思路**
我们定义 $f[r]$ 为将 $[1,r]$ 这一段字符分割为若干回文串的最小分割次数,那么最终答案为 $f[n]$。
不失一般性的考虑 $f[r]$ 如何转移:
1. 从「起点字符」到「第 $r$ 个字符」能形成回文串。那么最小分割次数为 0,此时有 $f[r] = 0$
2. 从「起点字符」到「第 $r$ 个字符」不能形成回文串。此时我们需要枚举左端点 $l$,如果 $[l,r]$ 这一段是回文串的话,那么有 $f[r] = f[l - 1] + 1$
在 $2$ 中满足回文要求的左端点位置 $l$ 可能有很多个,我们在所有方案中取一个 $\min$ 即可。
* **快速判断「任意一段子串是否回文」思路**
剩下的问题是,我们如何快速判断连续一段 $[l, r]$ 是否为回文串,做法和昨天的 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd) 一模一样。
*PS. 在 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd),数据范围只有 $16$,因此我们可以不使用 DP 进行预处理,而是使用双指针来判断是否回文也能过。但是该题数据范围为 $2000$(数量级为 $10^3$),使用朴素做法判断是否回文的话,复杂度会去到 $O(n^3)$(计算量为 $10^9$),必然超时。*
因此我们不可能每次都使用双指针去线性扫描一遍 $[l, r]$ 判断是否回文。
一个合理的做法是,我们先预处理出所有的 $g[l][r]$,$g[l][r]$ 代表 $[l,r]$ 这一段是否为回文串。
预处理 $g[l][r]$ 的过程可以用递推去做。
要想 $g[l][r] = true$ ,必须满足以下两个条件:
1. $g[l + 1][r - 1] = true$
2. $s[i] = s[j]$
由于状态 $f[l][r]$ 依赖于状态 $f[l + 1][r - 1]$,因此需要我们左端点 $l$ 是「从大到小」进行遍历;而右端点 $r$ 是「从小到大」进行遍历。
因此最终的遍历过程可以整理为:**右端点 $r$ 一直往右移动(从小到大),在 $r$ 固定情况下,左端点 $l$ 在 $r$ 在左边开始,一直往左移动(从大到小)**
代码:
```Java
class Solution {
public int minCut(String s) {
int n = s.length();
char[] cs = s.toCharArray();
// g[l][r] 代表 [l,r] 这一段是否为回文串
boolean[][] g = new boolean[n + 1][n + 1];
for (int r = 1; r <= n; r++) {
for (int l = r; l >= 1; l--) {
// 如果只有一个字符,则[l,r]属于回文
if (l == r) {
g[l][r] = true;
} else {
// 在 l 和 r 字符相同的前提下
if (cs[l - 1] == cs[r - 1]) {
// 如果 l 和 r 长度只有 2;或者 [l+1,r-1] 这一段满足回文,则[l,r]属于回文
if (r - l == 1 || g[l + 1][r - 1]) {
g[l][r] = true;
}
}
}
}
}
// f[r] 代表将 [1,r] 这一段分割成若干回文子串所需要的最小分割次数
int[] f = new int[n + 1];
for (int r = 1; r <= n; r++) {
// 如果 [1,r] 满足回文,不需要分割
if (g[1][r]) {
f[r] = 0;
} else {
// 先设定一个最大分割次数(r 个字符最多消耗 r - 1 次分割)
f[r] = r - 1;
// 在所有符合 [l,r] 回文的方案中取最小值
for (int l = 1; l <= r; l++) {
if (g[l][r]) f[r] = Math.min(f[r], f[l - 1] + 1);
}
}
}
return f[n];
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 关于「如何确定 DP 状态定义」的分享
有同学会对「如何确定 DP 的状态定义」有疑问,觉得自己总是定不下 DP 的状态定义。
首先,十分正常,不用担心。
DP 的状态定义,基本上是考经验的(猜的),猜对了 DP 的状态定义,基本上「状态转移方程」就是呼之欲出。
虽然大多数情况都是猜的,但也不是毫无规律,相当一部分是定义是与「结尾」和「答案」有所关联的。
**例如本题定义 $f[i]$ 为以下标为 $i$ 的字符作为结尾(结尾)的最小分割次数(答案)。**
因此对于那些你没见过的 DP 模型题,可以从这两方面去「猜」。
---
### Manacher 算法(非重要补充)
如果你还学有余力的话,可以看看下面这篇题解。
提供了「回文串」问题的究极答案:Manacher 算法。
由于 Manacher 算法较为局限,只能解决「回文串」问题,远不如 KMP 算法使用广泛,**不建议大家深究原理,而是直接当做「模板」背过。**
背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个字符串,返回该字符串的最大回文子串。
[回文串问题的究极答案:Manacher 算法](https://leetcode-cn.com/problems/longest-palindromic-substring/solution/shua-chuan-lc-po-su-jie-fa-manacher-suan-i2px/)
**如果觉得自己背不下来,也没有问题。事实上我还没有见过必须使用 Manacher 算法才能过的回文串题。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.132` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/134. 加油站（中等）.md | 134. 加油站 | https://leetcode-cn.com/problems/gas-station/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-zsgqp/ | 中等 | [
"DFA",
"KMP"
] | 在一条环路上有 `N` 个加油站,其中第 `i` 个加油站有汽油 `gas[i]` 升。
你有一辆油箱容量无限的的汽车,从第 `i` 个加油站开往第 `i+1` 个加油站需要消耗汽油 `cost[i]` 升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 `-1`。
说明:
* 如果题目有解,该答案即为唯一答案。
* 输入数组均为非空数组,且长度相同。
* 输入数组中的元素均为非负数。
示例 1:
```
输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发,可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站,此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站,此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站,此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站,此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站,你需要消耗 5 升汽油,正好足够你返回到 3 号加油站。
因此,3 可为起始索引。
```
示例 2:
```
输入:
gas = [2,3,4]
cost = [3,4,3]
输出: -1
解释:
你不能从 0 号或 1 号加油站出发,因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发,可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站,此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站,此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站,因为返程需要消耗 4 升汽油,但是你的油箱只有 3 升汽油。
因此,无论怎样,你都不可能绕环路行驶一周。
``` | ### 基本分析/朴素解法
这是一道比较经典的题目。
估计在 LeetCode 也是有一段时间了,所以连数据范围都没有。
我这里直接规定一下数据范围为 $10^5$,这意味着我们不能使用 $O(n^2)$ 做法了。
但朴素做法往往是优化的出发点,所以我们还是先分析一下,朴素的做法是怎么样的:
* 题目要求「合法起点」的下标,因此我们可以枚举所有的「起点」
* 然后按照「油量 & 成本」模拟一遍,看是否能走完一圈
共有 $n$ 个「起点」,检查某个「起点」合法性的复杂度是 $O(n)$ 的。因此整体复杂度为 $O(n^2)$ 的。
代码:
```java
class Solution {
public int canCompleteCircuit(int[] gas, int[] cost) {
int n = gas.length;
for (int start = 0; start < n; start++) {
// 直接跳过第一步都不满足的起点
if (gas[start] < cost[start]) continue;
// 剩余油量
int cur = gas[start] - cost[start];
// 所在位置
int idx = (start + 1) % n;
while (idx != start) {
cur += gas[idx] - cost[idx];
// 如果剩余油量为负数,说明无法离开当前位置,走到下一位置
if (cur < 0) break;
idx = (idx + 1) % n;
}
if (idx == start) return start;
}
return -1;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$
PS. 在 LeetCode 上提交了一下,是可以过的 🤣
---
### KMP
不考虑我们跳过那些第一步就不满足的起点的话,将上述解法中的两个主要逻辑“单独”拎出来看,都是无法优化的:
* 在没做任何操作之前,我们无法知道哪些起点是不合法的
* 没有比 $O(n)$ 更低的复杂度可以验证一个起点的合法性
因此只能使用 $O(n^2)$ 解法?
并不是。单独看无法优化,合在一起则可以:**随着某个起点「合法性验证」失败,我们可以否决掉一些「必然不合法」的方案。**
什么意思呢?
在朴素解法中,当我们验证了某个起点 $i$ 失败(无法走完一圈)之后,我们接下来会去尝试验证起点 $i + 1$。
**这时候验证 $i$ 失败过程中产生的“信息”,其实并没有贡献到之后的算法中。**
事实上,起点 $i$ 验证失败,其实是意味存在某个位置 $k$ 使得「当前油量」为负数。而这个位置 $k$ 就是验证起点 $i$ 这过程中产生的“信息”。
它可以产生的价值是:**在位置 $i$ 和位置 $k$ 之间的所有位置,都不可能是一个合法起点。也就是说,随着起点 $i$ 验证失败,我们可以否决掉方案不仅仅是位置 $i$,而是 $[i, k]$ 这些位置。**
我们可以证明为什么会有这样的性质:
首先,可以明确的是:**因为 `gas` 数组和 `cost` 数组是给定的,因此每个位置的「净消耗」是固定的,与从哪个「起点」出发无关。**
净消耗是指该位置提供的「油量」和「到达下一位置的油耗」,也就是 `gas[i]` 和 `cast[i]` 之间的差值。
证明过程如图:
因此,当有了这个优化之后,我们每个位置其实只会被遍历常数次:**当位置 $i$ 作为「起点」验证失败后,验证过程中遍历过的位置就不需要再作为「起点」被验证了。**
代码:
```Java
class Solution {
public int canCompleteCircuit(int[] gas, int[] cost) {
int n = gas.length;
for (int start = 0; start < n; ) {
if (gas[start] < cost[start]) {
start++;
} else {
int cur = gas[start] - cost[start];
int idx = start + 1;
while (idx % n != start) {
cur += gas[idx % n] - cost[idx % n];
if (cur < 0) break;
idx++;
}
if (idx % n == start) return start;
else start = idx;
}
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 总结
看到这里,你可以已经理解了 $O(n)$ 解法是怎么来的了。
但可能还不清楚这个优化思路的本质是什么,其实这个优化的本质与 KMP 为什么可以做到线性匹配如出一辙。
**本质都是利用某次匹配(验证)过程产生的“信息”,来加速之后的匹配(验证)过程(否决掉一些必然合法的方案)。**
在我写过的 [KMP](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486317&idx=1&sn=9c2ff2fa5db427133cce9c875064e7a4&chksm=fd9ca072caeb29642bf1f5c151e4d5aaff4dc10ba408b23222ea1672cfc41204a584fede5c05&token=1279910339&lang=zh_CN#rd) 题解里,有这么一句原话:
> 当我们的原串指针从 `i` 位置后移到 `j` 位置,不仅仅代表着「原串」下标范围为 $[i,j)$ 的字符与「匹配串」匹配或者不匹配,更是在否决那些以「原串」下标范围为 $[i,j)$ 为「匹配发起点」的子集。
所以,从更本质的角度出发,这道题其实是一道「KMP」思想应用题,或者说广泛性的「DFA」题。
---
### 其他
在写「总结」部分的时候,我还特意去看了一下题解区,没有人提到过「KMP」和「DFA」,几乎所有题解都停留在题目标签「贪心算法」的角度去思考。
这是不对的,题目标签的拟定很大程度取决于「写这个标签的人的水平」和「ta 当时看这道题的思考角度」,是一个主观的结果。
**学习算法和数据结构,应该是去理解每个算法和数据结构的“某个操作”为什么能够带来优化效果,并将该优化效果的“底层思想”挖掘出来,应用到我们没见过的问题中,这才是真正的“学习”。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.134` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/137. 只出现一次的数字 II（中等）.md | 137. 只出现一次的数字 II | https://leetcode-cn.com/problems/single-number-ii/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-fku8/ | 中等 | [
"哈希表",
"位运算"
] | 给你一个整数数组 `nums`,除某个元素仅出现一次外,其余每个元素都恰出现三次。请你找出并返回那个只出现了一次的元素。
示例 1:
```
输入:nums = [2,2,3,2]
输出:3
```
示例 2:
```
输入:nums = [0,1,0,1,0,1,99]
输出:99
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* `nums` 中,除某个元素仅出现 一次 外,其余每个元素都恰出现 三次
进阶:你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗? | ### 哈希表
一个朴素的做法是使用「哈希表」进行计数,然后将计数为 $1$ 的数字进行输出。
哈希表以「数值 : 数值出现次数」形式进行存储。
代码:
```Java
class Solution {
public int singleNumber(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums) {
map.put(x, map.getOrDefault(x, 0) + 1);
}
for (int x : map.keySet()) {
if (map.get(x) == 1) return x;
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 位数统计
哈希表解法的空间复杂度是 $O(n)$ 的,而题目的【进阶】部分提到应当使用常数空间来做。
其中一个比较容易想到的做法,是利用 $int$ 类型固定为 $32$ 位。
**使用一个长度为 $32$ 的数组 $cnt[]$ 记录下所有数值的每一位共出现了多少次 $1$,再对 $cnt[]$ 数组的每一位进行 $mod$ $3$ 操作,重新拼凑出只出现一次的数值。**
举个 🌰,考虑样例 `[1,1,1,3]`,$1$ 和 $3$ 对应的二进制表示分别是 `00..001` 和 `00..011`,存入 $cnt[]$ 数组后得到 `[0,0,...,0,1,4]`。进行 $mod$ $3$ 操作后得到 `[0,0,...,0,1,1]`,再转为十进制数字即可得「只出现一次」的答案 $3$。
代码:
```Java
class Solution {
public int singleNumber(int[] nums) {
int[] cnt = new int[32];
for (int x : nums) {
for (int i = 0; i < 32; i++) {
if (((x >> i) & 1) == 1) {
cnt[i]++;
}
}
}
int ans = 0;
for (int i = 0; i < 32; i++) {
if ((cnt[i] % 3 & 1) == 1) {
ans += (1 << i);
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### DFA
如果我们考虑「除了某个元素只出现一次以外,其余每个元素均出现两次」的情况,那么可以使用「异或」运算。
利用相同数异或为 0 的性质,可以帮助我们很好实现状态切换:
本题是考虑「除了某个元素只出现一次以外,其余每个元素均出现三次」的情况,那么对应了「出现 0 次」、「出现 1 次」和「出现 2 次」三种状态,意味着至少需要两位进行记录,且状态转换关系为:
那么如何将上述 DFA 用表达式表示出来呢?有以下几种方法:
1. 用「真值表」写出「逻辑函数表达式」可参考 [这里](https://wenku.baidu.com/view/e9460ad96729647d27284b73f242336c1eb930f0.html),化简过程可以参考 [卡诺图化简法](https://baike.baidu.com/item/%E5%8D%A1%E8%AF%BA%E5%9B%BE%E5%8C%96%E7%AE%80%E6%B3%95) 。
2. 把结论记住(这是一道经典的 DFA 入门题)。
3. 硬做,位运算也就那几种,不会「数字电路」也记不住「结论」,砸时间看着真值表不断调逻辑也是可以写出来的。
代码:
```Java
class Solution {
public int singleNumber(int[] nums) {
int one = 0, two = 0;
for(int x : nums){
one = one ^ x & ~two;
two = two ^ x & ~one;
}
return one;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/138. 复制带随机指针的链表（中等）.md | 138. 复制带随机指针的链表 | https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-pqek/ | 中等 | [
"哈希表",
"链表"
] | 给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。
返回复制链表的头节点。
用一个由 `n` 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 `[val, random_index]` 表示:
* `val`:一个表示 `Node.val` 的整数。
* `random_index`:随机指针指向的节点索引(范围从 $0$ 到 $n-1$);如果不指向任何节点,则为 `null` 。
你的代码 只 接受原链表的头节点 `head` 作为传入参数。
示例 1:
```
输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]
```
示例 2:
```
输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]
```
示例 3:
```
输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]
```
示例 4:
```
输入:head = []
输出:[]
解释:给定的链表为空(空指针),因此返回 null。
```
提示:
* $0 <= n <= 1000$
* $-10000 <= Node.val <= 10000$ | ### 模拟 + 哈希表
如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。
现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:
1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;
2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应的新 `random` 节点,并在新链表上构造 `random` 关系。
代码:
```Java
class Solution {
public Node copyRandomList(Node head) {
Node t = head;
Node dummy = new Node(-10010), cur = dummy;
Map<Node, Node> map = new HashMap<>();
while (head != null) {
Node node = new Node(head.val);
map.put(head, node);
cur.next = node;
cur = cur.next; head = head.next;
}
cur = dummy.next; head = t;
while (head != null) {
cur.random = map.get(head.random);
cur = cur.next; head = head.next;
}
return dummy.next;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 模拟(原地算法)
显然时间复杂度上无法优化,考虑如何降低空间(不使用「哈希表」)。
我们使用「哈希表」的目的为了实现原节点和新节点的映射关系,更进一步的是为了快速找到某个节点 `random` 在新链表的位置。
那么我们可以利用原链表的 `next` 做一个临时中转,从而实现映射。
具体的,我们可以按照如下流程进行:
1. 对原链表的每个节点节点进行复制,并追加到原节点的后面;
2. 完成 $1$ 操作之后,链表的奇数位置代表了原链表节点,链表的偶数位置代表了新链表节点,且每个原节点的 `next` 指针执行了对应的新节点。这时候,我们需要构造新链表的 `random` 指针关系,可以利用 `link[i + 1].random = link[i].random.next`,$i$ 为奇数下标,含义为 **新链表节点的 `random` 指针指向旧链表对应节点的 `random` 指针的下一个值**;
3. 对链表进行拆分操作。
代码:
```Java
class Solution {
public Node copyRandomList(Node head) {
if (head == null) return head;
Node t = head;
while (head != null) {
Node node = new Node(head.val);
node.next = head.next;
head.next = node;
head = node.next;
}
head = t;
while (head != null) {
if (head.random != null) head.next.random = head.random.next;
head = head.next.next;
}
head = t;
Node ans = head.next;
while (head != null) {
Node ne = head.next;
if (ne != null) head.next = ne.next;
head = ne;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.138` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/139. 单词拆分（中等）.md | 139. 单词拆分 | https://leetcode.cn/problems/word-break/solution/by-ac_oier-gh00/ | 中等 | [
"动态规划",
"哈希表",
"序列 DP"
] | 给你一个字符串 `s` 和一个字符串列表 `wordDict` 作为字典。请你判断是否可以利用字典中出现的单词拼接出 `s` 。
注意:不要求字典中出现的单词全部都使用,并且字典中的单词可以重复使用。
示例 1:
```
输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
```
示例 2:
```
输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
注意,你可以重复使用字典中的单词。
```
示例 3:
```
输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false
```
提示:
* $1 <= s.length <= 300$
* $1 <= wordDict.length <= 1000$
* $1 <= wordDict[i].length <= 20$
* `s` 和 `wordDict[i]` 仅有小写英文字母组成
* `wordDict` 中的所有字符串 互不相同 | ### 序列 DP
将字符串 `s` 长度记为 $n$,`wordDict` 长度记为 $m$。为了方便,我们调整字符串 `s` 以及将要用到的动规数组的下标从 $1$ 开始。
定义 $f[i]$ 为考虑前 $i$ 个字符,能否使用 `wordDict` 拼凑出来:当 $f[i] = true$ 代表 $s[1...i]$ 能够使用 `wordDict` 所拼凑,反之则不能。
不失一般性考虑 $f[i]$ 该如何转移:由于 $f[i]$ 需要考虑 $s[1...i]$ 范围内的字符,若 $f[i]$ 为 `True` 说明整个 $s[1...i]$ 都能够使用 `wordDict` 拼凑,自然也包括最后一个字符 $s[i]$ 所在字符串 `sub`。
**我们可以枚举最后一个字符所在字符串的左端点 $j$,若 $sub = s[j...i]$ 在 `wordDict` 中出现过,并且 $f[j - 1] = True$,说明 $s[0...(j - 1)]$ 能够被拼凑,并且子串 `sub` 也在 `wordDict`,可得 `f[i] = True`。**
为了快速判断某个字符是否在 `wordDict` 中出现,我们可以使用 `Set` 结构对 $wordDict[i]$ 进行转存。
Java 代码:
```Java
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
Set<String> set = new HashSet<>();
for (String word : wordDict) set.add(word);
int n = s.length();
boolean[] f = new boolean[n + 10];
f[0] = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i && !f[i]; j++) {
String sub = s.substring(j - 1, i);
if (set.contains(sub)) f[i] = f[j - 1];
}
}
return f[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool wordBreak(string s, vector<string>& wordDict) {
unordered_set<string> set;
for (const string& word : wordDict) {
set.insert(word);
}
int n = s.length();
vector<bool> f(n + 10, false);
f[0] = true;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i && !f[i]; ++j) {
string sub = s.substr(j - 1, i - j + 1);
if (set.find(sub) != set.end()) f[i] = f[j - 1] || f[i];
}
}
return f[n];
}
};
```
Python 代码:
```Python
class Solution:
def wordBreak(self, s: str, wordDict: List[str]) -> bool:
ss = set(wordDict)
n = len(s)
f = [False] * (n + 10)
f[0] = True
for i in range(1, n + 1):
j = i
while j >= 1 and not f[i]:
sub = s[j - 1:i]
if sub in ss:
f[i] = f[j - 1]
j -= 1
return f[n]
```
TypeScript 代码:
```TypeScript
function wordBreak(s: string, wordDict: string[]): boolean {
const ss = new Set<string>(wordDict)
const n = s.length
const f = new Array<boolean>(n + 10).fill(false)
f[0] = true
for (let i = 1; i <= n; i++) {
for (let j = i; j >= 1 && !f[i]; j--) {
const sub = s.substring(j - 1, i)
if (ss.has(sub)) f[i] = f[j - 1]
}
}
return f[n]
}
```
* 时间复杂度:将 `wordDict` 转存在 `Set` 复杂度为 $O(m)$;`DP` 过程复忽裁剪子串和查询 `Set` 结构的常数,复杂度为 $O(n^2)$
* 空间复杂度:$O(n + m)$
---
### 总结
这里简单说下「线性 DP」和「序列 DP」的区别。
线性 DP 通常强调「状态转移所依赖的前驱状态」是由给定数组所提供的,即拓扑序是由原数组直接给出。更大白话来说就是通常有 $f[i][...]$ 依赖于 $f[i - 1][...]$。
这就限定了线性 DP 的复杂度是简单由「状态数量(或者说是维度数)」所决定。
序列 DP 通常需要结合题意来寻找前驱状态,即需要自身寻找拓扑序关系(例如本题,需要自己通过枚举的方式来找左端点,从而找到可转移的前驱状态 $f[j - 1]$)。
这就限定了序列 DP 的复杂度是由「状态数 + 找前驱」的复杂度所共同决定。也直接导致了序列 DP 有很多玩法,往往能够结合其他知识点出题,来优化找前驱这一操作,通常是利用某些性质,或是利用数据结构进行优化。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.139` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1331. 数组序号转换（简单）.md | 1331. 数组序号转换 | https://leetcode.cn/problems/rank-transform-of-an-array/solution/by-ac_oier-j70n/ | 简单 | [
"模拟",
"哈希表",
"排序"
] | 给你一个整数数组 `arr`,请你将数组中的每个元素替换为它们排序后的序号。
序号代表了一个元素有多大。序号编号的规则如下:
* 序号从 $1$ 开始编号。
* 一个元素越大,那么序号越大。如果两个元素相等,那么它们的序号相同。
* 每个数字的序号都应该尽可能地小。
示例 1:
```
输入:arr = [40,10,20,30]
输出:[4,1,2,3]
解释:40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。
```
示例 2:
```
输入:arr = [100,100,100]
输出:[1,1,1]
解释:所有元素有相同的序号。
```
示例 3:
```
输入:arr = [37,12,28,9,100,56,80,5,12]
输出:[5,3,4,2,8,6,7,1,3]
```
提示:
* $0 <= arr.length <= 10^5$
* $-10^9 <= arr[i] <= 10^9$ | ### 模拟
根据题意进行模拟即可。
对 `arr` 进行拷贝操作得到新数组 `clone`,对 `clone` 数组进行排序,再使用哈希表记录元素与序号的映射关系,最后根据映射关系构造答案。
Java 代码:
```Java
class Solution {
public int[] arrayRankTransform(int[] arr) {
int[] clone = arr.clone();
Arrays.sort(clone);
Map<Integer, Integer> map = new HashMap<>();
int n = arr.length, idx = 0;
for (int i : clone) {
if (!map.containsKey(i)) map.put(i, ++idx);
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = map.get(arr[i]);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function arrayRankTransform(arr: number[]): number[] {
let clone = new Array<number>()
for (const i of arr) clone.push(i)
clone.sort((a,b)=>a-b)
let n = arr.length, idx = 0
let map = new Map<number, number>()
for (const i of clone) {
if (!map.has(i)) map.set(i, ++idx)
}
let ans = new Array<number>()
for (let i = 0; i < n; i++) ans.push(map.get(arr[i]))
return ans
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1331` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |