) -> i32 {
+ let (n, m) = (nums1.len(), nums2.len());
+ let mut last = vec![0; m + 1]; // 记录滚动数组
+ let mut dp = vec![0; m + 1];
+ for i in 1..=n {
+ dp.swap_with_slice(&mut last);
+ for j in 1..=m {
+ if nums1[i - 1] == nums2[j - 1] {
+ dp[j] = last[j - 1] + 1;
+ } else {
+ dp[j] = last[j].max(dp[j - 1]);
+ }
+ }
+ }
+ dp[m]
+}
+```
JavaScript：
diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md
index fdcc7619..ecedf89b 100644
--- a/problems/1143.最长公共子序列.md
+++ b/problems/1143.最长公共子序列.md
@@ -4,40 +4,40 @@
参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
-## 1143.最长公共子序列
+## 1143.最长公共子序列
[力扣题目链接](https://leetcode-cn.com/problems/longest-common-subsequence/)
-给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
+给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
-一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
+一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
-例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
+例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
-若这两个字符串没有公共子序列，则返回 0。
+若这两个字符串没有公共子序列，则返回 0。
-示例 1:
+示例 1:
-输入：text1 = "abcde", text2 = "ace"
-输出：3
-解释：最长公共子序列是 "ace"，它的长度为 3。
+输入：text1 = "abcde", text2 = "ace"
+输出：3
+解释：最长公共子序列是 "ace"，它的长度为 3。
-示例 2:
-输入：text1 = "abc", text2 = "abc"
-输出：3
-解释：最长公共子序列是 "abc"，它的长度为 3。
+示例 2:
+输入：text1 = "abc", text2 = "abc"
+输出：3
+解释：最长公共子序列是 "abc"，它的长度为 3。
-示例 3:
-输入：text1 = "abc", text2 = "def"
-输出：0
-解释：两个字符串没有公共子序列，返回 0。
+示例 3:
+输入：text1 = "abc", text2 = "def"
+输出：0
+解释：两个字符串没有公共子序列，返回 0。
-提示:
+提示:
* 1 <= text1.length <= 1000
* 1 <= text2.length <= 1000
输入的字符串只含有小写英文字符。
-## 思路
+## 思路
本题和[动态规划：718. 最长重复子数组](https://programmercarl.com/0718.最长重复子数组.html)区别在于这里不要求是连续的了，但要有相对顺序，即："ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
@@ -45,21 +45,21 @@
1. 确定dp数组（dp table）以及下标的含义
-dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
+dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
-有同学会问：为什么要定义长度为[0, i - 1]的字符串text1，定义为长度为[0, i]的字符串text1不香么？
+有同学会问：为什么要定义长度为[0, i - 1]的字符串text1，定义为长度为[0, i]的字符串text1不香么？
这样定义是为了后面代码实现方便，如果非要定义为为长度为[0, i]的字符串text1也可以，大家可以试一试！
2. 确定递推公式
-主要就是两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同
+主要就是两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同
-如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;
+如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。
-即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
代码如下：
@@ -71,9 +71,9 @@ if (text1[i - 1] == text2[j - 1]) {
}
```
-3. dp数组如何初始化
+3. dp数组如何初始化
-先看看dp[i][0]应该是多少呢？
+先看看dp[i][0]应该是多少呢？
test1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i][0] = 0;
@@ -101,7 +101,7 @@ vector> dp(text1.size() + 1, vector(text2.size() + 1, 0));
-最后红框dp[text1.size()][text2.size()]为最终结果
+最后红框dp[text1.size()][text2.size()]为最终结果
以上分析完毕，C++代码如下：
@@ -158,7 +158,7 @@ class Solution:
for i in range(1, len2):
for j in range(1, len1): # 开始列出状态转移方程
if text1[j-1] == text2[i-1]:
- dp[i][j] = dp[i-1][j-1]+1
+ dp[i][j] = dp[i-1][j-1]+1
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
return dp[-1][-1]
@@ -189,10 +189,32 @@ func longestCommonSubsequence(text1 string, text2 string) int {
func max(a,b int)int {
if a>b{
- return a
+ return a
}
return b
}
+
+```
+
+Rust:
+```rust
+pub fn longest_common_subsequence(text1: String, text2: String) -> i32 {
+ let (n, m) = (text1.len(), text2.len());
+ let (s1, s2) = (text1.as_bytes(), text2.as_bytes());
+ let mut dp = vec![0; m + 1];
+ let mut last = vec![0; m + 1];
+ for i in 1..=n {
+ dp.swap_with_slice(&mut last);
+ for j in 1..=m {
+ dp[j] = if s1[i - 1] == s2[j - 1] {
+ last[j - 1] + 1
+ } else {
+ last[j].max(dp[j - 1])
+ };
+ }
+ }
+ dp[m]
+}
```
Javascript：
From da464016574f14c43fe1e9f7c0d808ed7ea304fb Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Sun, 8 May 2022 10:29:33 +0800
Subject: [PATCH 42/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880322.=E9=9B=B6?=
=?UTF-8?q?=E9=92=B1=E5=85=91=E6=8D=A2.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0322.零钱兑换.md | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/problems/0322.零钱兑换.md b/problems/0322.零钱兑换.md
index 3a8d0662..1df8d613 100644
--- a/problems/0322.零钱兑换.md
+++ b/problems/0322.零钱兑换.md
@@ -322,7 +322,21 @@ const coinChange = (coins, amount) => {
}
```
+TypeScript：
+```typescript
+function coinChange(coins: number[], amount: number): number {
+ const dp: number[] = new Array(amount + 1).fill(Infinity);
+ dp[0] = 0;
+ for (let i = 0; i < coins.length; i++) {
+ for (let j = coins[i]; j <= amount; j++) {
+ if (dp[j - coins[i]] === Infinity) continue;
+ dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
+ }
+ }
+ return dp[amount] === Infinity ? -1 : dp[amount];
+};
+```
-----------------------
From 9b6a447674f3290541e46088962e1e3aa764d827 Mon Sep 17 00:00:00 2001
From: Hayden-Chang <62008508+Hayden-Chang@users.noreply.github.com>
Date: Sun, 8 May 2022 14:20:09 +0800
Subject: [PATCH 44/91] explain the reason for reverse traversal
---
problems/背包理论基础01背包-2.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index dabdfb2d..ea7c53ad 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -136,6 +136,7 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
不可以！
因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。
+倒叙遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
（这里如果读不懂，就在回想一下dp[j]的定义，或者就把两个for循环顺序颠倒一下试试！）
From 80167289e4895c4116b61a5c2a4fa22e9e2e88b5 Mon Sep 17 00:00:00 2001
From: Hayden-Chang <62008508+Hayden-Chang@users.noreply.github.com>
Date: Sun, 8 May 2022 14:24:09 +0800
Subject: [PATCH 45/91] =?UTF-8?q?Update=20=E8=83=8C=E5=8C=85=E7=90=86?=
=?UTF-8?q?=E8=AE=BA=E5=9F=BA=E7=A1=8001=E8=83=8C=E5=8C=85-2.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-2.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index ea7c53ad..eae01158 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -136,7 +136,8 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
不可以！
因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。
-倒叙遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
+
+倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
（这里如果读不懂，就在回想一下dp[j]的定义，或者就把两个for循环顺序颠倒一下试试！）
From 2fb34b30b38ee73624d65d183955cef3a80caced Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Sun, 8 May 2022 18:28:32 +0800
Subject: [PATCH 46/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880139.=E5=8D=95?=
=?UTF-8?q?=E8=AF=8D=E6=8B=86=E5=88=86.md=EF=BC=89:=E5=A2=9E=E5=8A=A0types?=
=?UTF-8?q?cript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0139.单词拆分.md | 42 +++++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index ac834f04..5b4e92b9 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -345,6 +345,48 @@ const wordBreak = (s, wordDict) => {
}
```
+TypeScript：
+
+> 动态规划
+
+```typescript
+function wordBreak(s: string, wordDict: string[]): boolean {
+ const dp: boolean[] = new Array(s.length + 1).fill(false);
+ dp[0] = true;
+ for (let i = 1; i <= s.length; i++) {
+ for (let j = 0; j < i; j++) {
+ const tempStr: string = s.slice(j, i);
+ if (wordDict.includes(tempStr) && dp[j] === true) {
+ dp[i] = true;
+ break;
+ }
+ }
+ }
+ return dp[s.length];
+};
+```
+
+> 记忆化回溯
+
+```typescript
+function wordBreak(s: string, wordDict: string[]): boolean {
+ // 只需要记忆结果为false的情况
+ const memory: boolean[] = [];
+ return backTracking(s, wordDict, 0, memory);
+ function backTracking(s: string, wordDict: string[], startIndex: number, memory: boolean[]): boolean {
+ if (startIndex >= s.length) return true;
+ if (memory[startIndex] === false) return false;
+ for (let i = startIndex + 1, length = s.length; i <= length; i++) {
+ const str: string = s.slice(startIndex, i);
+ if (wordDict.includes(str) && backTracking(s, wordDict, i, memory))
+ return true;
+ }
+ memory[startIndex] = false;
+ return false;
+ }
+};
+```
+
-----------------------
From 21475ad21864ce33fb5a6a113581f2c346be78b6 Mon Sep 17 00:00:00 2001
From: languagege
Date: Mon, 9 May 2022 18:51:39 +0800
Subject: [PATCH 47/91] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E4=BA=86=E5=85=B6?=
=?UTF-8?q?=E4=B8=AD=E4=B8=80=E4=B8=AA=E9=94=99=E5=88=AB=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0027.移除元素.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..3a93ac88 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -81,7 +81,7 @@ public:
**双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。**
-后序都会一一介绍到，本题代码如下：
+后续都会一一介绍到，本题代码如下：
```CPP
// 时间复杂度：O(n)
From 75198263f91484020c4a4dde421d9ecd989422dd Mon Sep 17 00:00:00 2001
From: changjunkui <506678275@qq.com>
Date: Tue, 10 May 2022 08:16:53 +0800
Subject: [PATCH 48/91] =?UTF-8?q?Update=200019.=E5=88=A0=E9=99=A4=E9=93=BE?=
=?UTF-8?q?=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=ACN=E4=B8=AA?=
=?UTF-8?q?=E8=8A=82=E7=82=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
方面改为方便
---
problems/0019.删除链表的倒数第N个节点.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 813e9b02..b3030a81 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -39,7 +39,7 @@
分为如下几步：
-* 首先这里我推荐大家使用虚拟头结点，这样方面处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
+* 首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
* 定义fast指针和slow指针，初始值为虚拟头结点，如图：
From 8bab33d0bba8a080fb614bec6be3b0a5961d7727 Mon Sep 17 00:00:00 2001
From: wang <472146630@qq.com>
Date: Tue, 10 May 2022 21:27:54 +0800
Subject: [PATCH 49/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200300.=E6=9C=80?=
=?UTF-8?q?=E9=95=BF=E4=B8=8A=E5=8D=87=E5=AD=90=E5=BA=8F=E5=88=97=E3=80=81?=
=?UTF-8?q?0322.=E9=9B=B6=E9=92=B1=E5=85=91=E6=8D=A2=E3=80=810518.?=
=?UTF-8?q?=E9=9B=B6=E9=92=B1=E5=85=91=E6=8D=A2II=20=E5=92=8C0674.?=
=?UTF-8?q?=E6=9C=80=E9=95=BF=E8=BF=9E=E7=BB=AD=E9=80=92=E5=A2=9E=E5=BA=8F?=
=?UTF-8?q?=E5=88=97=E7=9A=84rust=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0300.最长上升子序列.md | 17 +++++++++++++++++
problems/0322.零钱兑换.md | 20 +++++++++++++++++++-
problems/0518.零钱兑换II.md | 16 ++++++++++++++++
problems/0674.最长连续递增序列.md | 19 +++++++++++++++++++
4 files changed, 71 insertions(+), 1 deletion(-)
diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index dfdd5125..f53d19a1 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -168,6 +168,23 @@ func lengthOfLIS(nums []int ) int {
}
```
+Rust:
+```rust
+pub fn length_of_lis(nums: Vec) -> i32 {
+ let mut dp = vec![1; nums.len() + 1];
+ let mut result = 1;
+ for i in 1..nums.len() {
+ for j in 0..i {
+ if nums[j] < nums[i] {
+ dp[i] = dp[i].max(dp[j] + 1);
+ }
+ result = result.max(dp[i]);
+ }
+ }
+ result
+}
+```
+
Javascript
```javascript
const lengthOfLIS = (nums) => {
diff --git a/problems/0322.零钱兑换.md b/problems/0322.零钱兑换.md
index 3a8d0662..43c735be 100644
--- a/problems/0322.零钱兑换.md
+++ b/problems/0322.零钱兑换.md
@@ -220,7 +220,7 @@ class Solution:
for j in range(coin, amount + 1):
dp[j] = min(dp[j], dp[j - coin] + 1)
return dp[amount] if dp[amount] < amount + 1 else -1
-
+
def coinChange1(self, coins: List[int], amount: int) -> int:
'''版本二'''
# 初始化
@@ -302,6 +302,24 @@ func min(a, b int) int {
```
+Rust:
+
+```rust
+pub fn coin_change(coins: Vec, amount: i32) -> i32 {
+ let amount = amount as usize;
+ let mut dp = vec![i32::MAX; amount + 1];
+ dp[0] = 0;
+ for i in 0..coins.len() {
+ for j in coins[i] as usize..=amount {
+ if dp[j - coins[i] as usize] != i32::MAX {
+ dp[j] = dp[j].min(dp[j - coins[i] as usize] + 1);
+ }
+ }
+ }
+ if dp[amount] == i32::MAX { -1 } else { dp[amount] }
+}
+```
+
Javascript：
```javascript
const coinChange = (coins, amount) => {
diff --git a/problems/0518.零钱兑换II.md b/problems/0518.零钱兑换II.md
index e72c5f85..0e4a3987 100644
--- a/problems/0518.零钱兑换II.md
+++ b/problems/0518.零钱兑换II.md
@@ -242,6 +242,22 @@ func change(amount int, coins []int) int {
}
```
+Rust:
+```rust
+pub fn change(amount: i32, coins: Vec) -> i32 {
+ let amount = amount as usize;
+ let coins = coins.iter().map(|&c|c as usize).collect::>();
+ let mut dp = vec![0usize; amount + 1];
+ dp[0] = 1;
+ for i in 0..coins.len() {
+ for j in coins[i]..=amount {
+ dp[j] += dp[j - coins[i]];
+ }
+ }
+ dp[amount] as i32
+}
+```
+
Javascript：
```javascript
const change = (amount, coins) => {
diff --git a/problems/0674.最长连续递增序列.md b/problems/0674.最长连续递增序列.md
index e941d242..36471490 100644
--- a/problems/0674.最长连续递增序列.md
+++ b/problems/0674.最长连续递增序列.md
@@ -218,6 +218,7 @@ class Solution:
return result
```
+
> 贪心法：
```python
class Solution:
@@ -237,6 +238,24 @@ class Solution:
Go：
+Rust:
+```rust
+pub fn find_length_of_lcis(nums: Vec) -> i32 {
+ if nums.is_empty() {
+ return 0;
+ }
+ let mut result = 1;
+ let mut dp = vec![1; nums.len()];
+ for i in 1..nums.len() {
+ if nums[i - 1] < nums[i] {
+ dp[i] = dp[i - 1] + 1;
+ result = result.max(dp[i]);
+ }
+ }
+ result
+}
+```
+
Javascript：
> 动态规划：
From c62d518e149295783d219ec1871da84af8e5546e Mon Sep 17 00:00:00 2001
From: FizzerYu <36132150+FizzerYu@users.noreply.github.com>
Date: Wed, 11 May 2022 01:17:08 +0800
Subject: [PATCH 50/91] fix bug
---
problems/0701.二叉搜索树中的插入操作.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md
index df6a3954..50e39ade 100644
--- a/problems/0701.二叉搜索树中的插入操作.md
+++ b/problems/0701.二叉搜索树中的插入操作.md
@@ -279,7 +279,7 @@ class Solution:
root.right = self.insertIntoBST(root.right, val)
# 返回更新后的以当前root为根节点的新树
- return roo
+ return root
```
**递归法** - 无返回值
From d92aa2c52f0589cca9dbf1a7624f9312395b63fe Mon Sep 17 00:00:00 2001
From: unknown
Date: Wed, 11 May 2022 00:39:59 +0100
Subject: [PATCH 51/91] =?UTF-8?q?Add=200112.=E8=B7=AF=E5=BE=84=E6=80=BB?=
=?UTF-8?q?=E5=92=8C.md=20C=E8=AF=AD=E8=A8=80=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0112.路径总和.md | 57 +++++++++++++++++++++++++++++++++++
1 file changed, 57 insertions(+)
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 41463ec1..6433996c 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -1006,6 +1006,63 @@ func traversal(_ cur: TreeNode?, count: Int) {
}
```
+## C
+0112.路径总和
+递归法：
+```c
+bool hasPathSum(struct TreeNode* root, int targetSum){
+ // 递归结束条件：若当前节点不存在，返回false
+ if(!root)
+ return false;
+ // 若当前节点为叶子节点，且targetSum-root的值为0。（当前路径上的节点值的和满足条件）返回true
+ if(!root->right && !root->left && targetSum == root->val)
+ return true;
+
+ // 查看左子树和右子树的所有节点是否满足条件
+ return hasPathSum(root->right, targetSum - root->val) || hasPathSum(root->left, targetSum - root->val);
+}
+```
+
+迭代法:
+```c
+// 存储一个节点以及当前的和
+struct Pair {
+ struct TreeNode* node;
+ int sum;
+};
+
+bool hasPathSum(struct TreeNode* root, int targetSum){
+ struct Pair stack[1000];
+ int stackTop = 0;
+
+ // 若root存在，则将节点和值封装成一个pair入栈
+ if(root) {
+ struct Pair newPair = {root, root->val};
+ stack[stackTop++] = newPair;
+ }
+
+ // 当栈不为空时
+ while(stackTop) {
+ // 出栈栈顶元素
+ struct Pair topPair = stack[--stackTop];
+ // 若栈顶元素为叶子节点，且和为targetSum时，返回true
+ if(!topPair.node->left && !topPair.node->right && topPair.sum == targetSum)
+ return true;
+
+ // 若当前栈顶节点有左右孩子，计算和并入栈
+ if(topPair.node->left) {
+ struct Pair newPair = {topPair.node->left, topPair.sum + topPair.node->left->val};
+ stack[stackTop++] = newPair;
+ }
+ if(topPair.node->right) {
+ struct Pair newPair = {topPair.node->right, topPair.sum + topPair.node->right->val};
+ stack[stackTop++] = newPair;
+ }
+ }
+ return false;
+}
+```
+
-----------------------
From cc2c2adb0987a5e2e82eed75a93be068da6388a4 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 16:03:22 +0800
Subject: [PATCH 52/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200977.=E6=9C=89?=
=?UTF-8?q?=E5=BA=8F=E6=95=B0=E7=BB=84=E7=9A=84=E5=B9=B3=E6=96=B9.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0977.有序数组的平方.md | 34 ++++++++++++++++++++++++++
1 file changed, 34 insertions(+)
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 24276bcf..0e79a3d6 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -358,7 +358,41 @@ class Solution {
}
}
```
+Scala:
+双指针:
+```scala
+object Solution {
+ def sortedSquares(nums: Array[Int]): Array[Int] = {
+ val res: Array[Int] = new Array[Int](nums.length)
+ var top = nums.length - 1
+ var i = 0
+ var j = nums.length - 1
+ while (i <= j) {
+ if (nums(i) * nums(i) <= nums(j) * nums(j)) {
+ // 当左侧平方小于等于右侧，res数组顶部放右侧的平方，并且top下移，j左移
+ res(top) = nums(j) * nums(j)
+ top -= 1
+ j -= 1
+ } else {
+ // 当左侧平方大于右侧，res数组顶部放左侧的平方，并且top下移，i右移
+ res(top) = nums(i) * nums(i)
+ top -= 1
+ i += 1
+ }
+ }
+ res
+ }
+}
+```
+骚操作(暴力思路):
+```scala
+object Solution {
+ def sortedSquares(nums: Array[Int]): Array[Int] = {
+ nums.map(x=>{x*x}).sortWith(_ < _)
+ }
+}
+```
-----------------------
From 842c04208b163c4782fb7070d949f5feb0c01bee Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 16:35:58 +0800
Subject: [PATCH 53/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=88=E8=83=8C?=
=?UTF-8?q?=E5=8C=85=E9=97=AE=E9=A2=98=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80?=
=?UTF-8?q?=E5=A4=9A=E9=87=8D=E8=83=8C=E5=8C=85.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../背包问题理论基础多重背包.md | 58 +++++++++++++++++++
1 file changed, 58 insertions(+)
diff --git a/problems/背包问题理论基础多重背包.md b/problems/背包问题理论基础多重背包.md
index a988db2c..712380f4 100644
--- a/problems/背包问题理论基础多重背包.md
+++ b/problems/背包问题理论基础多重背包.md
@@ -334,6 +334,64 @@ func Test_multiplePack(t *testing.T) {
PASS
```
+TypeScript：
+
+> 版本一（改变数据源）：
+
+```typescript
+function testMultiPack() {
+ const bagSize: number = 10;
+ const weightArr: number[] = [1, 3, 4],
+ valueArr: number[] = [15, 20, 30],
+ amountArr: number[] = [2, 3, 2];
+ for (let i = 0, length = amountArr.length; i < length; i++) {
+ while (amountArr[i] > 1) {
+ weightArr.push(weightArr[i]);
+ valueArr.push(valueArr[i]);
+ amountArr[i]--;
+ }
+ }
+ const goodsNum: number = weightArr.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ // 遍历物品
+ for (let i = 0; i < goodsNum; i++) {
+ // 遍历背包容量
+ for (let j = bagSize; j >= weightArr[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - weightArr[i]] + valueArr[i]);
+ }
+ }
+ console.log(dp);
+}
+testMultiPack();
+```
+
+> 版本二（改变遍历方式）：
+
+```typescript
+function testMultiPack() {
+ const bagSize: number = 10;
+ const weightArr: number[] = [1, 3, 4],
+ valueArr: number[] = [15, 20, 30],
+ amountArr: number[] = [2, 3, 2];
+ const goodsNum: number = weightArr.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ // 遍历物品
+ for (let i = 0; i < goodsNum; i++) {
+ // 遍历物品个数
+ for (let j = 0; j < amountArr[i]; j++) {
+ // 遍历背包容量
+ for (let k = bagSize; k >= weightArr[i]; k--) {
+ dp[k] = Math.max(dp[k], dp[k - weightArr[i]] + valueArr[i]);
+ }
+ }
+ }
+ console.log(dp);
+}
+testMultiPack();
+```
+
+
+
-----------------------
From 871d96a2f9202504f2f5c754da7404f602a9f073 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 16:48:59 +0800
Subject: [PATCH 54/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200209.=E9=95=BF?=
=?UTF-8?q?=E5=BA=A6=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0209.长度最小的子数组.md | 48 +++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index fd72cf1b..78b8156c 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -400,6 +400,54 @@ class Solution {
}
}
```
+Scala:
+
+滑动窗口:
+```scala
+object Solution {
+ def minSubArrayLen(target: Int, nums: Array[Int]): Int = {
+ var result = Int.MaxValue // 返回结果，默认最大值
+ var left = 0 // 慢指针，当sum>=target，向右移动
+ var sum = 0 // 窗口值的总和
+ for (right <- 0 until nums.length) {
+ sum += nums(right)
+ while (sum >= target) {
+ result = math.min(result, right - left + 1) // 产生新结果
+ sum -= nums(left) // 左指针移动，窗口总和减去左指针的值
+ left += 1 // 左指针向右移动
+ }
+ }
+ // 相当于三元运算符，return关键字可以省略
+ if (result == Int.MaxValue) 0 else result
+ }
+}
+```
+
+暴力解法:
+```scala
+object Solution {
+ def minSubArrayLen(target: Int, nums: Array[Int]): Int = {
+ import scala.util.control.Breaks
+ var res = Int.MaxValue
+ var subLength = 0
+ for (i <- 0 until nums.length) {
+ var sum = 0
+ Breaks.breakable(
+ for (j <- i until nums.length) {
+ sum += nums(j)
+ if (sum >= target) {
+ subLength = j - i + 1
+ res = math.min(subLength, res)
+ Breaks.break()
+ }
+ }
+ )
+ }
+ // 相当于三元运算符
+ if (res == Int.MaxValue) 0 else res
+ }
+}
+```
-----------------------
From cb2fea63e7f5e616f697a715b9d523b6ba877308 Mon Sep 17 00:00:00 2001
From: unknown
Date: Wed, 11 May 2022 09:50:47 +0100
Subject: [PATCH 55/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200113.=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8CII=20C=E8=AF=AD=E8=A8=80=E8=A7=A3?=
=?UTF-8?q?=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0112.路径总和.md | 65 ++++++++++++++++++++++++++++++++++-
1 file changed, 64 insertions(+), 1 deletion(-)
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 6433996c..de155b45 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -1007,7 +1007,7 @@ func traversal(_ cur: TreeNode?, count: Int) {
```
## C
-0112.路径总和
+> 0112.路径总和
递归法：
```c
bool hasPathSum(struct TreeNode* root, int targetSum){
@@ -1062,6 +1062,69 @@ bool hasPathSum(struct TreeNode* root, int targetSum){
return false;
}
```
+> 0113.路径总和 II
+```c
+int** ret;
+int* path;
+int* colSize;
+int retTop;
+int pathTop;
+
+void traversal(const struct TreeNode* const node, int count) {
+ // 若当前节点为叶子节点
+ if(!node->right && !node->left) {
+ // 若当前path上的节点值总和等于targetSum。
+ if(count == 0) {
+ // 复制当前path
+ int *curPath = (int*)malloc(sizeof(int) * pathTop);
+ memcpy(curPath, path, sizeof(int) * pathTop);
+ // 记录当前path的长度为pathTop
+ colSize[retTop] = pathTop;
+ // 将当前path加入到ret数组中
+ ret[retTop++] = curPath;
+ }
+ return;
+ }
+
+ // 若节点有左/右孩子
+ if(node->left) {
+ // 将左孩子的值加入path中
+ path[pathTop++] = node->left->val;
+ traversal(node->left, count - node->left->val);
+ // 回溯
+ pathTop--;
+ }
+ if(node->right) {
+ // 将右孩子的值加入path中
+ path[pathTop++] = node->right->val;
+ traversal(node->right, count - node->right->val);
+ // 回溯
+ --pathTop;
+ }
+}
+
+int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes){
+ // 初始化数组
+ ret = (int**)malloc(sizeof(int*) * 1000);
+ path = (int*)malloc(sizeof(int*) * 1000);
+ colSize = (int*)malloc(sizeof(int) * 1000);
+ retTop = pathTop = 0;
+ *returnSize = 0;
+
+ // 若根节点不存在，返回空的ret
+ if(!root)
+ return ret;
+ // 将根节点加入到path中
+ path[pathTop++] = root->val;
+ traversal(root, targetSum - root->val);
+
+ // 设置返回ret数组大小，以及其中每个一维数组元素的长度
+ *returnSize = retTop;
+ *returnColumnSizes = colSize;
+
+ return ret;
+}
+```
From c363e9da86973e5dafaa5e765c9c6318b5eb9723 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 16:59:05 +0800
Subject: [PATCH 56/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880198.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8D.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0198.打家劫舍.md | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
index dfe1f3a0..a828b9a9 100644
--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@@ -189,6 +189,29 @@ const rob = nums => {
};
```
+TypeScript：
+
+```typescript
+function rob(nums: number[]): number {
+ /**
+ dp[i]: 前i个房屋能偷到的最大金额
+ dp[0]: nums[0];
+ dp[1]: max(nums[0], nums[1]);
+ ...
+ dp[i]: max(dp[i-1], dp[i-2]+nums[i]);
+ */
+ const length: number = nums.length;
+ if (length === 1) return nums[0];
+ const dp: number[] = [];
+ dp[0] = nums[0];
+ dp[1] = Math.max(nums[0], nums[1]);
+ for (let i = 2; i < length; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ return dp[length - 1];
+};
+```
+
From a8cfc460e7143e6b6d8486ad9e8d88e1c9759211 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 17:37:12 +0800
Subject: [PATCH 57/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200059.=E8=9E=BA?=
=?UTF-8?q?=E6=97=8B=E7=9F=A9=E9=98=B5II.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0059.螺旋矩阵II.md | 51 +++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index a7b19a34..f3b8e1ce 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -564,6 +564,57 @@ int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
return ans;
}
```
+Scala:
+```scala
+object Solution {
+ def generateMatrix(n: Int): Array[Array[Int]] = {
+ var res = Array.ofDim[Int](n, n) // 定义一个n*n的二维矩阵
+ var num = 1 // 标志当前到了哪个数字
+ var i = 0 // 横坐标
+ var j = 0 // 竖坐标
+ while (num <= n * n) {
+ // 向右：当j不越界，并且下一个要填的数字是空白时
+ while (j < n && res(i)(j) == 0) {
+ res(i)(j) = num // 当前坐标等于num
+ num += 1 // num++
+ j += 1 // 竖坐标+1
+ }
+ i += 1 // 下移一行
+ j -= 1 // 左移一列
+
+ // 剩下的都同上
+
+ // 向下
+ while (i < n && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ i += 1
+ }
+ i -= 1
+ j -= 1
+
+ // 向左
+ while (j >= 0 && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ j -= 1
+ }
+ i -= 1
+ j += 1
+
+ // 向上
+ while (i >= 0 && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ i -= 1
+ }
+ i += 1
+ j += 1
+ }
+ res
+ }
+}
+```
-----------------------
From 296485551542d296e27486e985406d7944f3aa9a Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 18:35:43 +0800
Subject: [PATCH 58/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880213.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8DII.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0213.打家劫舍II.md | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index 8e569e46..9e698d01 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -165,7 +165,30 @@ const robRange = (nums, start, end) => {
return dp[end]
}
```
+TypeScript：
+
+```typescript
+function rob(nums: number[]): number {
+ const length: number = nums.length;
+ if (length === 0) return 0;
+ if (length === 1) return nums[0];
+ return Math.max(robRange(nums, 0, length - 2),
+ robRange(nums, 1, length - 1));
+};
+function robRange(nums: number[], start: number, end: number): number {
+ if (start === end) return nums[start];
+ const dp: number[] = [];
+ dp[start] = nums[start];
+ dp[start + 1] = Math.max(nums[start], nums[start + 1]);
+ for (let i = start + 2; i <= end; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ return dp[end];
+}
+```
+
Go：
+
```go
// 打家劫舍Ⅱ 动态规划
// 时间复杂度O(n) 空间复杂度O(n)
From 558dc3343150b1a91a1f307c0bb1fcb881abcd20 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 19:11:53 +0800
Subject: [PATCH 59/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E9=93=BE=E8=A1=A8?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/链表理论基础.md | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/problems/链表理论基础.md b/problems/链表理论基础.md
index 095282f5..9dddf1e2 100644
--- a/problems/链表理论基础.md
+++ b/problems/链表理论基础.md
@@ -210,6 +210,13 @@ type ListNode struct {
}
```
+Scala:
+```scala
+class ListNode(_x: Int = 0, _next: ListNode = null) {
+ var next: ListNode = _next
+ var x: Int = _x
+}
+```
-----------------------
From 8a562b7a2511b44705a6d9e28388738d6a452848 Mon Sep 17 00:00:00 2001
From: UndeadSheep
Date: Wed, 11 May 2022 19:44:09 +0800
Subject: [PATCH 60/91] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20=E5=93=88=E5=B8=8C?=
=?UTF-8?q?=E8=A1=A8=E9=83=A8=E5=88=86=E7=9A=84=20C#=E7=89=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0001.两数之和.md | 18 +++++++++++++++
problems/0202.快乐数.md | 23 +++++++++++++++++++
problems/0242.有效的字母异位词.md | 19 ++++++++++++++++
problems/0349.两个数组的交集.md | 18 +++++++++++++++
problems/0383.赎金信.md | 17 ++++++++++++++
problems/0454.四数相加II.md | 27 +++++++++++++++++++++++
6 files changed, 122 insertions(+)
diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index 9571a773..459a66ad 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -274,6 +274,24 @@ class Solution {
}
}
```
+C#:
+```csharp
+public class Solution {
+ public int[] TwoSum(int[] nums, int target) {
+ Dictionary dic= new Dictionary();
+ for(int i=0;i
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 741a735a..51a79aff 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -385,5 +385,28 @@ bool isHappy(int n){
return bHappy;
}
```
+
+C#：
+```csharp
+public class Solution {
+ private int getSum(int n) {
+ int sum = 0;
+ //每位数的换算
+ while (n > 0) {
+ sum += (n % 10) * (n % 10);
+ n /= 10;
+ }
+ return sum;
+ }
+ public bool IsHappy(int n) {
+ HashSet set = new HashSet();
+ while(n != 1 && !set.Contains(n)) { //判断避免循环
+ set.Add(n);
+ n = getSum(n);
+ }
+ return n == 1;
+ }
+}
+```
-----------------------
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 080166fd..878b2466 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -307,6 +307,25 @@ impl Solution {
}
}
```
+
+C#：
+```csharp
+ public bool IsAnagram(string s, string t) {
+ int sl=s.Length,tl=t.Length;
+ if(sl!=tl) return false;
+ int[] a = new int[26];
+ for(int i = 0; i < sl; i++){
+ a[s[i] - 'a']++;
+ a[t[i] - 'a']--;
+ }
+ foreach (int i in a)
+ {
+ if (i != 0)
+ return false;
+ }
+ return true;
+ }
+```
## 相关题目
* 383.赎金信
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 45f19b6e..7f8958d2 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -313,6 +313,24 @@ int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* re
}
```
+C#:
+```csharp
+ public int[] Intersection(int[] nums1, int[] nums2) {
+ if(nums1==null||nums1.Length==0||nums2==null||nums1.Length==0)
+ return new int[0]; //注意数组条件
+ HashSet one = Insert(nums1);
+ HashSet two = Insert(nums2);
+ one.IntersectWith(two);
+ return one.ToArray();
+ }
+ public HashSet Insert(int[] nums){
+ HashSet one = new HashSet();
+ foreach(int num in nums){
+ one.Add(num);
+ }
+ return one;
+ }
+```
## 相关题目
* 350.两个数组的交集 II
diff --git a/problems/0383.赎金信.md b/problems/0383.赎金信.md
index 5d9e8295..6d6efc55 100644
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@@ -361,5 +361,22 @@ impl Solution {
}
```
+C#：
+```csharp
+public bool CanConstruct(string ransomNote, string magazine) {
+ if(ransomNote.Length > magazine.Length) return false;
+ int[] letters = new int[26];
+ foreach(char c in magazine){
+ letters[c-'a']++;
+ }
+ foreach(char c in ransomNote){
+ letters[c-'a']--;
+ if(letters[c-'a']<0){
+ return false;
+ }
+ }
+ return true;
+ }
+```
-----------------------
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index a6cd413b..962fe7a5 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -318,5 +318,32 @@ impl Solution {
}
```
+C#：
+```csharp
+public int FourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
+ Dictionary dic = new Dictionary();
+ foreach(var i in nums1){
+ foreach(var j in nums2){
+ int sum = i + j;
+ if(dic.ContainsKey(sum)){
+ dic[sum]++;
+ }else{
+ dic.Add(sum, 1);
+ }
+
+ }
+ }
+ int res = 0;
+ foreach(var a in nums3){
+ foreach(var b in nums4){
+ int sum = a+b;
+ if(dic.TryGetValue(-sum, out var result)){
+ res += result;
+ }
+ }
+ }
+ return res;
+ }
+```
-----------------------
From ef8564a5930805ace91776c5648fa7110800c2d7 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 19:51:07 +0800
Subject: [PATCH 61/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200203.=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E5=85=83=E7=B4=A0.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0203.移除链表元素.md | 32 ++++++++++++++++++++++++++++-
1 file changed, 31 insertions(+), 1 deletion(-)
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index c34831b7..53230c0b 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -446,6 +446,36 @@ impl Solution {
}
}
```
-
+Scala:
+```scala
+/**
+ * Definition for singly-linked list.
+ * class ListNode(_x: Int = 0, _next: ListNode = null) {
+ * var next: ListNode = _next
+ * var x: Int = _x
+ * }
+ */
+object Solution {
+ def removeElements(head: ListNode, `val`: Int): ListNode = {
+ if (head == null) return head
+ var dummy = new ListNode(-1, head) // 定义虚拟头节点
+ var cur = head // cur 表示当前节点
+ var pre = dummy // pre 表示cur前一个节点
+ while (cur != null) {
+ if (cur.x == `val`) {
+ // 相等，就删除那么cur的前一个节点pre执行cur的下一个
+ pre.next = cur.next
+ } else {
+ // 不相等，pre就等于当前cur节点
+ pre = cur
+ }
+ // 向下迭代
+ cur = cur.next
+ }
+ // 最终返回dummy的下一个，就是链表的头
+ dummy.next
+ }
+}
+```
-----------------------
From 898016b8a98aa7eeb2445681e66f0302a79c28ae Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 21:13:42 +0800
Subject: [PATCH 62/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200707.=E8=AE=BE?=
=?UTF-8?q?=E8=AE=A1=E9=93=BE=E8=A1=A8.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0707.设计链表.md | 68 +++++++++++++++++++++++++++++++++++
1 file changed, 68 insertions(+)
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 37ce15ad..dcdb53f4 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -1154,7 +1154,75 @@ class MyLinkedList {
}
```
+Scala:
+```scala
+class ListNode(_x: Int = 0, _next: ListNode = null) {
+ var next: ListNode = _next
+ var x: Int = _x
+}
+class MyLinkedList() {
+
+ var size = 0 // 链表尺寸
+ var dummy: ListNode = new ListNode(0) // 虚拟头节点
+
+ // 获取第index个节点的值
+ def get(index: Int): Int = {
+ if (index < 0 || index >= size) {
+ return -1;
+ }
+ var cur = dummy
+ for (i <- 0 to index) {
+ cur = cur.next
+ }
+ cur.x // 返回cur的值
+ }
+
+ // 在链表最前面插入一个节点
+ def addAtHead(`val`: Int) {
+ addAtIndex(0, `val`)
+ }
+
+ // 在链表最后面插入一个节点
+ def addAtTail(`val`: Int) {
+ addAtIndex(size, `val`)
+ }
+
+ // 在第index个节点之前插入一个新节点
+ // 如果index等于链表长度，则说明新插入的节点是尾巴
+ // 如果index等于0，则说明新插入的节点是头
+ // 如果index>链表长度，则说明为空
+ def addAtIndex(index: Int, `val`: Int) {
+ if (index > size) {
+ return
+ }
+ var loc = index // 因为参数index是val不可变类型，所以需要赋值给一个可变类型
+ if (index < 0) {
+ loc = 0
+ }
+ size += 1 //链表尺寸+1
+ var pre = dummy
+ for (i <- 0 until loc) {
+ pre = pre.next
+ }
+ val node: ListNode = new ListNode(`val`, pre.next)
+ pre.next = node
+ }
+ // 删除第index个节点
+ def deleteAtIndex(index: Int) {
+ if (index < 0 || index >= size) {
+ return
+ }
+ size -= 1
+ var pre = dummy
+ for (i <- 0 until index) {
+ pre = pre.next
+ }
+ pre.next = pre.next.next
+ }
+
+}
+```
-----------------------
From 923ce563f1461876fbed667f8a79194ccb060096 Mon Sep 17 00:00:00 2001
From: yangtzech
Date: Wed, 11 May 2022 21:30:43 +0800
Subject: [PATCH 63/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=EF=BC=880102.?=
=?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D?=
=?UTF-8?q?=E5=8E=86.md=EF=BC=89=EF=BC=9A102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
=?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86=20=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0=20c++=20=E9=80=92=E5=BD=92=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..5f69f53d 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -82,6 +82,26 @@ public:
}
};
```
+```CPP
+# 递归法
+class Solution {
+public:
+ void order(TreeNode* cur, vector>& result, int depth)
+ {
+ if (cur == nullptr) return;
+ if (result.size() == depth) result.push_back(vector());
+ result[depth].push_back(cur->val);
+ order(cur->left, result, depth + 1);
+ order(cur->right, result, depth + 1);
+ }
+ vector> levelOrder(TreeNode* root) {
+ vector> result;
+ int depth = 0;
+ order(root, result, depth);
+ return result;
+ }
+};
+```
python3代码：
From 3606a624237334eddee98308e39daedbb2d250b0 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 23:03:42 +0800
Subject: [PATCH 64/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200206.=E7=BF=BB?=
=?UTF-8?q?=E8=BD=AC=E9=93=BE=E8=A1=A8.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0206.翻转链表.md | 34 ++++++++++++++++++++++++++++++++++
1 file changed, 34 insertions(+)
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 941928ba..25b16907 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -496,6 +496,40 @@ struct ListNode* reverseList(struct ListNode* head){
return reverse(NULL, head);
}
```
+Scala:
+双指针法：
+```scala
+object Solution {
+ def reverseList(head: ListNode): ListNode = {
+ var pre: ListNode = null
+ var cur = head
+ while (cur != null) {
+ var tmp = cur.next
+ cur.next = pre
+ pre = cur
+ cur = tmp
+ }
+ pre
+ }
+}
+```
+递归法：
+```scala
+object Solution {
+ def reverseList(head: ListNode): ListNode = {
+ reverse(null, head)
+ }
+
+ def reverse(pre: ListNode, cur: ListNode): ListNode = {
+ if (cur == null) {
+ return pre // 如果当前cur为空，则返回pre
+ }
+ val tmp: ListNode = cur.next
+ cur.next = pre
+ reverse(cur, tmp) // 此时cur成为前一个节点，tmp是当前节点
+ }
+}
+```
-----------------------
From 83086c903d77496e6fa34e7e4b0069e27ad1210c Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 10:13:00 +0800
Subject: [PATCH 65/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200024.=E4=B8=A4?=
=?UTF-8?q?=E4=B8=A4=E4=BA=A4=E6=8D=A2=E9=93=BE=E8=A1=A8=E4=B8=AD=E7=9A=84?=
=?UTF-8?q?=E8=8A=82=E7=82=B9.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0024.两两交换链表中的节点.md | 24 ++++++++++++++++++-
1 file changed, 23 insertions(+), 1 deletion(-)
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index ce75e0d7..2289c229 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -311,7 +311,29 @@ func swapPairs(_ head: ListNode?) -> ListNode? {
return dummyHead.next
}
```
-
+Scala:
+```scala
+// 虚拟头节点
+object Solution {
+ def swapPairs(head: ListNode): ListNode = {
+ var dummy = new ListNode(0, head) // 虚拟头节点
+ var pre = dummy
+ var cur = head
+ // 当pre的下一个和下下个都不为空，才进行两两转换
+ while (pre.next != null && pre.next.next != null) {
+ var tmp: ListNode = cur.next.next // 缓存下一次要进行转换的第一个节点
+ pre.next = cur.next // 步骤一
+ cur.next.next = cur // 步骤二
+ cur.next = tmp // 步骤三
+ // 下面是准备下一轮的交换
+ pre = cur
+ cur = tmp
+ }
+ // 最终返回dummy虚拟头节点的下一个，return可以省略
+ dummy.next
+ }
+}
+```
-----------------------
From 5fd85215ea9c30c73e5ab84f41dbc9cf170e8617 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 10:53:20 +0800
Subject: [PATCH 66/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200019.=E5=88=A0?=
=?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=AC?=
=?UTF-8?q?N=E4=B8=AA=E8=8A=82=E7=82=B9.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...0019.删除链表的倒数第N个节点.md | 24 ++++++++++++++++++-
1 file changed, 23 insertions(+), 1 deletion(-)
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 813e9b02..8df65627 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -289,6 +289,28 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
return dummyHead.next
}
```
-
+Scala:
+```scala
+object Solution {
+ def removeNthFromEnd(head: ListNode, n: Int): ListNode = {
+ val dummy = new ListNode(-1, head) // 定义虚拟头节点
+ var fast = head // 快指针从头开始走
+ var slow = dummy // 慢指针从虚拟头开始头
+ // 因为参数 n 是不可变量，所以不能使用 while(n>0){n-=1}的方式
+ for (i <- 0 until n) {
+ fast = fast.next
+ }
+ // 快指针和满指针一起走，直到fast走到null
+ while (fast != null) {
+ slow = slow.next
+ fast = fast.next
+ }
+ // 删除slow的下一个节点
+ slow.next = slow.next.next
+ // 返回虚拟头节点的下一个
+ dummy.next
+ }
+}
+```
-----------------------
From 6992735d8de6d1875d0565413faed410e81c822e Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 12:46:47 +0800
Subject: [PATCH 67/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E9=9D=A2=E8=AF=95?=
=?UTF-8?q?=E9=A2=9802.07.=E9=93=BE=E8=A1=A8=E7=9B=B8=E4=BA=A4.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/面试题02.07.链表相交.md | 50 ++++++++++++++++++++++++-
1 file changed, 49 insertions(+), 1 deletion(-)
diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index 2e7226de..0a38cc33 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -317,7 +317,55 @@ ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
}
```
-
+Scala:
+```scala
+object Solution {
+ def getIntersectionNode(headA: ListNode, headB: ListNode): ListNode = {
+ var lenA = 0 // headA链表的长度
+ var lenB = 0 // headB链表的长度
+ var tmp = headA // 临时变量
+ // 统计headA的长度
+ while (tmp != null) {
+ lenA += 1;
+ tmp = tmp.next
+ }
+ // 统计headB的长度
+ tmp = headB // 临时变量赋值给headB
+ while (tmp != null) {
+ lenB += 1
+ tmp = tmp.next
+ }
+ // 因为传递过来的参数是不可变量，所以需要重新定义
+ var listA = headA
+ var listB = headB
+ // 两个链表的长度差
+ // 如果gap>0，lenA>lenB，headA(listA)链表往前移动gap步
+ // 如果gap<0，lenA 0) {
+ // 因为不可以i-=1，所以可以使用for
+ for (i <- 0 until gap) {
+ listA = listA.next // 链表headA(listA) 移动
+ }
+ } else {
+ gap = math.abs(gap) // 此刻gap为负值，取绝对值
+ for (i <- 0 until gap) {
+ listB = listB.next
+ }
+ }
+ // 现在两个链表同时往前走，如果相等则返回
+ while (listA != null && listB != null) {
+ if (listA == listB) {
+ return listA
+ }
+ listA = listA.next
+ listB = listB.next
+ }
+ // 如果链表没有相交则返回null，return可以省略
+ null
+ }
+}
+```
-----------------------
From 2ce58ac6756775f8ec5139b36a23e8f3de232d30 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 12:55:14 +0800
Subject: [PATCH 68/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880337.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8DIII.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0337.打家劫舍III.md | 43 ++++++++++++++++++++++++++++++++
1 file changed, 43 insertions(+)
diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
index a4d8f6b2..6f50723d 100644
--- a/problems/0337.打家劫舍III.md
+++ b/problems/0337.打家劫舍III.md
@@ -429,7 +429,50 @@ const rob = root => {
};
```
+### TypeScript
+
+> 记忆化后序遍历
+
+```typescript
+const memory: Map = new Map();
+function rob(root: TreeNode | null): number {
+ if (root === null) return 0;
+ if (memory.has(root)) return memory.get(root);
+ // 不取当前节点
+ const res1: number = rob(root.left) + rob(root.right);
+ // 取当前节点
+ let res2: number = root.val;
+ if (root.left !== null) res2 += rob(root.left.left) + rob(root.left.right);
+ if (root.right !== null) res2 += rob(root.right.left) + rob(root.right.right);
+ const res: number = Math.max(res1, res2);
+ memory.set(root, res);
+ return res;
+};
+```
+
+> 状态标记化后序遍历
+
+```typescript
+function rob(root: TreeNode | null): number {
+ return Math.max(...robNode(root));
+};
+// [0]-不偷当前节点能获得的最大金额; [1]-偷~~
+type MaxValueArr = [number, number];
+function robNode(node: TreeNode | null): MaxValueArr {
+ if (node === null) return [0, 0];
+ const leftArr: MaxValueArr = robNode(node.left);
+ const rightArr: MaxValueArr = robNode(node.right);
+ // 不偷
+ const val1: number = Math.max(leftArr[0], leftArr[1]) +
+ Math.max(rightArr[0], rightArr[1]);
+ // 偷
+ const val2: number = leftArr[0] + rightArr[0] + node.val;
+ return [val1, val2];
+}
+```
+
### Go
+
```go
// 打家劫舍Ⅲ 动态规划
// 时间复杂度O(n) 空间复杂度O(logn)
From 5627d4ba8605f35b8d63cf4af363c64d721f69a3 Mon Sep 17 00:00:00 2001
From: Jamcy123 <1219502823@qq.com>
Date: Thu, 12 May 2022 16:04:42 +0800
Subject: [PATCH 69/91] =?UTF-8?q?=E8=83=8C=E5=8C=85=E7=90=86=E8=AE=BA?=
=?UTF-8?q?=E5=9F=BA=E7=A1=8001=E8=83=8C=E5=8C=85-1=20js=20=E7=89=88?=
=?UTF-8?q?=E6=9C=AC=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-1.md | 51 +++++++++---------------
1 file changed, 19 insertions(+), 32 deletions(-)
diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md
index fe940b4c..e833ea80 100644
--- a/problems/背包理论基础01背包-1.md
+++ b/problems/背包理论基础01背包-1.md
@@ -380,44 +380,31 @@ func main() {
### javascript
```js
-function testweightbagproblem (wight, value, size) {
- const len = wight.length,
- dp = array.from({length: len + 1}).map(
- () => array(size + 1).fill(0)
- );
-
- for(let i = 1; i <= len; i++) {
- for(let j = 0; j <= size; j++) {
- if(wight[i - 1] <= j) {
- dp[i][j] = math.max(
- dp[i - 1][j],
- value[i - 1] + dp[i - 1][j - wight[i - 1]]
- )
- } else {
- dp[i][j] = dp[i - 1][j];
- }
+function testWeightBagProblem (weight, value, size) {
+ // 定义 dp 数组
+ const len = weight.length,
+ dp = Array(len).fill().map(() => Array(size + 1).fill(0));
+
+ // 初始化
+ for(let j = weight[0]; j <= size; j++) {
+ dp[0][j] = value[0];
}
- }
-// console.table(dp);
-
- return dp[len][size];
-}
-
-function testWeightBagProblem2 (wight, value, size) {
- const len = wight.length,
- dp = Array(size + 1).fill(0);
- for(let i = 1; i <= len; i++) {
- for(let j = size; j >= wight[i - 1]; j--) {
- dp[j] = Math.max(dp[j], value[i - 1] + dp[j - wight[i - 1]]);
+ // weight 数组的长度len 就是物品个数
+ for(let i = 1; i < len; i++) { // 遍历物品
+ for(let j = 0; j <= size; j++) { // 遍历背包容量
+ if(j < weight[i]) dp[i][j] = dp[i - 1][j];
+ else dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
+ }
}
- }
- return dp[size];
-}
+ console.table(dp)
+
+ return dp[len - 1][size];
+}
function test () {
- console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
+ console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
}
test();
From 40457f0f44d3981dc071fd56871f66d7e5946af1 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 16:16:48 +0800
Subject: [PATCH 70/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880121.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0121.买卖股票的最佳时机.md | 40 ++++++++++++++++++++
1 file changed, 40 insertions(+)
diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
index f0bc3b97..a2498bb6 100644
--- a/problems/0121.买卖股票的最佳时机.md
+++ b/problems/0121.买卖股票的最佳时机.md
@@ -426,6 +426,46 @@ var maxProfit = function(prices) {
};
```
+TypeScript：
+
+> 贪心法
+
+```typescript
+function maxProfit(prices: number[]): number {
+ if (prices.length === 0) return 0;
+ let buy: number = prices[0];
+ let profitMax: number = 0;
+ for (let i = 1, length = prices.length; i < length; i++) {
+ profitMax = Math.max(profitMax, prices[i] - buy);
+ buy = Math.min(prices[i], buy);
+ }
+ return profitMax;
+};
+```
+
+> 动态规划
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 第i天持有股票的最大现金
+ dp[i][1]: 第i天不持有股票的最大现金
+ */
+ const length = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = [];
+ dp[0] = [-prices[0], 0];
+ for (let i = 1; i < length; i++) {
+ dp[i] = [];
+ dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
+ }
+ return dp[length - 1][1];
+};
+```
+
+
+
-----------------------
From 8ba775d04acd100e6cdac8ebd913aaead67fae15 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 16:40:54 +0800
Subject: [PATCH 71/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880122.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAII=E5=8A=A8=E6=80=81=E8=A7=84=E5=88=92.md=EF=BC=89?=
=?UTF-8?q?=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...票的最佳时机II（动态规划）.md | 36 +++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
index 5a165a14..12b21fde 100644
--- a/problems/0122.买卖股票的最佳时机II（动态规划）.md
+++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -295,6 +295,42 @@ const maxProfit = (prices) => {
}
```
+TypeScript：
+
+> 动态规划
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 第i天持有股票
+ dp[i][1]: 第i天不持有股票
+ */
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0] = [-prices[0], 0];
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
+ }
+ return dp[length - 1][1];
+};
+```
+
+> 贪心法
+
+```typescript
+function maxProfit(prices: number[]): number {
+ let resProfit: number = 0;
+ for (let i = 1, length = prices.length; i < length; i++) {
+ if (prices[i] > prices[i - 1]) {
+ resProfit += prices[i] - prices[i - 1];
+ }
+ }
+ return resProfit;
+};
+```
+
-----------------------
From 0a58ef986de4c20c5d69a4b490b478f44b7f3f5c Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 17:35:30 +0800
Subject: [PATCH 72/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200142.=E7=8E=AF?=
=?UTF-8?q?=E5=BD=A2=E9=93=BE=E8=A1=A8II.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0142.环形链表II.md | 26 +++++++++++++++++++++++++-
1 file changed, 25 insertions(+), 1 deletion(-)
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index e8ca950d..f8e62d45 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -370,7 +370,31 @@ ListNode *detectCycle(ListNode *head) {
}
```
-
+Scala:
+```scala
+object Solution {
+ def detectCycle(head: ListNode): ListNode = {
+ var fast = head // 快指针
+ var slow = head // 慢指针
+ while (fast != null && fast.next != null) {
+ fast = fast.next.next // 快指针一次走两步
+ slow = slow.next // 慢指针一次走一步
+ // 如果相遇，fast快指针回到头
+ if (fast == slow) {
+ fast = head
+ // 两个指针一步一步的走，第一次相遇的节点必是入环节点
+ while (fast != slow) {
+ fast = fast.next
+ slow = slow.next
+ }
+ return fast
+ }
+ }
+ // 如果fast指向空值，必然无环返回null
+ null
+ }
+}
+```
-----------------------
From a25409d7ec351aaf2e6e513e3e091fc97cd17d60 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 19:16:20 +0800
Subject: [PATCH 73/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200242.=E6=9C=89?=
=?UTF-8?q?=E6=95=88=E7=9A=84=E5=AD=97=E6=AF=8D=E5=BC=82=E4=BD=8D=E8=AF=8D?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0242.有效的字母异位词.md | 25 +++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 080166fd..4f0d143e 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -307,6 +307,31 @@ impl Solution {
}
}
```
+
+Scala:
+```scala
+object Solution {
+ def isAnagram(s: String, t: String): Boolean = {
+ // 如果两个字符串的长度不等，直接返回false
+ if (s.length != t.length) return false
+ val record = new Array[Int](26) // 记录每个单词出现了多少次
+ // 遍历字符串，对于s字符串单词对应的记录+=1，t字符串对应的记录-=1
+ for (i <- 0 until s.length) {
+ record(s(i) - 97) += 1
+ record(t(i) - 97) -= 1
+ }
+ // 如果不等于则直接返回false
+ for (i <- 0 until 26) {
+ if (record(i) != 0) {
+ return false
+ }
+ }
+ // 如果前面不返回false，说明匹配成功，返回true，return可以省略
+ true
+ }
+}
+```
+
## 相关题目
* 383.赎金信
From 74b76bfd120446653495d96135e697b5797bae35 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 22:21:29 +0800
Subject: [PATCH 74/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=201002.=E6=9F=A5?=
=?UTF-8?q?=E6=89=BE=E5=B8=B8=E7=94=A8=E5=AD=97=E7=AC=A6.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/1002.查找常用字符.md | 34 ++++++++++++++++++++++++++++-
1 file changed, 33 insertions(+), 1 deletion(-)
diff --git a/problems/1002.查找常用字符.md b/problems/1002.查找常用字符.md
index 36937b0b..075b5ef1 100644
--- a/problems/1002.查找常用字符.md
+++ b/problems/1002.查找常用字符.md
@@ -418,6 +418,38 @@ char ** commonChars(char ** words, int wordsSize, int* returnSize){
return ret;
}
```
-
+Scala:
+```scala
+object Solution {
+ def commonChars(words: Array[String]): List[String] = {
+ // 声明返回结果的不可变List集合，因为res要重新赋值，所以声明为var
+ var res = List[String]()
+ var hash = new Array[Int](26) // 统计字符出现的最小频率
+ // 统计第一个字符串中字符出现的次数
+ for (i <- 0 until words(0).length) {
+ hash(words(0)(i) - 'a') += 1
+ }
+ // 统计其他字符串出现的频率
+ for (i <- 1 until words.length) {
+ // 统计其他字符出现的频率
+ var hashOtherStr = new Array[Int](26)
+ for (j <- 0 until words(i).length) {
+ hashOtherStr(words(i)(j) - 'a') += 1
+ }
+ // 更新hash，取26个字母最小出现的频率
+ for (k <- 0 until 26) {
+ hash(k) = math.min(hash(k), hashOtherStr(k))
+ }
+ }
+ // 根据hash的结果转换输出的形式
+ for (i <- 0 until 26) {
+ for (j <- 0 until hash(i)) {
+ res = res :+ (i + 'a').toChar.toString
+ }
+ }
+ res
+ }
+}
+```
-----------------------
From a71f7d2127bae83cc42dffd20b4c460865006d15 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 23:23:59 +0800
Subject: [PATCH 75/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880123.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAIII.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0123.买卖股票的最佳时机III.md | 30 +++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md
index 56ade343..67c99497 100644
--- a/problems/0123.买卖股票的最佳时机III.md
+++ b/problems/0123.买卖股票的最佳时机III.md
@@ -352,6 +352,36 @@ const maxProfit = prices => {
};
```
+TypeScript：
+
+> 版本一
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 无操作;
+ dp[i][1]: 第一次买入；
+ dp[i][2]: 第一次卖出；
+ dp[i][3]: 第二次买入；
+ dp[i][4]: 第二次卖出；
+ */
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0)
+ .map(_ => new Array(5).fill(0));
+ dp[0][1] = -prices[0];
+ dp[0][3] = -prices[0];
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = dp[i - 1][0];
+ dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
+ dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
+ dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
+ dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
+ }
+ return Math.max(dp[length - 1][2], dp[length - 1][4]);
+};
+```
+
Go:
> 版本一：
From 78c6602ff20c309132007795956f332d66ff7130 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 10:05:27 +0800
Subject: [PATCH 76/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200349.=E4=B8=A4?=
=?UTF-8?q?=E4=B8=AA=E6=95=B0=E7=BB=84=E7=9A=84=E4=BA=A4=E9=9B=86.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0349.两个数组的交集.md | 42 ++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 45f19b6e..49cf4112 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -312,7 +312,49 @@ int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* re
return result;
}
```
+Scala:
+正常解法:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // 导入mutable
+ import scala.collection.mutable
+ // 临时Set，用于记录数组1出现的每个元素
+ val tmpSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ // 结果Set，存储最终结果
+ val resSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ // 遍历nums1，把每个元素添加到tmpSet
+ nums1.foreach(tmpSet.add(_))
+ // 遍历nums2，如果在tmpSet存在就添加到resSet
+ nums2.foreach(elem => {
+ if (tmpSet.contains(elem)) {
+ resSet.add(elem)
+ }
+ })
+ // 将结果转换为Array返回，return可以省略
+ resSet.toArray
+ }
+}
+```
+骚操作1:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // 先转为Set，然后取交集，最后转换为Array
+ (nums1.toSet).intersect(nums2.toSet).toArray
+ }
+}
+```
+骚操作2:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // distinct去重，然后取交集
+ (nums1.distinct).intersect(nums2.distinct)
+ }
+}
+```
## 相关题目
* 350.两个数组的交集 II
From 9f720470e8e2360047052897885261545d0e1ac7 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 10:29:17 +0800
Subject: [PATCH 77/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200202.=E5=BF=AB?=
=?UTF-8?q?=E4=B9=90=E6=95=B0.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0202.快乐数.md | 33 +++++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 741a735a..2d0f7d27 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -385,5 +385,38 @@ bool isHappy(int n){
return bHappy;
}
```
+Scala:
+```scala
+object Solution {
+ // 引入mutable
+ import scala.collection.mutable
+ def isHappy(n: Int): Boolean = {
+ // 存放每次计算后的结果
+ val set: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ var tmp = n // 因为形参是不可变量，所以需要找到一个临时变量
+ // 开始进入循环
+ while (true) {
+ val sum = getSum(tmp) // 获取这个数每个值的平方和
+ if (sum == 1) return true // 如果最终等于 1，则返回true
+ // 如果set里面已经有这个值了，说明进入无限循环，可以返回false，否则添加这个值到set
+ if (set.contains(sum)) return false
+ else set.add(sum)
+ tmp = sum
+ }
+ // 最终需要返回值，直接返回个false
+ false
+ }
+
+ def getSum(n: Int): Int = {
+ var sum = 0
+ var tmp = n
+ while (tmp != 0) {
+ sum += (tmp % 10) * (tmp % 10)
+ tmp = tmp / 10
+ }
+ sum
+ }
+}
+```
-----------------------
From be5cc136c56cb194af8ce1d794871ca7af4b1e1d Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:00:11 +0800
Subject: [PATCH 78/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200035.=E6=90=9C?=
=?UTF-8?q?=E7=B4=A2=E6=8F=92=E5=85=A5=E4=BD=8D=E7=BD=AE.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0035.搜索插入位置.md | 21 ++++++++++++++++++++-
1 file changed, 20 insertions(+), 1 deletion(-)
diff --git a/problems/0035.搜索插入位置.md b/problems/0035.搜索插入位置.md
index 9a770703..3e8cf5c8 100644
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@@ -316,7 +316,26 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
return right + 1
}
```
-
+### Scala
+```scala
+object Solution {
+ def searchInsert(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (target == nums(mid)) {
+ return mid
+ } else if (target > nums(mid)) {
+ left = mid + 1
+ } else {
+ right = mid - 1
+ }
+ }
+ right + 1
+ }
+}
+```
From 95593634b341a951850fae3b5aa739ba7c5d3864 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:01:04 +0800
Subject: [PATCH 79/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200704.=E4=BA=8C?=
=?UTF-8?q?=E5=88=86=E6=9F=A5=E6=89=BE.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0704.二分查找.md | 41 +++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 55625130..1e474f9a 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -610,7 +610,48 @@ public class Solution{
}
}
```
+**Scala:**
+（版本一）左闭右闭区间
+```scala
+object Solution {
+ def search(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + ((right - left) / 2)
+ if (target == nums(mid)) {
+ return mid
+ } else if (target < nums(mid)) {
+ right = mid - 1
+ } else {
+ left = mid + 1
+ }
+ }
+ -1
+ }
+}
+```
+（版本二）左闭右开区间
+```scala
+object Solution {
+ def search(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length
+ while (left < right) {
+ val mid = left + (right - left) / 2
+ if (target == nums(mid)) {
+ return mid
+ } else if (target < nums(mid)) {
+ right = mid
+ } else {
+ left = mid + 1
+ }
+ }
+ -1
+ }
+}
+```
-----------------------
From 9fc232aba413b43fd479ad5b4fd1a186ff90a359 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:01:45 +0800
Subject: [PATCH 80/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200034.=E5=9C=A8?=
=?UTF-8?q?=E6=8E=92=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD=E6=9F=A5=E6=89=BE?=
=?UTF-8?q?=E5=85=83=E7=B4=A0=E7=9A=84=E7=AC=AC=E4=B8=80=E4=B8=AA=E5=92=8C?=
=?UTF-8?q?=E6=9C=80=E5=90=8E=E4=B8=80=E4=B8=AA=E4=BD=8D=E7=BD=AE.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...元素的第一个和最后一个位置.md | 45 +++++++++++++++++++
1 file changed, 45 insertions(+)
diff --git a/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md b/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
index dfd90b82..260462c2 100644
--- a/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
+++ b/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
@@ -480,7 +480,52 @@ var searchRange = function(nums, target) {
return [-1, -1];
};
```
+### Scala
+```scala
+object Solution {
+ def searchRange(nums: Array[Int], target: Int): Array[Int] = {
+ var left = getLeftBorder(nums, target)
+ var right = getRightBorder(nums, target)
+ if (left == -2 || right == -2) return Array(-1, -1)
+ if (right - left > 1) return Array(left + 1, right - 1)
+ Array(-1, -1)
+ }
+ // 寻找左边界
+ def getLeftBorder(nums: Array[Int], target: Int): Int = {
+ var leftBorder = -2
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (nums(mid) >= target) {
+ right = mid - 1
+ leftBorder = right
+ } else {
+ left = mid + 1
+ }
+ }
+ leftBorder
+ }
+
+ // 寻找右边界
+ def getRightBorder(nums: Array[Int], target: Int): Int = {
+ var rightBorder = -2
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (nums(mid) <= target) {
+ left = mid + 1
+ rightBorder = left
+ } else {
+ right = mid - 1
+ }
+ }
+ rightBorder
+ }
+}
+```
-----------------------
From f131f27744693b91f40df4ea0fb7c1578bd6647b Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:02:19 +0800
Subject: [PATCH 81/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200027.=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E5=85=83=E7=B4=A0.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0027.移除元素.md | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..5ff327fb 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -328,6 +328,20 @@ int removeElement(int* nums, int numsSize, int val){
return slow;
}
```
-
+Scala:
+```scala
+object Solution {
+ def removeElement(nums: Array[Int], `val`: Int): Int = {
+ var slow = 0
+ for (fast <- 0 until nums.length) {
+ if (`val` != nums(fast)) {
+ nums(slow) = nums(fast)
+ slow += 1
+ }
+ }
+ slow
+ }
+}
+```
-----------------------
From 495998e509527b53a8b84cc0527dfcff4fc1e1af Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 13 May 2022 12:07:52 +0800
Subject: [PATCH 82/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880188.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAIV.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0188.买卖股票的最佳时机IV.md | 22 +++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md
index 61c558a1..27eb38c3 100644
--- a/problems/0188.买卖股票的最佳时机IV.md
+++ b/problems/0188.买卖股票的最佳时机IV.md
@@ -409,5 +409,27 @@ var maxProfit = function(k, prices) {
};
```
+TypeScript：
+
+```typescript
+function maxProfit(k: number, prices: number[]): number {
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0)
+ .map(_ => new Array(k * 2 + 1).fill(0));
+ for (let i = 1; i <= k; i++) {
+ dp[0][i * 2 - 1] = -prices[0];
+ }
+ for (let i = 1; i < length; i++) {
+ for (let j = 1; j < 2 * k + 1; j++) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] + Math.pow(-1, j) * prices[i]);
+ }
+ }
+ return dp[length - 1][2 * k];
+};
+```
+
+
+
-----------------------
From 127986e03a0b4acdedf80a6b38d3ded7d61514f3 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 13 May 2022 16:19:59 +0800
Subject: [PATCH 83/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880309.=E6=9C=80?=
=?UTF-8?q?=E4=BD=B3=E4=B9=B0=E5=8D=96=E8=82=A1=E7=A5=A8=E6=97=B6=E6=9C=BA?=
=?UTF-8?q?=E5=90=AB=E5=86=B7=E5=86=BB=E6=9C=9F.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...09.最佳买卖股票时机含冷冻期.md | 60 +++++++++++++++++++
1 file changed, 60 insertions(+)
diff --git a/problems/0309.最佳买卖股票时机含冷冻期.md b/problems/0309.最佳买卖股票时机含冷冻期.md
index f3e7541b..f037fe85 100644
--- a/problems/0309.最佳买卖股票时机含冷冻期.md
+++ b/problems/0309.最佳买卖股票时机含冷冻期.md
@@ -325,6 +325,66 @@ const maxProfit = (prices) => {
};
```
+TypeScript：
+
+> 版本一，与本文思路一致
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 持股状态；
+ dp[i][1]: 无股状态，当天为非冷冻期；
+ dp[i][2]: 无股状态，当天卖出；
+ dp[i][3]: 无股状态，当天为冷冻期；
+ */
+ const length: number = prices.length;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0][0] = -prices[0];
+ dp[0][1] = dp[0][2] = dp[0][3] = 0;
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = Math.max(
+ dp[i - 1][0],
+ Math.max(dp[i - 1][1], dp[i - 1][3]) - prices[i]
+ );
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][3]);
+ dp[i][2] = dp[i - 1][0] + prices[i];
+ dp[i][3] = dp[i - 1][2];
+ }
+ const lastEl: number[] = dp[length - 1];
+ return Math.max(lastEl[1], lastEl[2], lastEl[3]);
+};
+```
+
+> 版本二，状态定义略有不同，可以帮助理解
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 持股状态，当天买入；
+ dp[i][1]: 持股状态，当天未买入；
+ dp[i][2]: 无股状态，当天卖出；
+ dp[i][3]: 无股状态，当天未卖出；
+
+ 买入有冷冻期限制，其实就是状态[0]只能由前一天的状态[3]得到；
+ 如果卖出有冷冻期限制，其实就是[2]由[1]得到。
+ */
+ const length: number = prices.length;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0][0] = -prices[0];
+ dp[0][1] = -Infinity;
+ dp[0][2] = dp[0][3] = 0;
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = dp[i - 1][3] - prices[i];
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0]);
+ dp[i][2] = Math.max(dp[i - 1][0], dp[i - 1][1]) + prices[i];
+ dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2]);
+ }
+ return Math.max(dp[length - 1][2], dp[length - 1][3]);
+};
+```
+
+
+
-----------------------
From 6c0d4365c6ed1e9a47c5f31e14d59912648f4afa Mon Sep 17 00:00:00 2001
From: lizhendong128
Date: Fri, 13 May 2022 17:26:03 +0800
Subject: [PATCH 84/91] =?UTF-8?q?=E4=BF=AE=E6=94=B90059=E8=9E=BA=E6=97=8B?=
=?UTF-8?q?=E7=9F=A9=E9=98=B5II=20Java=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
精简Java代码中不必要的变量，调整结构，减少代码量，使代码更加易读
---
problems/0059.螺旋矩阵II.md | 44 +++++++++------------------------
1 file changed, 12 insertions(+), 32 deletions(-)
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index 93735895..7afc1575 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -130,57 +130,37 @@ Java：
```Java
class Solution {
public int[][] generateMatrix(int n) {
+ int loop = 0; // 控制循环次数
int[][] res = new int[n][n];
+ int start = 0; // 每次循环的开始点(start, start)
+ int count = 1; // 定义填充数字
+ int i, j;
- // 循环次数
- int loop = n / 2;
-
- // 定义每次循环起始位置
- int startX = 0;
- int startY = 0;
-
- // 定义偏移量
- int offset = 1;
-
- // 定义填充数字
- int count = 1;
-
- // 定义中间位置
- int mid = n / 2;
- while (loop > 0) {
- int i = startX;
- int j = startY;
-
+ while (loop++ < n / 2) { // 判断边界后，loop从1开始
// 模拟上侧从左到右
- for (; j startY; j--) {
+ for (; j >= loop; j--) {
res[i][j] = count++;
}
// 模拟左侧从下到上
- for (; i > startX; i--) {
+ for (; i >= loop; i--) {
res[i][j] = count++;
}
-
- loop--;
-
- startX += 1;
- startY += 1;
-
- offset += 2;
+ start++;
}
if (n % 2 == 1) {
- res[mid][mid] = count;
+ res[start][start] = count;
}
return res;
From 5da6c06ef9fd308e9ab77b8393e81377eec75821 Mon Sep 17 00:00:00 2001
From: unknown
Date: Sat, 14 May 2022 16:27:47 +0100
Subject: [PATCH 85/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E8=83=8C=E5=8C=85?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E8=82=8C=E9=86=8701=E8=83=8C=E5=8C=85=20C?=
=?UTF-8?q?=E8=AF=AD=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-1.md | 46 ++++++++++++++++++++++++
1 file changed, 46 insertions(+)
diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md
index fe940b4c..43ad26be 100644
--- a/problems/背包理论基础01背包-1.md
+++ b/problems/背包理论基础01背包-1.md
@@ -423,5 +423,51 @@ function test () {
test();
```
+### C
+```c
+#include
+#include
+#include
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define ARR_SIZE(a) (sizeof((a)) / sizeof((a)[0]))
+#define BAG_WEIGHT 4
+
+void backPack(int* weights, int weightSize, int* costs, int costSize, int bagWeight) {
+ // 开辟dp数组
+ int dp[weightSize][bagWeight + 1];
+ memset(dp, 0, sizeof(int) * weightSize * (bagWeight + 1));
+
+ int i, j;
+ // 当背包容量大于物品0的重量时，将物品0放入到背包中
+ for(j = weights[0]; j <= bagWeight; ++j) {
+ dp[0][j] = costs[0];
+ }
+
+ // 先遍历物品，再遍历重量
+ for(j = 1; j <= bagWeight; ++j) {
+ for(i = 1; i < weightSize; ++i) {
+ // 如果当前背包容量小于物品重量
+ if(j < weights[i])
+ // 背包物品的价值等于背包不放置当前物品时的价值
+ dp[i][j] = dp[i-1][j];
+ // 若背包当前重量可以放置物品
+ else
+ // 背包的价值等于放置该物品或不放置该物品的最大值
+ dp[i][j] = MAX(dp[i - 1][j], dp[i - 1][j - weights[i]] + costs[i]);
+ }
+ }
+
+ printf("%d\n", dp[weightSize - 1][bagWeight]);
+}
+
+int main(int argc, char* argv[]) {
+ int weights[] = {1, 3, 4};
+ int costs[] = {15, 20, 30};
+ backPack(weights, ARR_SIZE(weights), costs, ARR_SIZE(costs), BAG_WEIGHT);
+ return 0;
+}
+```
+
-----------------------
From a5db99363b1bca72345036228776a0320242c8c4 Mon Sep 17 00:00:00 2001
From: SevenMonths
Date: Sun, 15 May 2022 15:35:08 +0800
Subject: [PATCH 86/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880035.=E6=90=9C?=
=?UTF-8?q?=E7=B4=A2=E6=8F=92=E5=85=A5=E4=BD=8D=E7=BD=AE.md=EF=BC=89?=
=?UTF-8?q?=EF=BC=9A=E5=A2=9E=E5=8A=A0PHP=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0035.搜索插入位置.md | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0035.搜索插入位置.md b/problems/0035.搜索插入位置.md
index 9a770703..8a8f9706 100644
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@@ -318,6 +318,31 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
```
+### PHP
+
+```php
+// 二分法(1)：[左闭右闭]
+function searchInsert($nums, $target)
+{
+ $n = count($nums);
+ $l = 0;
+ $r = $n - 1;
+ while ($l <= $r) {
+ $mid = floor(($l + $r) / 2);
+ if ($nums[$mid] > $target) {
+ // 下次搜索在左区间：[$l,$mid-1]
+ $r = $mid - 1;
+ } else if ($nums[$mid] < $target) {
+ // 下次搜索在右区间：[$mid+1,$r]
+ $l = $mid + 1;
+ } else {
+ // 命中返回
+ return $mid;
+ }
+ }
+ return $r + 1;
+}
+```
-----------------------
From aa22b802a5986f06a123c59f395bf49aba779d1a Mon Sep 17 00:00:00 2001
From: unknown
Date: Sun, 15 May 2022 14:39:41 +0100
Subject: [PATCH 87/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E8=83=8C=E5=8C=85?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=8001-2.mc=20C=E8=AF=AD?=
=?UTF-8?q?=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-2.md | 33 ++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index dabdfb2d..a99a872b 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -315,6 +315,39 @@ function test () {
test();
```
+### C
+```c
+#include
+#include
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define ARR_SIZE(arr) ((sizeof((arr))) / sizeof((arr)[0]))
+#define BAG_WEIGHT 4
+
+void test_back_pack(int* weights, int weightSize, int* values, int valueSize, int bagWeight) {
+ int dp[bagWeight + 1];
+ memset(dp, 0, sizeof(int) * (bagWeight + 1));
+
+ int i, j;
+ // 先遍历物品
+ for(i = 0; i < weightSize; ++i) {
+ // 后遍历重量。从后向前遍历
+ for(j = bagWeight; j >= weights[i]; --j) {
+ dp[j] = MAX(dp[j], dp[j - weights[i]] + values[i]);
+ }
+ }
+
+ // 打印最优结果
+ printf("%d\n", dp[bagWeight]);
+}
+
+int main(int argc, char** argv) {
+ int weights[] = {1, 3, 4};
+ int values[] = {15, 20, 30};
+ test_back_pack(weights, ARR_SIZE(weights), values, ARR_SIZE(values), BAG_WEIGHT);
+ return 0;
+}
+```
-----------------------
From 19abe18019814af74ee51ba56e4e8ee6106b1253 Mon Sep 17 00:00:00 2001
From: unknown
Date: Sun, 15 May 2022 15:26:23 +0100
Subject: [PATCH 88/91] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200416.=E5=88=86?=
=?UTF-8?q?=E5=89=B2=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md=20C=E8=AF=AD?=
=?UTF-8?q?=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0416.分割等和子集.md | 100 ++++++++++++++++++++++++++++
1 file changed, 100 insertions(+)
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index 6e93ae8e..76cfd87f 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -416,6 +416,106 @@ var canPartition = function(nums) {
};
```
+C:
+二维dp：
+```c
+/**
+1. dp数组含义：dp[i][j]为背包重量为j时，从[0-i]元素和最大值
+2. 递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i])
+3. 初始化：dp[i][0]初始化为0。因为背包重量为0时，不可能放入元素。dp[0][j] = nums[0]，当j >= nums[0] && j < target时
+4. 遍历顺序：先遍历物品，再遍历背包
+*/
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+int getSum(int* nums, int numsSize) {
+ int sum = 0;
+
+ int i;
+ for(i = 0; i < numsSize; ++i) {
+ sum += nums[i];
+ }
+ return sum;
+}
+
+bool canPartition(int* nums, int numsSize){
+ // 求出元素总和
+ int sum = getSum(nums, numsSize);
+ // 若元素总和为奇数，则不可能得到两个和相等的子数组
+ if(sum % 2)
+ return false;
+
+ // 若子数组的和等于target，则nums可以被分割
+ int target = sum / 2;
+ // 初始化dp数组
+ int dp[numsSize][target + 1];
+ // dp[j][0]都应被设置为0。因为当背包重量为0时，不可放入元素
+ memset(dp, 0, sizeof(int) * numsSize * (target + 1));
+
+ int i, j;
+ // 当背包重量j大于nums[0]时，可以在dp[0][j]中放入元素nums[0]
+ for(j = nums[0]; j <= target; ++j) {
+ dp[0][j] = nums[0];
+ }
+
+ for(i = 1; i < numsSize; ++i) {
+ for(j = 1; j <= target; ++j) {
+ // 若当前背包重量j小于nums[i]，则其值等于只考虑0到i-1物品时的值
+ if(j < nums[i])
+ dp[i][j] = dp[i - 1][j];
+ // 否则，背包重量等于在背包中放入num[i]/不放入nums[i]的较大值
+ else
+ dp[i][j] = MAX(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
+ }
+ }
+ // 判断背包重量为target，且考虑到所有物品时，放入的元素和是否等于target
+ return dp[numsSize - 1][target] == target;
+}
+```
+滚动数组：
+```c
+/**
+1. dp数组含义：dp[j]为背包重量为j时，其中可放入元素的最大值
+2. 递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
+3. 初始化：均初始化为0即可
+4. 遍历顺序：先遍历物品，再后序遍历背包
+*/
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+int getSum(int* nums, int numsSize) {
+ int sum = 0;
+
+ int i;
+ for(i = 0; i < numsSize; ++i) {
+ sum += nums[i];
+ }
+ return sum;
+}
+
+bool canPartition(int* nums, int numsSize){
+ // 求出元素总和
+ int sum = getSum(nums, numsSize);
+ // 若元素总和为奇数，则不可能得到两个和相等的子数组
+ if(sum % 2)
+ return false;
+ // 背包容量
+ int target = sum / 2;
+
+ // 初始化dp数组，元素均为0
+ int dp[target + 1];
+ memset(dp, 0, sizeof(int) * (target + 1));
+
+ int i, j;
+ // 先遍历物品，后遍历背包
+ for(i = 0; i < numsSize; ++i) {
+ for(j = target; j >= nums[i]; --j) {
+ dp[j] = MAX(dp[j], dp[j - nums[i]] + nums[i]);
+ }
+ }
+
+ // 查看背包容量为target时，元素总和是否等于target
+ return dp[target] == target;
+}
+```
From 83c2fd2454bbbbeda82725d2c38a2b577d7434c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=A8=8B=E5=BA=8F=E5=91=98Carl?=
Date: Wed, 18 May 2022 09:27:56 +0800
Subject: [PATCH 89/91] Update README.md
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 3d44ca69..01cab0b0 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@
-# LeetCode 刷题攻略1111
+# LeetCode 刷题攻略
## 刷题攻略的背景
From 0b88af0824b696be6d2f107adde3758f1df1c3f8 Mon Sep 17 00:00:00 2001
From: lizhendong128
Date: Thu, 19 May 2022 11:08:59 +0800
Subject: [PATCH 90/91] =?UTF-8?q?=E4=BF=AE=E6=94=B90150=E9=80=86=E6=B3=A2?=
=?UTF-8?q?=E5=85=B0=E8=A1=A8=E8=BE=BE=E5=BC=8F=E6=B1=82=E5=80=BC=20Java?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
将for循环改为for each，使代码更加简洁。因为循环除了对token进行遍历，i并没有其他用途。
---
problems/0150.逆波兰表达式求值.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index fd3d69aa..6ce7e2f9 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -136,19 +136,19 @@ java:
class Solution {
public int evalRPN(String[] tokens) {
Deque stack = new LinkedList();
- for (int i = 0; i < tokens.length; ++i) {
- if ("+".equals(tokens[i])) { // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
+ for (String s : tokens) {
+ if ("+".equals(s)) { // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
stack.push(stack.pop() + stack.pop()); // 注意 - 和/ 需要特殊处理
- } else if ("-".equals(tokens[i])) {
+ } else if ("-".equals(s)) {
stack.push(-stack.pop() + stack.pop());
- } else if ("*".equals(tokens[i])) {
+ } else if ("*".equals(s)) {
stack.push(stack.pop() * stack.pop());
- } else if ("/".equals(tokens[i])) {
+ } else if ("/".equals(s)) {
int temp1 = stack.pop();
int temp2 = stack.pop();
stack.push(temp2 / temp1);
} else {
- stack.push(Integer.valueOf(tokens[i]));
+ stack.push(Integer.valueOf(s));
}
}
return stack.pop();
From 278011c2df448c295985c0ba4f2ddc0843f4efd7 Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Sun, 22 May 2022 11:11:50 +0800
Subject: [PATCH 91/91] Update
---
problems/0056.合并区间.md | 4 +-
problems/0077.组合.md | 25 +++++------
problems/0101.对称二叉树.md | 4 +-
problems/0435.无重叠区间.md | 2 +-
.../0452.用最少数量的箭引爆气球.md | 4 +-
problems/面试题 02.07. 解法更新.md | 41 -------------------
6 files changed, 20 insertions(+), 60 deletions(-)
delete mode 100644 problems/面试题 02.07. 解法更新.md
diff --git a/problems/0056.合并区间.md b/problems/0056.合并区间.md
index a9caeaf0..0d002b46 100644
--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@@ -112,8 +112,8 @@ public:
};
```
-* 时间复杂度：$O(n\log n)$ ，有一个快排
-* 空间复杂度：$O(1)$，我没有算result数组（返回值所需容器占的空间）
+* 时间复杂度：O(nlog n) ，有一个快排
+* 空间复杂度：O(n)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间
## 总结
diff --git a/problems/0077.组合.md b/problems/0077.组合.md
index 4560c5b7..9e0398ab 100644
--- a/problems/0077.组合.md
+++ b/problems/0077.组合.md
@@ -27,7 +27,7 @@
也可以直接看我的B站视频：[带你学透回溯算法-组合问题（对应力扣题目：77.组合）](https://www.bilibili.com/video/BV1ti4y1L7cv#reply3733925949)
-# 思路
+## 思路
本题这是回溯法的经典题目。
@@ -232,7 +232,7 @@ void backtracking(参数) {
**对比一下本题的代码，是不是发现有点像！** 所以有了这个模板，就有解题的大体方向，不至于毫无头绪。
-# 总结
+## 总结
组合问题是回溯法解决的经典问题，我们开始的时候给大家列举一个很形象的例子，就是n为100，k为50的话，直接想法就需要50层for循环。
@@ -242,7 +242,7 @@ void backtracking(参数) {
接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。
-# 剪枝优化
+## 剪枝优化
我们说过，回溯法虽然是暴力搜索，但也有时候可以有点剪枝优化一下的。
@@ -324,7 +324,7 @@ public:
};
```
-# 剪枝总结
+## 剪枝总结
本篇我们准对求组合问题的回溯法代码做了剪枝优化，这个优化如果不画图的话，其实不好理解，也不好讲清楚。
@@ -334,10 +334,10 @@ public:
-# 其他语言版本
+## 其他语言版本
-## Java：
+### Java：
```java
class Solution {
List> result = new ArrayList<>();
@@ -366,6 +366,8 @@ class Solution {
}
```
+### Python
+
Python2:
```python
class Solution(object):
@@ -395,7 +397,6 @@ class Solution(object):
return result
```
-## Python
```python
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
@@ -432,7 +433,7 @@ class Solution:
```
-## javascript
+### javascript
剪枝：
```javascript
@@ -456,7 +457,7 @@ const combineHelper = (n, k, startIndex) => {
}
```
-## TypeScript
+### TypeScript
```typescript
function combine(n: number, k: number): number[][] {
@@ -479,7 +480,7 @@ function combine(n: number, k: number): number[][] {
-## Go
+### Go
```Go
var res [][]int
func combine(n int, k int) [][]int {
@@ -534,7 +535,7 @@ func backtrack(n,k,start int,track []int){
}
```
-## C
+### C
```c
int* path;
int pathTop;
@@ -642,7 +643,7 @@ int** combine(int n, int k, int* returnSize, int** returnColumnSizes){
}
```
-## Swift
+### Swift
```swift
func combine(_ n: Int, _ k: Int) -> [[Int]] {
diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index e4e232c8..1eb43589 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -238,7 +238,7 @@ public:
};
```
-# 总结
+## 总结
这次我们又深度剖析了一道二叉树的“简单题”，大家会发现，真正的把题目搞清楚其实并不简单，leetcode上accept了和真正掌握了还是有距离的。
@@ -248,7 +248,7 @@ public:
如果已经做过这道题目的同学，读完文章可以再去看看这道题目，思考一下，会有不一样的发现！
-# 相关题目推荐
+## 相关题目推荐
这两道题目基本和本题是一样的，只要稍加修改就可以AC。
diff --git a/problems/0435.无重叠区间.md b/problems/0435.无重叠区间.md
index b24ca024..32790a34 100644
--- a/problems/0435.无重叠区间.md
+++ b/problems/0435.无重叠区间.md
@@ -93,7 +93,7 @@ public:
};
```
* 时间复杂度：O(nlog n) ，有一个快排
-* 空间复杂度：O(1)
+* 空间复杂度：O(n)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间
大家此时会发现如此复杂的一个问题，代码实现却这么简单！
diff --git a/problems/0452.用最少数量的箭引爆气球.md b/problems/0452.用最少数量的箭引爆气球.md
index 33bbad55..327694ca 100644
--- a/problems/0452.用最少数量的箭引爆气球.md
+++ b/problems/0452.用最少数量的箭引爆气球.md
@@ -105,8 +105,8 @@ public:
};
```
-* 时间复杂度：$O(n\log n)$，因为有一个快排
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(nlog n)，因为有一个快排
+* 空间复杂度：O(1)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间
可以看出代码并不复杂。
diff --git a/problems/面试题 02.07. 解法更新.md b/problems/面试题 02.07. 解法更新.md
deleted file mode 100644
index 6115d02e..00000000
--- a/problems/面试题 02.07. 解法更新.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# 双指针，不计算链表长度
-设置指向headA和headB的指针pa、pb，分别遍历两个链表，每次循环同时更新pa和pb。
-* 当链表A遍历完之后，即pa为空时，将pa指向headB；
-* 当链表B遍历完之后，即pa为空时，将pb指向headA；
-* 当pa与pb相等时，即指向同一个节点，该节点即为相交起始节点。
-* 若链表不相交，则pa、pb同时为空时退出循环，即如果链表不相交，pa与pb在遍历过全部节点后同时指向结尾空节点，此时退出循环，返回空。
-# 证明思路
-设链表A不相交部分长度为a，链表B不相交部分长度为b，两个链表相交部分长度为c。
-在pa指向链表A时，即pa为空之前，pa经过链表A不相交部分和相交部分，走过的长度为a+c；
-pa指向链表B后，在移动相交节点之前经过链表B不相交部分，走过的长度为b，总合为a+c+b。
-同理，pb走过长度的总合为b+c+a。二者相等，即pa与pb可同时到达相交起始节点。
-该方法可避免计算具体链表长度。
-```cpp
-class Solution {
-public:
- ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
- //链表为空时，返回空指针
- if(headA == nullptr || headB == nullptr) return nullptr;
- ListNode* pa = headA;
- ListNode* pb = headB;
- //pa与pb在遍历过全部节点后,同时指向结尾空节点时退出循环
- while(pa != nullptr || pb != nullptr){
- //pa为空时，将pa指向headB
- if(pa == nullptr){
- pa = headB;
- }
- //pa为空时，将pb指向headA
- if(pb == nullptr){
- pb = headA;
- }
- //pa与pb相等时，返回相交起始节点
- if(pa == pb){
- return pa;
- }
- pa = pa->next;
- pb = pb->next;
- }
- return nullptr;
- }
-};
-```
+
+