next(needle.size());
+ getNext(&next[0], needle);
+ int j = 0;
+ for (int i = 0; i < haystack.size(); i++) {
+ while(j > 0 && haystack[i] != needle[j]) {
+ j = next[j - 1];
+ }
+ if (haystack[i] == needle[j]) {
+ j++;
+ }
+ if (j == needle.size() ) {
+ return (i - needle.size() + 1);
+ }
+ }
+ return -1;
+ }
+};
+```
+* 时间复杂度: O(n + m)
+* 空间复杂度: O(m)
+
+
+## 总结
+
+我们介绍了什么是KMP，KMP可以解决什么问题，然后分析KMP算法里的next数组，知道了next数组就是前缀表，再分析为什么要是前缀表而不是什么其他表。
+
+接着从给出的模式串中，我们一步一步的推导出了前缀表，得出前缀表无论是统一减一还是不减一得到的next数组仅仅是kmp的实现方式的不同。
+
+其中还分析了KMP算法的时间复杂度，并且和暴力方法做了对比。
+
+然后先用前缀表统一减一得到的next数组，求得文本串s里是否出现过模式串t，并给出了具体分析代码。
+
+又给出了直接用前缀表作为next数组，来做匹配的实现代码。
+
+可以说把KMP的每一个细微的细节都扣了出来，毫无遮掩的展示给大家了！
+
+
+## 其他语言版本
+
+### Java：
+```Java
+class Solution {
+ /**
+ 牺牲空间，换取最直白的暴力法
+ 时间复杂度 O(n * m)
+ 空间 O(n + m)
+ */
+ public int strStr(String haystack, String needle) {
+ // 获取 haystack 和 needle 的长度
+ int n = haystack.length(), m = needle.length();
+ // 将字符串转换为字符数组，方便索引操作
+ char[] s = haystack.toCharArray(), p = needle.toCharArray();
+
+ // 遍历 haystack 字符串
+ for (int i = 0; i < n - m + 1; i++) {
+ // 初始化匹配的指针
+ int a = i, b = 0;
+ // 循环检查 needle 是否在当前位置开始匹配
+ while (b < m && s[a] == p[b]) {
+ // 如果当前字符匹配，则移动指针
+ a++;
+ b++;
+ }
+ // 如果 b 等于 m，说明 needle 已经完全匹配，返回当前位置 i
+ if (b == m) return i;
+ }
+
+ // 如果遍历完毕仍未找到匹配的子串，则返回 -1
+ return -1;
+ }
+}
+```
+
+```Java
+class Solution {
+ /**
+ * 基于窗口滑动的算法
+ *
+ * 时间复杂度：O(m*n)
+ * 空间复杂度：O(1)
+ * 注：n为haystack的长度，m为needle的长度
+ */
+ public int strStr(String haystack, String needle) {
+ int m = needle.length();
+ // 当 needle 是空字符串时我们应当返回 0
+ if (m == 0) {
+ return 0;
+ }
+ int n = haystack.length();
+ if (n < m) {
+ return -1;
+ }
+ int i = 0;
+ int j = 0;
+ while (i < n - m + 1) {
+ // 找到首字母相等
+ while (i < n && haystack.charAt(i) != needle.charAt(j)) {
+ i++;
+ }
+ if (i == n) {// 没有首字母相等的
+ return -1;
+ }
+ // 遍历后续字符，判断是否相等
+ i++;
+ j++;
+ while (i < n && j < m && haystack.charAt(i) == needle.charAt(j)) {
+ i++;
+ j++;
+ }
+ if (j == m) {// 找到
+ return i - j;
+ } else {// 未找到
+ i -= j - 1;
+ j = 0;
+ }
+ }
+ return -1;
+ }
+}
+```
+
+```java
+// 方法一
+class Solution {
+ public void getNext(int[] next, String s){
+ int j = -1;
+ next[0] = j;
+ for (int i = 1; i < s.length(); i++){
+ while(j >= 0 && s.charAt(i) != s.charAt(j+1)){
+ j=next[j];
+ }
+
+ if(s.charAt(i) == s.charAt(j+1)){
+ j++;
+ }
+ next[i] = j;
+ }
+ }
+ public int strStr(String haystack, String needle) {
+ if(needle.length()==0){
+ return 0;
+ }
+
+ int[] next = new int[needle.length()];
+ getNext(next, needle);
+ int j = -1;
+ for(int i = 0; i < haystack.length(); i++){
+ while(j>=0 && haystack.charAt(i) != needle.charAt(j+1)){
+ j = next[j];
+ }
+ if(haystack.charAt(i) == needle.charAt(j+1)){
+ j++;
+ }
+ if(j == needle.length()-1){
+ return (i-needle.length()+1);
+ }
+ }
+
+ return -1;
+ }
+}
+```
+
+```Java
+class Solution {
+ //前缀表（不减一）Java实现
+ public int strStr(String haystack, String needle) {
+ if (needle.length() == 0) return 0;
+ int[] next = new int[needle.length()];
+ getNext(next, needle);
+
+ int j = 0;
+ for (int i = 0; i < haystack.length(); i++) {
+ while (j > 0 && needle.charAt(j) != haystack.charAt(i))
+ j = next[j - 1];
+ if (needle.charAt(j) == haystack.charAt(i))
+ j++;
+ if (j == needle.length())
+ return i - needle.length() + 1;
+ }
+ return -1;
+
+ }
+
+ private void getNext(int[] next, String s) {
+ int j = 0;
+ next[0] = 0;
+ for (int i = 1; i < s.length(); i++) {
+ while (j > 0 && s.charAt(j) != s.charAt(i))
+ j = next[j - 1];
+ if (s.charAt(j) == s.charAt(i))
+ j++;
+ next[i] = j;
+ }
+ }
+}
+```
+
+### Python3：
+（版本一）前缀表（减一）
+
+```python
+class Solution:
+ def getNext(self, next, s):
+ j = -1
+ next[0] = j
+ for i in range(1, len(s)):
+ while j >= 0 and s[i] != s[j+1]:
+ j = next[j]
+ if s[i] == s[j+1]:
+ j += 1
+ next[i] = j
+
+ def strStr(self, haystack: str, needle: str) -> int:
+ if not needle:
+ return 0
+ next = [0] * len(needle)
+ self.getNext(next, needle)
+ j = -1
+ for i in range(len(haystack)):
+ while j >= 0 and haystack[i] != needle[j+1]:
+ j = next[j]
+ if haystack[i] == needle[j+1]:
+ j += 1
+ if j == len(needle) - 1:
+ return i - len(needle) + 1
+ return -1
+```
+（版本二）前缀表（不减一）
+
+```python
+class Solution:
+ def getNext(self, next: List[int], s: str) -> None:
+ j = 0
+ next[0] = 0
+ for i in range(1, len(s)):
+ while j > 0 and s[i] != s[j]:
+ j = next[j - 1]
+ if s[i] == s[j]:
+ j += 1
+ next[i] = j
+
+ def strStr(self, haystack: str, needle: str) -> int:
+ if len(needle) == 0:
+ return 0
+ next = [0] * len(needle)
+ self.getNext(next, needle)
+ j = 0
+ for i in range(len(haystack)):
+ while j > 0 and haystack[i] != needle[j]:
+ j = next[j - 1]
+ if haystack[i] == needle[j]:
+ j += 1
+ if j == len(needle):
+ return i - len(needle) + 1
+ return -1
+```
+
+
+（版本三）暴力法
+```python
+class Solution(object):
+ def strStr(self, haystack, needle):
+ """
+ :type haystack: str
+ :type needle: str
+ :rtype: int
+ """
+ m, n = len(haystack), len(needle)
+ for i in range(m):
+ if haystack[i:i+n] == needle:
+ return i
+ return -1
+```
+（版本四）使用 index
+```python
+class Solution:
+ def strStr(self, haystack: str, needle: str) -> int:
+ try:
+ return haystack.index(needle)
+ except ValueError:
+ return -1
+```
+（版本五）使用 find
+```python
+class Solution:
+ def strStr(self, haystack: str, needle: str) -> int:
+ return haystack.find(needle)
+
+```
+
+### Go：
+
+```go
+// 方法一:前缀表使用减1实现
+
+// getNext 构造前缀表next
+// params:
+// next 前缀表数组
+// s 模式串
+func getNext(next []int, s string) {
+ j := -1 // j表示 最长相等前后缀长度
+ next[0] = j
+
+ for i := 1; i < len(s); i++ {
+ for j >= 0 && s[i] != s[j+1] {
+ j = next[j] // 回退前一位
+ }
+ if s[i] == s[j+1] {
+ j++
+ }
+ next[i] = j // next[i]是i（包括i）之前的最长相等前后缀长度
+ }
+}
+func strStr(haystack string, needle string) int {
+ if len(needle) == 0 {
+ return 0
+ }
+ next := make([]int, len(needle))
+ getNext(next, needle)
+ j := -1 // 模式串的起始位置 next为-1 因此也为-1
+ for i := 0; i < len(haystack); i++ {
+ for j >= 0 && haystack[i] != needle[j+1] {
+ j = next[j] // 寻找下一个匹配点
+ }
+ if haystack[i] == needle[j+1] {
+ j++
+ }
+ if j == len(needle)-1 { // j指向了模式串的末尾
+ return i - len(needle) + 1
+ }
+ }
+ return -1
+}
+```
+
+```go
+// 方法二: 前缀表无减一或者右移
+
+// getNext 构造前缀表next
+// params:
+// next 前缀表数组
+// s 模式串
+func getNext(next []int, s string) {
+ j := 0
+ next[0] = j
+ for i := 1; i < len(s); i++ {
+ for j > 0 && s[i] != s[j] {
+ j = next[j-1]
+ }
+ if s[i] == s[j] {
+ j++
+ }
+ next[i] = j
+ }
+}
+func strStr(haystack string, needle string) int {
+ n := len(needle)
+ if n == 0 {
+ return 0
+ }
+ j := 0
+ next := make([]int, n)
+ getNext(next, needle)
+ for i := 0; i < len(haystack); i++ {
+ for j > 0 && haystack[i] != needle[j] {
+ j = next[j-1] // 回退到j的前一位
+ }
+ if haystack[i] == needle[j] {
+ j++
+ }
+ if j == n {
+ return i - n + 1
+ }
+ }
+ return -1
+}
+```
+
+### JavaScript:
+
+> 前缀表统一减一
+
+```javascript
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+var strStr = function (haystack, needle) {
+ if (needle.length === 0)
+ return 0;
+
+ const getNext = (needle) => {
+ let next = [];
+ let j = -1;
+ next.push(j);
+
+ for (let i = 1; i < needle.length; ++i) {
+ while (j >= 0 && needle[i] !== needle[j + 1])
+ j = next[j];
+ if (needle[i] === needle[j + 1])
+ j++;
+ next.push(j);
+ }
+
+ return next;
+ }
+
+ let next = getNext(needle);
+ let j = -1;
+ for (let i = 0; i < haystack.length; ++i) {
+ while (j >= 0 && haystack[i] !== needle[j + 1])
+ j = next[j];
+ if (haystack[i] === needle[j + 1])
+ j++;
+ if (j === needle.length - 1)
+ return (i - needle.length + 1);
+ }
+
+ return -1;
+};
+```
+
+> 前缀表统一不减一
+
+```javascript
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+var strStr = function (haystack, needle) {
+ if (needle.length === 0)
+ return 0;
+
+ const getNext = (needle) => {
+ let next = [];
+ let j = 0;
+ next.push(j);
+
+ for (let i = 1; i < needle.length; ++i) {
+ while (j > 0 && needle[i] !== needle[j])
+ j = next[j - 1];
+ if (needle[i] === needle[j])
+ j++;
+ next.push(j);
+ }
+
+ return next;
+ }
+
+ let next = getNext(needle);
+ let j = 0;
+ for (let i = 0; i < haystack.length; ++i) {
+ while (j > 0 && haystack[i] !== needle[j])
+ j = next[j - 1];
+ if (haystack[i] === needle[j])
+ j++;
+ if (j === needle.length)
+ return (i - needle.length + 1);
+ }
+
+ return -1;
+};
+```
+
+### TypeScript:
+
+> 前缀表统一减一
+
+```typescript
+function strStr(haystack: string, needle: string): number {
+ function getNext(str: string): number[] {
+ let next: number[] = [];
+ let j: number = -1;
+ next[0] = j;
+ for (let i = 1, length = str.length; i < length; i++) {
+ while (j >= 0 && str[i] !== str[j + 1]) {
+ j = next[j];
+ }
+ if (str[i] === str[j + 1]) {
+ j++;
+ }
+ next[i] = j;
+ }
+ return next;
+ }
+ if (needle.length === 0) return 0;
+ let next: number[] = getNext(needle);
+ let j: number = -1;
+ for (let i = 0, length = haystack.length; i < length; i++) {
+ while (j >= 0 && haystack[i] !== needle[j + 1]) {
+ j = next[j];
+ }
+ if (haystack[i] === needle[j + 1]) {
+ if (j === needle.length - 2) {
+ return i - j - 1;
+ }
+ j++;
+ }
+ }
+ return -1;
+};
+```
+
+> 前缀表不减一
+
+```typescript
+// 不减一版本
+function strStr(haystack: string, needle: string): number {
+ function getNext(str: string): number[] {
+ let next: number[] = [];
+ let j: number = 0;
+ next[0] = j;
+ for (let i = 1, length = str.length; i < length; i++) {
+ while (j > 0 && str[i] !== str[j]) {
+ j = next[j - 1];
+ }
+ if (str[i] === str[j]) {
+ j++;
+ }
+ next[i] = j;
+ }
+ return next;
+ }
+ if (needle.length === 0) return 0;
+ let next: number[] = getNext(needle);
+ let j: number = 0;
+ for (let i = 0, length = haystack.length; i < length; i++) {
+ while (j > 0 && haystack[i] !== needle[j]) {
+ j = next[j - 1];
+ }
+ if (haystack[i] === needle[j]) {
+ if (j === needle.length - 1) {
+ return i - j;
+ }
+ j++;
+ }
+ }
+ return -1;
+}
+```
+
+### Swift:
+
+> 前缀表统一减一
+
+```swift
+func strStr(_ haystack: String, _ needle: String) -> Int {
+
+ let s = Array(haystack), p = Array(needle)
+ guard p.count != 0 else { return 0 }
+
+ // 2 pointer
+ var j = -1
+ var next = [Int](repeating: -1, count: needle.count)
+ // KMP
+ getNext(&next, needle: p)
+ for i in 0 ..< s.count {
+ while j >= 0 && s[i] != p[j + 1] {
+ //不匹配之后寻找之前匹配的位置
+ j = next[j]
+ }
+ if s[i] == p[j + 1] {
+ //匹配，双指针同时后移
+ j += 1
+ }
+ if j == (p.count - 1) {
+ //出现匹配字符串
+ return i - p.count + 1
+ }
+ }
+ return -1
+}
+
+//前缀表统一减一
+func getNext(_ next: inout [Int], needle: [Character]) {
+
+ var j: Int = -1
+ next[0] = j
+
+ // i 从 1 开始
+ for i in 1 ..< needle.count {
+ while j >= 0 && needle[i] != needle[j + 1] {
+ j = next[j]
+ }
+ if needle[i] == needle[j + 1] {
+ j += 1;
+ }
+ next[i] = j
+ }
+ print(next)
+}
+
+```
+
+> 前缀表右移
+
+```swift
+func strStr(_ haystack: String, _ needle: String) -> Int {
+
+ let s = Array(haystack), p = Array(needle)
+ guard p.count != 0 else { return 0 }
+
+ var j = 0
+ var next = [Int].init(repeating: 0, count: p.count)
+ getNext(&next, p)
+
+ for i in 0 ..< s.count {
+
+ while j > 0 && s[i] != p[j] {
+ j = next[j]
+ }
+
+ if s[i] == p[j] {
+ j += 1
+ }
+
+ if j == p.count {
+ return i - p.count + 1
+ }
+ }
+
+ return -1
+ }
+
+ // 前缀表后移一位，首位用 -1 填充
+ func getNext(_ next: inout [Int], _ needle: [Character]) {
+
+ guard needle.count > 1 else { return }
+
+ var j = 0
+ next[0] = j
+
+ for i in 1 ..< needle.count-1 {
+
+ while j > 0 && needle[i] != needle[j] {
+ j = next[j-1]
+ }
+
+ if needle[i] == needle[j] {
+ j += 1
+ }
+
+ next[i] = j
+ }
+ next.removeLast()
+ next.insert(-1, at: 0)
+ }
+```
+
+> 前缀表统一不减一
+```swift
+
+func strStr(_ haystack: String, _ needle: String) -> Int {
+
+ let s = Array(haystack), p = Array(needle)
+ guard p.count != 0 else { return 0 }
+
+ var j = 0
+ var next = [Int](repeating: 0, count: needle.count)
+ // KMP
+ getNext(&next, needle: p)
+
+ for i in 0 ..< s.count {
+ while j > 0 && s[i] != p[j] {
+ j = next[j-1]
+ }
+
+ if s[i] == p[j] {
+ j += 1
+ }
+
+ if j == p.count {
+ return i - p.count + 1
+ }
+ }
+ return -1
+ }
+
+ //前缀表
+ func getNext(_ next: inout [Int], needle: [Character]) {
+
+ var j = 0
+ next[0] = j
+
+ for i in 1 ..< needle.count {
+
+ while j>0 && needle[i] != needle[j] {
+ j = next[j-1]
+ }
+
+ if needle[i] == needle[j] {
+ j += 1
+ }
+
+ next[i] = j
+
+ }
+ }
+
+```
+
+### PHP：
+
+> 前缀表统一减一
+```php
+function strStr($haystack, $needle) {
+ if (strlen($needle) == 0) return 0;
+ $next= [];
+ $this->getNext($next,$needle);
+
+ $j = -1;
+ for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+ while($j >= 0 && $haystack[$i] != $needle[$j + 1]) {
+ $j = $next[$j];
+ }
+ if ($haystack[$i] == $needle[$j + 1]) {
+ $j++;
+ }
+ if ($j == (strlen($needle) - 1) ) {
+ return ($i - strlen($needle) + 1);
+ }
+ }
+ return -1;
+}
+
+function getNext(&$next, $s){
+ $j = -1;
+ $next[0] = $j;
+ for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+ while ($j >= 0 && $s[$i] != $s[$j + 1]) {
+ $j = $next[$j];
+ }
+ if ($s[$i] == $s[$j + 1]) {
+ $j++;
+ }
+ $next[$i] = $j;
+ }
+}
+```
+
+> 前缀表统一不减一
+```php
+function strStr($haystack, $needle) {
+ if (strlen($needle) == 0) return 0;
+ $next= [];
+ $this->getNext($next,$needle);
+
+ $j = 0;
+ for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+ while($j > 0 && $haystack[$i] != $needle[$j]) {
+ $j = $next[$j-1];
+ }
+ if ($haystack[$i] == $needle[$j]) {
+ $j++;
+ }
+ if ($j == strlen($needle)) {
+ return ($i - strlen($needle) + 1);
+ }
+ }
+ return -1;
+}
+
+function getNext(&$next, $s){
+ $j = 0;
+ $next[0] = $j;
+ for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+ while ($j > 0 && $s[$i] != $s[$j]) {
+ $j = $next[$j-1];
+ }
+ if ($s[$i] == $s[$j]) {
+ $j++;
+ }
+ $next[$i] = $j;
+ }
+}
+```
+
+### Rust:
+
+> 前缀表统一不减一
+```Rust
+impl Solution {
+ pub fn get_next(next: &mut Vec, s: &Vec) {
+ let len = s.len();
+ let mut j = 0;
+ for i in 1..len {
+ while j > 0 && s[i] != s[j] {
+ j = next[j - 1];
+ }
+ if s[i] == s[j] {
+ j += 1;
+ }
+ next[i] = j;
+ }
+ }
+
+ pub fn str_str(haystack: String, needle: String) -> i32 {
+ let (haystack_len, needle_len) = (haystack.len(), needle.len());
+ if haystack_len < needle_len { return -1;}
+ let (haystack, needle) = (haystack.chars().collect::>(), needle.chars().collect::>());
+ let mut next: Vec = vec![0; haystack_len];
+ Self::get_next(&mut next, &needle);
+ let mut j = 0;
+ for i in 0..haystack_len {
+ while j > 0 && haystack[i] != needle[j] {
+ j = next[j - 1];
+ }
+ if haystack[i] == needle[j] {
+ j += 1;
+ }
+ if j == needle_len {
+ return (i - needle_len + 1) as i32;
+ }
+ }
+ return -1;
+ }
+}
+```
+
+> 前缀表统一减一
+
+```rust
+impl Solution {
+ pub fn get_next(next_len: usize, s: &Vec) -> Vec {
+ let mut next = vec![-1; next_len];
+ let mut j = -1;
+ for i in 1..s.len() {
+ while j >= 0 && s[(j + 1) as usize] != s[i] {
+ j = next[j as usize];
+ }
+ if s[i] == s[(j + 1) as usize] {
+ j += 1;
+ }
+ next[i] = j;
+ }
+ next
+ }
+ pub fn str_str(haystack: String, needle: String) -> i32 {
+ if haystack.len() < needle.len() {
+ return -1;
+ }
+ let (haystack_chars, needle_chars) = (
+ haystack.chars().collect::>(),
+ needle.chars().collect::>(),
+ );
+ let mut j = -1;
+ let next = Self::get_next(needle.len(), &needle_chars);
+ for (i, v) in haystack_chars.into_iter().enumerate() {
+ while j >= 0 && v != needle_chars[(j + 1) as usize] {
+ j = next[j as usize];
+ }
+ if v == needle_chars[(j + 1) as usize] {
+ j += 1;
+ }
+ if j == needle_chars.len() as i32 - 1 {
+ return (i - needle_chars.len() + 1) as i32;
+ }
+ }
+ -1
+ }
+}
+```
+
+>前缀表统一不减一
+```csharp
+public int StrStr(string haystack, string needle)
+{
+ if (string.IsNullOrEmpty(needle))
+ return 0;
+
+ if (needle.Length > haystack.Length || string.IsNullOrEmpty(haystack))
+ return -1;
+
+ return KMP(haystack, needle);
+}
+
+public int KMP(string haystack, string needle)
+{
+ int[] next = GetNext(needle);
+ int i = 0, j = 0;
+ while (i < haystack.Length)
+ {
+ if (haystack[i] == needle[j])
+ {
+ i++;
+ j++;
+ }
+ if (j == needle.Length)
+ return i-j;
+ else if (i < haystack.Length && haystack[i] != needle[j])
+ if (j != 0)
+ {
+ j = next[j - 1];
+ }
+ else
+ {
+ i++;
+ }
+ }
+ return -1;
+}
+
+public int[] GetNext(string needle)
+{
+ int[] next = new int[needle.Length];
+ next[0] = 0;
+ int i = 1, j = 0;
+ while (i < needle.Length)
+ {
+ if (needle[i] == needle[j])
+ {
+ next[i++] = ++j;
+ }
+ else
+ {
+ if (j == 0)
+ {
+ next[i++] = 0;
+ }
+ else
+ {
+ j = next[j - 1];
+ }
+ }
+ }
+ return next;
+}
+```
+
+### C:
+
+> 前缀表统一右移和减一
+
+```c
+
+int *build_next(char* needle, int len) {
+
+ int *next = (int *)malloc(len * sizeof(int));
+ assert(next); // 确保分配成功
+
+ // 初始化next数组
+ next[0] = -1; // next[0] 设置为 -1，表示没有有效前缀匹配
+ if (len <= 1) { // 如果模式串长度小于等于 1，直接返回
+ return next;
+ }
+ next[1] = 0; // next[1] 设置为 0，表示第一个字符没有公共前后缀
+
+ // 构建next数组， i 从模式串的第三个字符开始， j 指向当前匹配的最长前缀长度
+ int i = 2, j = 0;
+ while (i < len) {
+ if (needle[i - 1] == needle[j]) {
+ j++;
+ next[i] = j;
+ i++;
+ } else if (j > 0) {
+ // 如果不匹配且 j > 0， 回退到次长匹配前缀的长度
+ j = next[j];
+ } else {
+ next[i] = 0;
+ i++;
+ }
+ }
+ return next;
+}
+
+int strStr(char* haystack, char* needle) {
+
+ int needle_len = strlen(needle);
+ int haystack_len = strlen(haystack);
+
+ int *next = build_next(needle, needle_len);
+
+ int i = 0, j = 0; // i 指向主串的当前起始位置, j 指向模式串的当前匹配位置
+ while (i <= haystack_len - needle_len) {
+ if (haystack[i + j] == needle[j]) {
+ j++;
+ if (j == needle_len) {
+ free(next);
+ next = NULL
+ return i;
+ }
+ } else {
+ i += j - next[j]; // 调整主串的起始位置
+ j = j > 0 ? next[j] : 0;
+ }
+ }
+
+ free(next);
+ next = NULL;
+ return -1;
+}
+```
+
diff --git "a/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" "b/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md"
new file mode 100755
index 0000000000..4bbf20fbb8
--- /dev/null
+++ "b/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md"
@@ -0,0 +1,269 @@
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
+
+
+
+
+# 31.下一个排列
+
+[力扣题目链接](https://leetcode.cn/problems/next-permutation/)
+
+实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
+
+如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
+
+必须 原地 修改，只允许使用额外常数空间。
+
+示例 1：
+* 输入：nums = [1,2,3]
+* 输出：[1,3,2]
+
+示例 2：
+* 输入：nums = [3,2,1]
+* 输出：[1,2,3]
+
+示例 3：
+* 输入：nums = [1,1,5]
+* 输出：[1,5,1]
+
+示例 4：
+* 输入：nums = [1]
+* 输出：[1]
+
+
+## 思路
+
+一些同学可能手动写排列的顺序，都没有写对，那么写程序的话思路一定是有问题的了，我这里以1234为例子，把全排列都列出来。可以参考一下规律所在：
+
+```
+1 2 3 4
+1 2 4 3
+1 3 2 4
+1 3 4 2
+1 4 2 3
+1 4 3 2
+2 1 3 4
+2 1 4 3
+2 3 1 4
+2 3 4 1
+2 4 1 3
+2 4 3 1
+3 1 2 4
+3 1 4 2
+3 2 1 4
+3 2 4 1
+3 4 1 2
+3 4 2 1
+4 1 2 3
+4 1 3 2
+4 2 1 3
+4 2 3 1
+4 3 1 2
+4 3 2 1
+```
+
+如图：
+
+以求1243为例，流程如图：
+
+
+
+对应的C++代码如下：
+
+```CPP
+class Solution {
+public:
+ void nextPermutation(vector& nums) {
+ for (int i = nums.size() - 1; i >= 0; i--) {
+ for (int j = nums.size() - 1; j > i; j--) {
+ if (nums[j] > nums[i]) {
+ swap(nums[j], nums[i]);
+ reverse(nums.begin() + i + 1, nums.end());
+ return;
+ }
+ }
+ }
+ // 到这里了说明整个数组都是倒序了，反转一下便可
+ reverse(nums.begin(), nums.end());
+ }
+};
+```
+
+## 其他语言版本
+
+### Java
+
+```java
+class Solution {
+ public void nextPermutation(int[] nums) {
+ for (int i = nums.length - 1; i >= 0; i--) {
+ for (int j = nums.length - 1; j > i; j--) {
+ if (nums[j] > nums[i]) {
+ // 交换
+ int temp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = temp;
+ // [i + 1, nums.length) 内元素升序排序
+ Arrays.sort(nums, i + 1, nums.length);
+ return;
+ }
+ }
+ }
+ Arrays.sort(nums); // 不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
+ }
+}
+```
+> 优化时间复杂度为O(N)，空间复杂度为O(1)
+```Java
+class Solution {
+ public void nextPermutation(int[] nums) {
+ // 1.从后向前获取逆序区域的前一位
+ int index = findIndex(nums);
+ // 判断数组是否处于最小组合状态
+ if(index != 0){
+ // 2.交换逆序区域刚好大于它的最小数字
+ exchange(nums,index);
+ }
+ // 3.把原来的逆序区转为顺序
+ reverse(nums,index);
+ }
+
+ public static int findIndex(int [] nums){
+ for(int i = nums.length-1;i>0;i--){
+ if(nums[i]>nums[i-1]){
+ return i;
+ }
+ }
+ return 0;
+ }
+ public static void exchange(int [] nums, int index){
+ int head = nums[index-1];
+ for(int i = nums.length-1;i>0;i--){
+ if(head < nums[i]){
+ nums[index-1] = nums[i];
+ nums[i] = head;
+ break;
+ }
+ }
+ }
+ public static void reverse(int [] nums, int index){
+ for(int i = index,j = nums.length-1;i直接使用sorted()会开辟新的空间并返回一个新的list，故补充一个原地反转函数
+```python
+class Solution:
+ def nextPermutation(self, nums: List[int]) -> None:
+ """
+ Do not return anything, modify nums in-place instead.
+ """
+ length = len(nums)
+ for i in range(length - 2, -1, -1): # 从倒数第二个开始
+ if nums[i]>=nums[i+1]: continue # 剪枝去重
+ for j in range(length - 1, i, -1):
+ if nums[j] > nums[i]:
+ nums[j], nums[i] = nums[i], nums[j]
+ self.reverse(nums, i + 1, length - 1)
+ return
+ self.reverse(nums, 0, length - 1)
+
+ def reverse(self, nums: List[int], left: int, right: int) -> None:
+ while left < right:
+ nums[left], nums[right] = nums[right], nums[left]
+ left += 1
+ right -= 1
+
+"""
+265 / 265 个通过测试用例
+状态：通过
+执行用时: 36 ms
+内存消耗: 14.9 MB
+"""
+```
+
+### Go
+
+```go
+//卡尔的解法
+func nextPermutation(nums []int) {
+ for i:=len(nums)-1;i>=0;i--{
+ for j:=len(nums)-1;j>i;j--{
+ if nums[j]>nums[i]{
+ //交换
+ nums[j],nums[i]=nums[i],nums[j]
+ reverse(nums,0+i+1,len(nums)-1)
+ return
+ }
+ }
+ }
+ reverse(nums,0,len(nums)-1)
+}
+//对目标切片指定区间的反转方法
+func reverse(a []int,begin,end int){
+ for i,j:=begin,end;i= 0; i--){
+ for(let j = nums.length - 1; j > i; j--){
+ if(nums[j] > nums[i]){
+ [nums[j],nums[i]] = [nums[i],nums[j]]; // 交换
+ // 深拷贝[i + 1, nums.length)部分到新数组arr
+ let arr = nums.slice(i+1);
+ // arr升序排序
+ arr.sort((a,b) => a - b);
+ // arr替换nums的[i + 1, nums.length)部分
+ nums.splice(i+1,nums.length - i, ...arr);
+ return;
+ }
+ }
+ }
+ nums.sort((a,b) => a - b); // 不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
+};
+
+//另一种
+var nextPermutation = function(nums) {
+ let i = nums.length - 2;
+ // 从右往左遍历拿到第一个左边小于右边的 i,此时 i 右边的数组是从右往左递增的
+ while (i >= 0 && nums[i] >= nums[i+1]){
+ i--;
+ }
+ if (i >= 0){
+ let j = nums.length - 1;
+ // 从右往左遍历拿到第一个大于nums[i]的数,因为之前nums[i]是第一个小于他右边的数，所以他的右边一定有大于他的数
+ while (j >= 0 && nums[j] <= nums[i]){
+ j--;
+ }
+ // 交换两个数
+ [nums[j], nums[i]] = [nums[i], nums[j]];
+ }
+ // 对 i 右边的数进行交换
+ // 因为 i 右边的数原来是从右往左递增的，把一个较小的值交换过来之后，仍然维持单调递增特性
+ // 此时头尾交换并向中间逼近就能获得 i 右边序列的最小值
+ let l = i + 1;
+ let r = nums.length - 1;
+ while (l < r){
+ [nums[l], nums[r]] = [nums[r], nums[l]];
+ l++;
+ r--;
+ }
+};
+```
+
+
+
diff --git "a/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md" "b/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md"
new file mode 100755
index 0000000000..37248e4819
--- /dev/null
+++ "b/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md"
@@ -0,0 +1,855 @@
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
+
+
+# 34. 在排序数组中查找元素的第一个和最后一个位置
+
+[力扣链接](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/)
+
+
+给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
+
+如果数组中不存在目标值 target，返回 [-1, -1]。
+
+进阶：你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗？
+
+
+示例 1：
+* 输入：nums = [5,7,7,8,8,10], target = 8
+* 输出：[3,4]
+
+示例 2：
+* 输入：nums = [5,7,7,8,8,10], target = 6
+* 输出：[-1,-1]
+
+示例 3：
+* 输入：nums = [], target = 0
+* 输出：[-1,-1]
+
+
+## 思路
+
+这道题目如果基础不是很好，不建议大家看简短的代码，简短的代码隐藏了太多逻辑，结果就是稀里糊涂把题AC了，但是没有想清楚具体细节！
+
+对二分还不了解的同学先做这两题：
+
+* [704.二分查找](https://programmercarl.com/0704.二分查找.html)
+* [35.搜索插入位置](https://programmercarl.com/0035.搜索插入位置.html)
+
+下面我来把所有情况都讨论一下。
+
+寻找target在数组里的左右边界，有如下三种情况：
+
+* 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
+* 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
+* 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}
+
+这三种情况都考虑到，说明就想的很清楚了。
+
+接下来，在去寻找左边界，和右边界了。
+
+采用二分法来去寻找左右边界，为了让代码清晰，我分别写两个二分来寻找左边界和右边界。
+
+**刚刚接触二分搜索的同学不建议上来就想用一个二分来查找左右边界，很容易把自己绕进去，建议扎扎实实的写两个二分分别找左边界和右边界**
+
+### 寻找右边界
+
+先来寻找右边界，至于二分查找，如果看过[704.二分查找](https://programmercarl.com/0704.二分查找.html)就会知道，二分查找中什么时候用while (left <= right)，有什么时候用while (left < right)，其实只要清楚**循环不变量**，很容易区分两种写法。
+
+那么这里我采用while (left <= right)的写法，区间定义为[left, right]，即左闭右闭的区间（如果这里有点看不懂了，强烈建议把[704.二分查找](https://programmercarl.com/0704.二分查找.html)这篇文章先看了，704题目做了之后再做这道题目就好很多了）
+
+确定好：计算出来的右边界是不包含target的右边界，左边界同理。
+
+可以写出如下代码
+
+```CPP
+// 二分查找，寻找target的右边界（不包括target）
+// 如果rightBorder为没有被赋值（即target在数组范围的左边，例如数组[3,3]，target为2），为了处理情况一
+int getRightBorder(vector& nums, int target) {
+ int left = 0;
+ int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
+ int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
+ while (left <= right) { // 当left==right，区间[left, right]依然有效
+ int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
+ if (nums[middle] > target) {
+ right = middle - 1; // target 在左区间，所以[left, middle - 1]
+ } else { // 当nums[middle] == target的时候，更新left，这样才能得到target的右边界
+ left = middle + 1;
+ rightBorder = left;
+ }
+ }
+ return rightBorder;
+}
+```
+
+### 寻找左边界
+
+```CPP
+// 二分查找，寻找target的左边界leftBorder（不包括target）
+// 如果leftBorder没有被赋值（即target在数组范围的右边，例如数组[3,3],target为4），为了处理情况一
+int getLeftBorder(vector& nums, int target) {
+ int left = 0;
+ int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
+ int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
+ while (left <= right) {
+ int middle = left + ((right - left) / 2);
+ if (nums[middle] >= target) { // 寻找左边界，就要在nums[middle] == target的时候更新right
+ right = middle - 1;
+ leftBorder = right;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return leftBorder;
+}
+```
+
+### 处理三种情况
+
+左右边界计算完之后，看一下主体代码，这里把上面讨论的三种情况，都覆盖了
+
+```CPP
+class Solution {
+public:
+ vector searchRange(vector& nums, int target) {
+ int leftBorder = getLeftBorder(nums, target);
+ int rightBorder = getRightBorder(nums, target);
+ // 情况一
+ if (leftBorder == -2 || rightBorder == -2) return {-1, -1};
+ // 情况三
+ if (rightBorder - leftBorder > 1) return {leftBorder + 1, rightBorder - 1};
+ // 情况二
+ return {-1, -1};
+ }
+private:
+ int getRightBorder(vector& nums, int target) {
+ int left = 0;
+ int right = nums.size() - 1;
+ int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
+ while (left <= right) {
+ int middle = left + ((right - left) / 2);
+ if (nums[middle] > target) {
+ right = middle - 1;
+ } else { // 寻找右边界，nums[middle] == target的时候更新left
+ left = middle + 1;
+ rightBorder = left;
+ }
+ }
+ return rightBorder;
+ }
+ int getLeftBorder(vector& nums, int target) {
+ int left = 0;
+ int right = nums.size() - 1;
+ int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
+ while (left <= right) {
+ int middle = left + ((right - left) / 2);
+ if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
+ right = middle - 1;
+ leftBorder = right;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return leftBorder;
+ }
+};
+```
+
+这份代码在简洁性很有大的优化空间，例如把寻找左右区间函数合并一起。
+
+但拆开更清晰一些，而且把三种情况以及对应的处理逻辑完整的展现出来了。
+
+## 总结
+
+初学者建议大家一块一块的去分拆这道题目，正如本题解描述，想清楚三种情况之后，先专注于寻找右区间，然后专注于寻找左区间，左右根据左右区间做最后判断。
+
+不要上来就想如果一起寻找左右区间，搞着搞着就会顾此失彼，绕进去拔不出来了。
+
+
+## 其他语言版本
+
+### Java
+
+```java
+class Solution {
+ int[] searchRange(int[] nums, int target) {
+ int leftBorder = getLeftBorder(nums, target);
+ int rightBorder = getRightBorder(nums, target);
+ // 情况一
+ if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1};
+ // 情况三
+ if (rightBorder - leftBorder > 1) return new int[]{leftBorder + 1, rightBorder - 1};
+ // 情况二
+ return new int[]{-1, -1};
+ }
+
+ int getRightBorder(int[] nums, int target) {
+ int left = 0;
+ int right = nums.length - 1;
+ int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
+ while (left <= right) {
+ int middle = left + ((right - left) / 2);
+ if (nums[middle] > target) {
+ right = middle - 1;
+ } else { // 寻找右边界，nums[middle] == target的时候更新left
+ left = middle + 1;
+ rightBorder = left;
+ }
+ }
+ return rightBorder;
+ }
+
+ int getLeftBorder(int[] nums, int target) {
+ int left = 0;
+ int right = nums.length - 1;
+ int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
+ while (left <= right) {
+ int middle = left + ((right - left) / 2);
+ if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
+ right = middle - 1;
+ leftBorder = right;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return leftBorder;
+ }
+}
+```
+
+```java
+// 解法2
+// 1、首先，在 nums 数组中二分查找 target；
+// 2、如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
+// 3、如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间
+
+class Solution {
+ public int[] searchRange(int[] nums, int target) {
+ int index = binarySearch(nums, target); // 二分查找
+
+ if (index == -1) { // nums 中不存在 target，直接返回 {-1, -1}
+ return new int[] {-1, -1}; // 匿名数组
+ }
+ // nums 中存在 target，则左右滑动指针，来找到符合题意的区间
+ int left = index;
+ int right = index;
+ // 向左滑动，找左边界
+ while (left - 1 >= 0 && nums[left - 1] == nums[index]) { // 防止数组越界。逻辑短路，两个条件顺序不能换
+ left--;
+ }
+ // 向右滑动，找右边界
+ while (right + 1 < nums.length && nums[right + 1] == nums[index]) { // 防止数组越界。
+ right++;
+ }
+ return new int[] {left, right};
+ }
+
+ /**
+ * 二分查找
+ * @param nums
+ * @param target
+ */
+ public int binarySearch(int[] nums, int target) {
+ int left = 0;
+ int right = nums.length - 1; // 不变量：左闭右闭区间
+
+ while (left <= right) { // 不变量：左闭右闭区间
+ int mid = left + (right - left) / 2;
+ if (nums[mid] == target) {
+ return mid;
+ } else if (nums[mid] < target) {
+ left = mid + 1;
+ } else {
+ right = mid - 1; // 不变量：左闭右闭区间
+ }
+ }
+ return -1; // 不存在
+ }
+}
+```
+
+```java
+// 解法三
+class Solution {
+ public int[] searchRange(int[] nums, int target) {
+ int left = searchLeft(nums,target);
+ int right = searchRight(nums,target);
+ return new int[]{left,right};
+ }
+ public int searchLeft(int[] nums,int target){
+ // 寻找元素第一次出现的地方
+ int left = 0;
+ int right = nums.length-1;
+ while(left<=right){
+ int mid = left+(right-left)/2;
+ // >= 的都要缩小 因为要找第一个元素
+ if(nums[mid]>=target){
+ right = mid - 1;
+ }else{
+ left = mid + 1;
+ }
+ }
+ // right = left - 1
+ // 如果存在答案 right是首选
+ if(right>=0&&right=0&&left=0&&left=0&&right<=nums.length&&nums[right]==target){
+ return right;
+ }
+ return -1;
+ }
+}
+```
+
+### C#
+
+```csharp
+public int[] SearchRange(int[] nums, int target) {
+
+ var leftBorder = GetLeftBorder(nums, target);
+ var rightBorder = GetRightBorder(nums, target);
+
+ if (leftBorder == -2 || rightBorder == -2) {
+ return new int[] {-1, -1};
+ }
+
+ if (rightBorder - leftBorder >=2) {
+ return new int[] {leftBorder + 1, rightBorder - 1};
+ }
+
+ return new int[] {-1, -1};
+
+}
+
+public int GetLeftBorder(int[] nums, int target){
+ var left = 0;
+ var right = nums.Length - 1;
+ var leftBorder = -2;
+
+ while (left <= right) {
+ var mid = (left + right) / 2;
+
+ if (target <= nums[mid]) {
+ right = mid - 1;
+ leftBorder = right;
+ }
+ else {
+ left = mid + 1;
+ }
+ }
+
+ return leftBorder;
+}
+
+public int GetRightBorder(int[] nums, int target){
+ var left = 0;
+ var right = nums.Length - 1;
+ var rightBorder = -2;
+
+ while (left <= right) {
+ var mid = (left + right) / 2;
+
+ if (target >= nums[mid]) {
+ left = mid + 1;
+ rightBorder = left;
+ }
+ else {
+ right = mid - 1;
+ }
+ }
+
+ return rightBorder;
+}
+```
+
+
+
+### Python
+
+```python
+class Solution:
+ def searchRange(self, nums: List[int], target: int) -> List[int]:
+ def getRightBorder(nums:List[int], target:int) -> int:
+ left, right = 0, len(nums)-1
+ rightBoder = -2 # 记录一下rightBorder没有被赋值的情况
+ while left <= right:
+ middle = left + (right-left) // 2
+ if nums[middle] > target:
+ right = middle - 1
+ else: # 寻找右边界，nums[middle] == target的时候更新left
+ left = middle + 1
+ rightBoder = left
+
+ return rightBoder
+
+ def getLeftBorder(nums:List[int], target:int) -> int:
+ left, right = 0, len(nums)-1
+ leftBoder = -2 # 记录一下leftBorder没有被赋值的情况
+ while left <= right:
+ middle = left + (right-left) // 2
+ if nums[middle] >= target: # 寻找左边界，nums[middle] == target的时候更新right
+ right = middle - 1
+ leftBoder = right
+ else:
+ left = middle + 1
+ return leftBoder
+ leftBoder = getLeftBorder(nums, target)
+ rightBoder = getRightBorder(nums, target)
+ # 情况一
+ if leftBoder == -2 or rightBoder == -2: return [-1, -1]
+ # 情况三
+ if rightBoder -leftBoder >1: return [leftBoder + 1, rightBoder - 1]
+ # 情况二
+ return [-1, -1]
+```
+```python
+# 解法2
+# 1、首先，在 nums 数组中二分查找 target；
+# 2、如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
+# 3、如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间
+class Solution:
+ def searchRange(self, nums: List[int], target: int) -> List[int]:
+ def binarySearch(nums:List[int], target:int) -> int:
+ left, right = 0, len(nums)-1
+ while left<=right: # 不变量：左闭右闭区间
+ middle = left + (right-left) // 2
+ if nums[middle] > target:
+ right = middle - 1
+ elif nums[middle] < target:
+ left = middle + 1
+ else:
+ return middle
+ return -1
+ index = binarySearch(nums, target)
+ if index == -1:return [-1, -1] # nums 中不存在 target，直接返回 {-1, -1}
+ # nums 中存在 target，则左右滑动指针，来找到符合题意的区间
+ left, right = index, index
+ # 向左滑动，找左边界
+ while left -1 >=0 and nums[left - 1] == target: left -=1
+ # 向右滑动，找右边界
+ while right+1 < len(nums) and nums[right + 1] == target: right +=1
+ return [left, right]
+```
+```python
+# 解法3
+# 1、首先，在 nums 数组中二分查找得到第一个大于等于 target的下标（左边界）与第一个大于target的下标（右边界）；
+# 2、如果左边界<= 右边界，则返回 [左边界, 右边界]。否则返回[-1, -1]
+class Solution:
+ def searchRange(self, nums: List[int], target: int) -> List[int]:
+ def binarySearch(nums:List[int], target:int, lower:bool) -> int:
+ left, right = 0, len(nums)-1
+ ans = len(nums)
+ while left<=right: # 不变量：左闭右闭区间
+ middle = left + (right-left) //2
+ # lower为True，执行前半部分，找到第一个大于等于 target的下标 ，否则找到第一个大于target的下标
+ if nums[middle] > target or (lower and nums[middle] >= target):
+ right = middle - 1
+ ans = middle
+ else:
+ left = middle + 1
+ return ans
+
+ leftBorder = binarySearch(nums, target, True) # 搜索左边界
+ rightBorder = binarySearch(nums, target, False) -1 # 搜索右边界
+ if leftBorder<= rightBorder and rightBorder< len(nums) and nums[leftBorder] == target and nums[rightBorder] == target:
+ return [leftBorder, rightBorder]
+ return [-1, -1]
+```
+
+```python
+# 解法4
+# 1、首先，在 nums 数组中二分查找得到第一个大于等于 target的下标leftBorder；
+# 2、在 nums 数组中二分查找得到第一个大于等于 target+1的下标， 减1则得到rightBorder；
+# 3、如果开始位置在数组的右边或者不存在target，则返回[-1, -1] 。否则返回[leftBorder, rightBorder]
+class Solution:
+ def searchRange(self, nums: List[int], target: int) -> List[int]:
+ def binarySearch(nums:List[int], target:int) -> int:
+ left, right = 0, len(nums)-1
+ while left<=right: # 不变量：左闭右闭区间
+ middle = left + (right-left) //2
+ if nums[middle] >= target:
+ right = middle - 1
+ else:
+ left = middle + 1
+ return left # 若存在target，则返回第一个等于target的值
+
+ leftBorder = binarySearch(nums, target) # 搜索左边界
+ rightBorder = binarySearch(nums, target+1) -1 # 搜索右边界
+ if leftBorder == len(nums) or nums[leftBorder]!= target: # 情况一和情况二
+ return [-1, -1]
+ return [leftBorder, rightBorder]
+```
+
+### Rust
+
+```rust
+
+impl Solution {
+ pub fn search_range(nums: Vec, target: i32) -> Vec {
+ let right_border = Solution::get_right_border(&nums, target);
+ let left_border = Solution::get_left_border(&nums, target);
+ if right_border == -2 || left_border == -2 {
+ return vec![-1, -1];
+ }
+ if right_border - left_border > 0 {
+ return vec![left_border, right_border - 1];
+ }
+ vec![-1, -1]
+ }
+
+ pub fn get_right_border(nums: &Vec, target: i32) -> i32 {
+ let mut left = 0;
+ let mut right = nums.len();
+ let mut right_border: i32 = -2;
+ while left < right {
+ let mid = (left + right) / 2;
+ if nums[mid] > target {
+ right = mid;
+ } else {
+ left = mid + 1;
+ right_border = left as i32;
+ }
+ }
+ right_border as i32
+ }
+
+ pub fn get_left_border(nums: &Vec, target: i32) -> i32 {
+ let mut left = 0;
+ let mut right = nums.len();
+ let mut left_border: i32 = -2;
+ while left < right {
+ let mid = (left + right) / 2;
+ if nums[mid] >= target {
+ right = mid;
+ left_border = right as i32;
+ } else {
+ left = mid + 1;
+ }
+ }
+ left_border as i32
+ }
+}
+```
+
+### Go
+
+```go
+func searchRange(nums []int, target int) []int {
+ leftBorder := getLeft(nums, target)
+ rightBorder := getRight(nums, target)
+ // 情况一
+ if leftBorder == -2 || rightBorder == -2 {
+ return []int{-1, -1}
+ }
+ // 情况三
+ if rightBorder - leftBorder > 1 {
+ return []int{leftBorder + 1, rightBorder - 1}
+ }
+ // 情况二
+ return []int{-1, -1}
+}
+
+func getLeft(nums []int, target int) int {
+ left, right := 0, len(nums)-1
+ border := -2 // 记录border没有被赋值的情况；这里不能赋值-1，target = num[0]时，会无法区分情况一和情况二
+ for left <= right { // []闭区间
+ mid := left + ((right - left) >> 1)
+ if nums[mid] >= target { // 找到第一个等于target的位置
+ right = mid - 1
+ border = right
+ } else {
+ left = mid + 1
+ }
+ }
+ return border
+}
+
+func getRight(nums []int, target int) int {
+ left, right := 0, len(nums) - 1
+ border := -2
+ for left <= right {
+ mid := left + ((right - left) >> 1)
+ if nums[mid] > target {
+ right = mid - 1
+ } else { // 找到第一个大于target的位置
+ left = mid + 1
+ border = left
+ }
+ }
+ return border
+
+}
+```
+
+### JavaScript
+
+```js
+var searchRange = function(nums, target) {
+ const getLeftBorder = (nums, target) => {
+ let left = 0, right = nums.length - 1;
+ let leftBorder = -2;// 记录一下leftBorder没有被赋值的情况
+ while(left <= right){
+ let middle = left + ((right - left) >> 1);
+ if(nums[middle] >= target){ // 寻找左边界，nums[middle] == target的时候更新right
+ right = middle - 1;
+ leftBorder = right;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return leftBorder;
+ }
+
+ const getRightBorder = (nums, target) => {
+ let left = 0, right = nums.length - 1;
+ let rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
+ while (left <= right) {
+ let middle = left + ((right - left) >> 1);
+ if (nums[middle] > target) {
+ right = middle - 1;
+ } else { // 寻找右边界，nums[middle] == target的时候更新left
+ left = middle + 1;
+ rightBorder = left;
+ }
+ }
+ return rightBorder;
+ }
+
+ let leftBorder = getLeftBorder(nums, target);
+ let rightBorder = getRightBorder(nums, target);
+ // 情况一
+ if(leftBorder === -2 || rightBorder === -2) return [-1,-1];
+ // 情况三
+ if (rightBorder - leftBorder > 1) return [leftBorder + 1, rightBorder - 1];
+ // 情况二
+ return [-1, -1];
+};
+```
+
+
+### TypeScript
+
+```typescript
+function searchRange(nums: number[], target: number): number[] {
+ const leftBoard: number = getLeftBorder(nums, target);
+ const rightBoard: number = getRightBorder(nums, target);
+ // target 在nums区间左侧或右侧
+ if (leftBoard === (nums.length - 1) || rightBoard === 0) return [-1, -1];
+ // target 不存在与nums范围内
+ if (rightBoard - leftBoard <= 1) return [-1, -1];
+ // target 存在于nums范围内
+ return [leftBoard + 1, rightBoard - 1];
+};
+// 查找第一个大于target的元素下标
+function getRightBorder(nums: number[], target: number): number {
+ let left: number = 0,
+ right: number = nums.length - 1;
+ // 0表示target在nums区间的左边
+ let rightBoard: number = 0;
+ while (left <= right) {
+ let mid = Math.floor((left + right) / 2);
+ if (nums[mid] <= target) {
+ // 右边界一定在mid右边（不含mid）
+ left = mid + 1;
+ rightBoard = left;
+ } else {
+ // 右边界在mid左边（含mid）
+ right = mid - 1;
+ }
+ }
+ return rightBoard;
+}
+// 查找第一个小于target的元素下标
+function getLeftBorder(nums: number[], target: number): number {
+ let left: number = 0,
+ right: number = nums.length - 1;
+ // length-1表示target在nums区间的右边
+ let leftBoard: number = nums.length - 1;
+ while (left <= right) {
+ let mid = Math.floor((left + right) / 2);
+ if (nums[mid] >= target) {
+ // 左边界一定在mid左边（不含mid）
+ right = mid - 1;
+ leftBoard = right;
+ } else {
+ // 左边界在mid右边（含mid）
+ left = mid + 1;
+ }
+ }
+ return leftBoard;
+}
+```
+
+
+### 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
+ }
+}
+```
+
+
+### Kotlin
+```kotlin
+class Solution {
+ fun searchRange(nums: IntArray, target: Int): IntArray {
+ var index = binarySearch(nums, target)
+ // 没找到，返回[-1, -1]
+ if (index == -1) return intArrayOf(-1, -1)
+ var left = index
+ var right = index
+ // 寻找左边界
+ while (left - 1 >=0 && nums[left - 1] == target){
+ left--
+ }
+ // 寻找右边界
+ while (right + 1 target) {
+ right = middle - 1
+ }
+ else {
+ if (nums[middle] < target) {
+ left = middle + 1
+ }
+ else {
+ return middle
+ }
+ }
+ }
+ // 没找到，返回-1
+ return -1
+ }
+}
+```
+
+### C
+```c
+int searchLeftBorder(int *nums, int numsSize, int target) {
+ int left = 0, right = numsSize - 1;
+ // 记录leftBorder没有被赋值的情况
+ int leftBorder = -1;
+ // 边界为[left, right]
+ while (left <= right) {
+ // 更新middle值，等同于middle = (left + right) / 2
+ int middle = left + ((right - left) >> 1);
+ // 若当前middle所指为target，将左边界设为middle，并向左继续寻找左边界
+ if (nums[middle] == target) {
+ leftBorder = middle;
+ right = middle - 1;
+ } else if (nums[middle] > target) {
+ right = middle - 1;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return leftBorder;
+}
+int searchRightBorder(int *nums, int numsSize, int target) {
+ int left = 0, right = numsSize - 1;
+ // 记录rightBorder没有被赋值的情况
+ int rightBorder = -1;
+ while (left <= right) {
+ int middle = left + ((right - left) >> 1);
+ // 若当前middle所指为target，将右边界设为middle，并向右继续寻找右边界
+ if (nums[middle] == target) {
+ rightBorder = middle;
+ left = middle + 1;
+ } else if (nums[middle] > target) {
+ right = middle - 1;
+ } else {
+ left = middle + 1;
+ }
+ }
+ return rightBorder;
+}
+
+int* searchRange(int* nums, int numsSize, int target, int* returnSize){
+ int leftBorder = searchLeftBorder(nums, numsSize, target);
+ int rightBorder = searchRightBorder(nums, numsSize, target);
+
+ // 定义返回数组及数组大小
+ *returnSize = 2;
+ int *resNums = (int*)malloc(sizeof(int) * 2);
+ resNums[0] = leftBorder;
+ resNums[1] = rightBorder;
+ return resNums;
+}
+```
+
+
diff --git "a/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md" "b/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
old mode 100644
new mode 100755
index 64cb107554..b48910eef7
--- "a/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
+++ "b/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
@@ -1,38 +1,47 @@
-# 题目地址
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-https://leetcode-cn.com/problems/search-insert-position/
-> 二分查找法是数组里的常用方法，彻底掌握它是十分必要的。
-# 编号35：搜索插入位置
+
+
+
+# 35.搜索插入位置
+
+[力扣题目链接](https://leetcode.cn/problems/search-insert-position/)
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
-示例 1:
-输入: [1,3,5,6], 5
-输出: 2
+示例 1:
+
+* 输入: [1,3,5,6], 5
+* 输出: 2
+
+示例 2:
-示例 2:
-输入: [1,3,5,6], 2
-输出: 1
+* 输入: [1,3,5,6], 2
+* 输出: 1
-示例 3:
-输入: [1,3,5,6], 7
-输出: 4
+示例 3:
-示例 4:
-输入: [1,3,5,6], 0
-输出: 0
+* 输入: [1,3,5,6], 7
+* 输出: 4
-# 思路
+示例 4:
+
+* 输入: [1,3,5,6], 0
+* 输出: 0
+
+## 思路
这道题目不难，但是为什么通过率相对来说并不高呢，我理解是大家对边界处理的判断有所失误导致的。
这道题目，要在数组中插入目标值，无非是这四种情况。
-
+
* 目标值在数组所有元素之前
* 目标值等于数组中某一个元素
@@ -43,65 +52,66 @@ https://leetcode-cn.com/problems/search-insert-position/
接下来我将从暴力的解法和二分法来讲解此题，也借此好好讲一讲二分查找法。
-## 暴力解法
+### 暴力解法
暴力解题 不一定时间消耗就非常高，关键看实现的方式，就像是二分查找时间消耗不一定就很低，是一样的。
-## 暴力解法C++代码
+C++代码
-```
+```CPP
class Solution {
public:
int searchInsert(vector& nums, int target) {
for (int i = 0; i < nums.size(); i++) {
// 分别处理如下三种情况
// 目标值在数组所有元素之前
- // 目标值等于数组中某一个元素
- // 目标值插入数组中的位置
+ // 目标值等于数组中某一个元素
+ // 目标值插入数组中的位置
if (nums[i] >= target) { // 一旦发现大于或者等于target的num[i]，那么i就是我们要的结果
return i;
}
}
- // 目标值在数组所有元素之后的情况
+ // 目标值在数组所有元素之后的情况
return nums.size(); // 如果target是最大的，或者 nums为空，则返回nums的长度
}
};
```
-时间复杂度：O(n)
-时间复杂度：O(1)
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
效率如下：
-
+
-## 二分法
+### 二分法
-既然暴力解法的时间复杂度是O(n)，就要尝试一下使用二分查找法。
+既然暴力解法的时间复杂度是O(n)，就要尝试一下使用二分查找法。
-
+
+
大家注意这道题目的前提是数组是有序数组，这也是使用二分查找的基础条件。
以后大家**只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。**
-同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下表可能不是唯一的。
+同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。
大体讲解一下二分法的思路，这里来举一个例子，例如在这个数组中，使用二分法寻找元素为5的位置，并返回其下标。
-
+
二分查找涉及的很多的边界条件，逻辑比较简单，就是写不好。
相信很多同学对二分查找法中边界条件处理不好。
-例如到底是 `while(left < right)` 还是 `while(left <= right)`，到底是`right = middle`呢，还是要`right = middle - 1`呢？
+例如到底是 `while(left < right)` 还是 `while(left <= right)`，到底是`right = middle`呢，还是要`right = middle - 1`呢？
-这里弄不清楚主要是因为**对区间的定义没有想清楚，这就是不变量**。
+这里弄不清楚主要是因为**对区间的定义没有想清楚，这就是不变量**。
要在二分查找的过程中，保持不变量，这也就是**循环不变量** （感兴趣的同学可以查一查）。
-## 二分法第一种写法
+### 二分法第一种写法
以这道题目来举例，以下的代码中定义 target 是在一个在左闭右闭的区间里，**也就是[left, right] （这个很重要）**。
@@ -109,13 +119,13 @@ public:
**大家要仔细看注释，思考为什么要写while(left <= right)， 为什么要写right = middle - 1**。
-```
+```CPP
class Solution {
public:
int searchInsert(vector& nums, int target) {
int n = nums.size();
int left = 0;
- int right = n - 1; // 定义target在左闭右闭的区间里，[left, right]
+ int right = n - 1; // 定义target在左闭右闭的区间里，[left, right]
while (left <= right) { // 当left==right，区间[left, right]依然有效
int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
if (nums[middle] > target) {
@@ -130,18 +140,19 @@ public:
// 目标值在数组所有元素之前 [0, -1]
// 目标值等于数组中某一个元素 return middle;
// 目标值插入数组中的位置 [left, right]，return right + 1
- // 目标值在数组所有元素之后的情况 [left, right]， return right + 1
+ // 目标值在数组所有元素之后的情况 [left, right]， 因为是右闭区间，所以 return right + 1
return right + 1;
}
};
```
-时间复杂度：O(logn)
-时间复杂度：O(1)
+
+* 时间复杂度：O(log n)
+* 空间复杂度：O(1)
效率如下：
-
+
-## 二分法第二种写法
+### 二分法第二种写法
如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) 。
@@ -151,7 +162,7 @@ public:
**大家要仔细看注释，思考为什么要写while (left < right)， 为什么要写right = middle**。
-```
+```CPP
class Solution {
public:
int searchInsert(vector& nums, int target) {
@@ -172,16 +183,16 @@ public:
// 目标值在数组所有元素之前 [0,0)
// 目标值等于数组中某一个元素 return middle
// 目标值插入数组中的位置 [left, right) ，return right 即可
- // 目标值在数组所有元素之后的情况 [left, right)，return right 即可
+ // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
return right;
}
};
```
-时间复杂度：O(logn)
-时间复杂度：O(1)
+* 时间复杂度：O(log n)
+* 空间复杂度：O(1)
-# 总结
+## 总结
希望通过这道题目，大家会发现平时写二分法，为什么总写不好，就是因为对区间定义不清楚。
@@ -190,5 +201,349 @@ public:
然后在**二分查找的循环中，坚持循环不变量的原则**，很多细节问题，自然会知道如何处理了。
-> 更过算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。
+
+## 其他语言版本
+
+### Java
+
+```java
+class Solution {
+ public int searchInsert(int[] nums, int target) {
+ int n = nums.length;
+
+ // 定义target在左闭右闭的区间，[low, high]
+ int low = 0;
+ int high = n - 1;
+
+ while (low <= high) { // 当low==high，区间[low, high]依然有效
+ int mid = low + (high - low) / 2; // 防止溢出
+ if (nums[mid] > target) {
+ high = mid - 1; // target 在左区间，所以[low, mid - 1]
+ } else if (nums[mid] < target) {
+ low = mid + 1; // target 在右区间，所以[mid + 1, high]
+ } else {
+ // 1. 目标值等于数组中某一个元素 return mid;
+ return mid;
+ }
+ }
+ // 2.目标值在数组所有元素之前 3.目标值插入数组中 4.目标值在数组所有元素之后 return right + 1;
+ return high + 1;
+ }
+}
+```
+
+```java
+//第二种二分法：左闭右开
+public int searchInsert(int[] nums, int target) {
+ int left = 0;
+ int right = nums.length;
+ while (left < right) { //左闭右开 [left, right)
+ int middle = left + ((right - left) >> 1);
+ if (nums[middle] > target) {
+ right = middle; // target 在左区间，在[left, middle)中
+ } else if (nums[middle] < target) {
+ left = middle + 1; // target 在右区间，在 [middle+1, right)中
+ } else { // nums[middle] == target
+ return middle; // 数组中找到目标值的情况，直接返回下标
+ }
+ }
+ // 目标值在数组所有元素之前 [0,0)
+ // 目标值插入数组中的位置 [left, right) ，return right 即可
+ // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
+ return right;
+}
+```
+
+
+
+### C#
+
+```go
+public int SearchInsert(int[] nums, int target) {
+
+ var left = 0;
+ var right = nums.Length - 1;
+
+ while (left <= right) {
+
+ var curr = (left + right) / 2;
+
+ if (nums[curr] == target)
+ {
+ return curr;
+ }
+
+ if (target > nums[curr]) {
+ left = curr + 1;
+ }
+ else {
+ right = curr - 1;
+ }
+ }
+
+ return left;
+}
+```
+
+
+
+### Golang
+
+```go
+// 第一种二分法
+func searchInsert(nums []int, target int) int {
+ left, right := 0, len(nums)-1
+ for left <= right {
+ mid := left + (right-left)/2
+ if nums[mid] == target {
+ return mid
+ } else if nums[mid] > target {
+ right = mid - 1
+ } else {
+ left = mid + 1
+ }
+ }
+ return right+1
+}
+```
+
+### Rust
+
+```rust
+impl Solution {
+ pub fn search_insert(nums: Vec, target: i32) -> i32 {
+ use std::cmp::Ordering::{Equal, Greater, Less};
+ let (mut left, mut right) = (0, nums.len() as i32 - 1);
+ while left <= right {
+ let mid = (left + right) / 2;
+ match nums[mid as usize].cmp(&target) {
+ Less => left = mid + 1,
+ Equal => return mid,
+ Greater => right = mid - 1,
+ }
+ }
+ right + 1
+ }
+}
+```
+
+### Python
+
+```python
+# 第一种二分法: [left, right]左闭右闭区间
+class Solution:
+ def searchInsert(self, nums: List[int], target: int) -> int:
+ left, right = 0, len(nums) - 1
+
+ while left <= right:
+ middle = (left + right) // 2
+
+ if nums[middle] < target:
+ left = middle + 1
+ elif nums[middle] > target:
+ right = middle - 1
+ else:
+ return middle
+ return right + 1
+```
+
+```python
+# 第二种二分法: [left, right)左闭右开区间
+class Solution:
+ def searchInsert(self, nums: List[int], target: int) -> int:
+ left = 0
+ right = len(nums)
+
+ while (left < right):
+ middle = (left + right) // 2
+
+ if nums[middle] > target:
+ right = middle
+ elif nums[middle] < target:
+ left = middle + 1
+ else:
+ return middle
+
+ return right
+```
+
+### JavaScript
+
+```js
+var searchInsert = function (nums, target) {
+ let l = 0, r = nums.length - 1, ans = nums.length;
+
+ while (l <= r) {
+ const mid = l + Math.floor((r - l) >> 1);
+
+ if (target > nums[mid]) {
+ l = mid + 1;
+ } else {
+ ans = mid;
+ r = mid - 1;
+ }
+ }
+
+ return ans;
+};
+```
+
+### TypeScript
+
+```typescript
+// 第一种二分法
+function searchInsert(nums: number[], target: number): number {
+ const length: number = nums.length;
+ let left: number = 0,
+ right: number = length - 1;
+ while (left <= right) {
+ const mid: number = Math.floor((left + right) / 2);
+ if (nums[mid] < target) {
+ left = mid + 1;
+ } else if (nums[mid] === target) {
+ return mid;
+ } else {
+ right = mid - 1;
+ }
+ }
+ return right + 1;
+};
+```
+
+### Swift
+
+```swift
+// 暴力法
+func searchInsert(_ nums: [Int], _ target: Int) -> Int {
+ for i in 0..= target {
+ return i
+ }
+ }
+ return nums.count
+}
+
+// 二分法
+func searchInsert(_ nums: [Int], _ target: Int) -> Int {
+ var left = 0
+ var right = nums.count - 1
+
+ while left <= right {
+ let middle = left + ((right - left) >> 1)
+
+ if nums[middle] > target {
+ right = middle - 1
+ }else if nums[middle] < target {
+ left = middle + 1
+ }else if nums[middle] == target {
+ return middle
+ }
+ }
+
+ 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
+ }
+}
+```
+
+### 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;
+}
+```
+
+### C
+
+```c
+//版本一 [left, right]左闭右闭区间
+int searchInsert(int* nums, int numsSize, int target){
+ //左闭右开区间 [0 , numsSize-1]
+ int left =0;
+ int mid =0;
+ int right = numsSize - 1;
+ while(left <= right){//左闭右闭区间 所以可以 left == right
+ mid = left + (right - left) / 2;
+ if(target < nums[mid]){
+ //target 在左区间 [left, mid - 1]中，原区间包含mid，右区间边界可以向左内缩
+ right = mid -1;
+ }else if( target > nums[mid]){
+ //target 在右区间 [mid + 1, right]中,原区间包含mid，左区间边界可以向右内缩
+ left = mid + 1;
+ }else {
+ // nums[mid] == target ，顺利找到target，直接返回mid
+ return mid;
+ }
+ }
+ //数组中未找到target元素
+ //target在数组所有元素之后，[left, right]是右闭区间，需要返回 right +1
+ return right + 1;
+}
+```
+
+```c
+//版本二 [left, right]左闭右开区间
+int searchInsert(int* nums, int numsSize, int target){
+ //左闭右开区间 [0 , numsSize)
+ int left =0;
+ int mid =0;
+ int right = numsSize;
+ while(left < right){//左闭右闭区间 所以 left < right
+ mid = left + (right - left) / 2;
+ if(target < nums[mid]){
+ //target 在左区间 [left, mid)中，原区间没有包含mid，右区间边界不能内缩
+ right = mid ;
+ }else if( target > nums[mid]){
+ // target 在右区间 [mid+1, right)中，原区间包含mid，左区间边界可以向右内缩
+ left = mid + 1;
+ }else {
+ // nums[mid] == target ，顺利找到target，直接返回mid
+ return mid;
+ }
+ }
+ //数组中未找到target元素
+ //target在数组所有元素之后，[left, right)是右开区间， return right即可
+ return right;
+}
+```
+
diff --git "a/problems/0037.\350\247\243\346\225\260\347\213\254.md" "b/problems/0037.\350\247\243\346\225\260\347\213\254.md"
old mode 100644
new mode 100755
index 43b37c9c36..204f0cc092
--- "a/problems/0037.\350\247\243\346\225\260\347\213\254.md"
+++ "b/problems/0037.\350\247\243\346\225\260\347\213\254.md"
@@ -1,51 +1,181 @@
-# 题目地址
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-https://leetcode-cn.com/problems/sudoku-solver/
-# 思路
-棋盘搜索问题依然是要使用回溯法，暴力搜索，只不过这次我们要做的是双层递归。
+> 如果对回溯法理论还不清楚的同学，可以先看这个视频[视频来了！！带你学透回溯算法（理论篇）](https://mp.weixin.qq.com/s/wDd5azGIYWjbU0fdua_qBg)
-怎么做双层递归呢？如果大家之前做过回溯类型的题目，例如：，77.组合（组合问题），131.分割回文串（分割问题），78.子集（子集问题），46.全排列（排列问题），以及51.N皇后（N皇后问题）等等，都会发现，这些都是单层递归。
+# 37. 解数独
-**如果大家以上这几道题目没有做过的话，不建议上来就做这道题哈！**
+[力扣题目链接](https://leetcode.cn/problems/sudoku-solver/)
-n皇后因为每一行每一列只放一个皇后，只需要一层for循环遍历行数，递归来处理每一行的一个皇后放在哪里就可以。
+编写一个程序，通过填充空格来解决数独问题。
-本题就不一样了，本题中棋盘每一个位置都要放一个数字，这个问题的树形结构要比N皇后更宽更深。
+一个数独的解法需遵循如下规则：
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
+空白格用 '.' 表示。
-如图所示：
+
-
+一个数独。
-可以看出我们需要的是一个二维的递归（也就是两个for循环，递归遍历每一个棋盘的位置）
+
-这道题目和之前递归的方式都不一样，这里相当于两层递归，之前的都是一层递归。
+答案被标成红色。
-# C++代码
+提示：
+* 给定的数独序列只包含数字 1-9 和字符 '.' 。
+* 你可以假设给定的数独只有唯一解。
+* 给定数独永远是 9x9 形式的。
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[回溯算法二维递归？解数独不过如此！| LeetCode：37. 解数独](https://www.bilibili.com/video/BV1TW4y1471V/)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
+
+棋盘搜索问题可以使用回溯法暴力搜索，只不过这次我们要做的是**二维递归**。
+
+怎么做二维递归呢？
+
+大家已经跟着「代码随想录」刷过了如下回溯法题目，例如：[77.组合（组合问题）](https://programmercarl.com/0077.组合.html)，[131.分割回文串（分割问题）](https://programmercarl.com/0131.分割回文串.html)，[78.子集（子集问题）](https://programmercarl.com/0078.子集.html)，[46.全排列（排列问题）](https://programmercarl.com/0046.全排列.html)，以及[51.N皇后（N皇后问题）](https://programmercarl.com/0051.N皇后.html)，其实这些题目都是一维递归。
+
+**如果以上这几道题目没有做过的话，不建议上来就做这道题哈！**
+
+[N皇后问题](https://programmercarl.com/0051.N皇后.html)是因为每一行每一列只放一个皇后，只需要一层for循环遍历一行，递归来遍历列，然后一行一列确定皇后的唯一位置。
+
+本题就不一样了，**本题中棋盘的每一个位置都要放一个数字（而N皇后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深**。
+
+因为这个树形结构太大了，我抽取一部分，如图所示：
+
+
+
+
+### 回溯三部曲
+
+* 递归函数以及参数
+
+**递归函数的返回值需要是bool类型，为什么呢？**
+
+因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。
+
+代码如下：
+
+```cpp
+bool backtracking(vector>& board)
```
-class Solution {
-private:
+
+* 递归终止条件
+
+本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。
+
+**不用终止条件会不会死循环？**
+
+递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！
+
+**那么有没有永远填不满的情况呢？**
+
+这个问题我在递归单层搜索逻辑里再来讲！
+
+* 递归单层搜索逻辑
+
+
+
+在树形图中可以看出我们需要的是一个二维的递归 （一行一列）
+
+**一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！**
+
+
+代码如下：（**详细看注释**）
+
+```CPP
bool backtracking(vector>& board) {
- for (int i = 0; i < board.size(); i++) { // 遍历行
+ for (int i = 0; i < board.size(); i++) { // 遍历行
for (int j = 0; j < board[0].size(); j++) { // 遍历列
if (board[i][j] != '.') continue;
- for (char k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
- if (isValid(i, j, k, board)) {
- board[i][j] = k;
+ for (char k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
+ if (isValid(i, j, k, board)) {
+ board[i][j] = k; // 放置k
if (backtracking(board)) return true; // 如果找到合适一组立刻返回
- board[i][j] = '.';
+ board[i][j] = '.'; // 回溯，撤销k
}
}
- return false;
+ return false; // 9个数都试完了，都不行，那么就返回false
}
}
return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
-
}
+```
+
+**注意这里return false的地方，这里放return false 是有讲究的**。
+
+因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
+
+那么会直接返回， **这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！**
+
+### 判断棋盘是否合法
+
+判断棋盘是否合法有如下三个维度：
+
+* 同行是否重复
+* 同列是否重复
+* 9宫格里是否重复
+
+代码如下：
+
+```CPP
bool isValid(int row, int col, char val, vector>& board) {
+ for (int i = 0; i < 9; i++) { // 判断行里是否重复
+ if (board[row][i] == val) {
+ return false;
+ }
+ }
+ for (int j = 0; j < 9; j++) { // 判断列里是否重复
+ if (board[j][col] == val) {
+ return false;
+ }
+ }
+ int startRow = (row / 3) * 3;
+ int startCol = (col / 3) * 3;
+ for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
+ for (int j = startCol; j < startCol + 3; j++) {
+ if (board[i][j] == val ) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+```
+
+最后整体C++代码如下：
+
+```CPP
+class Solution {
+private:
+bool backtracking(vector>& board) {
+ for (int i = 0; i < board.size(); i++) { // 遍历行
+ for (int j = 0; j < board[0].size(); j++) { // 遍历列
+ if (board[i][j] == '.') {
+ for (char k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
+ if (isValid(i, j, k, board)) {
+ board[i][j] = k; // 放置k
+ if (backtracking(board)) return true; // 如果找到合适一组立刻返回
+ board[i][j] = '.'; // 回溯，撤销k
+ }
+ }
+ return false; // 9个数都试完了，都不行，那么就返回false
+ }
+ }
+ }
+ return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
+}
+bool isValid(int row, int col, char val, vector>& board) {
for (int i = 0; i < 9; i++) { // 判断行里是否重复
if (board[row][i] == val) {
return false;
@@ -72,4 +202,692 @@ public:
backtracking(board);
}
};
+
+```
+
+## 总结
+
+解数独可以说是非常难的题目了，如果还一直停留在单层递归的逻辑中，这道题目可以让大家瞬间崩溃。
+
+所以我在开篇就提到了**二维递归**，这也是我自创词汇，希望可以帮助大家理解解数独的搜索过程。
+
+一波分析之后，再看代码会发现其实也不难，唯一难点就是理解**二维递归**的思维逻辑。
+
+**这样，解数独这么难的问题，也被我们攻克了**。
+
+**恭喜一路上坚持打卡的录友们，回溯算法已经接近尾声了，接下来就是要一波总结了**。
+
+
+## 其他语言版本
+
+
+### Java
+解法一:
+```java
+class Solution {
+ public void solveSudoku(char[][] board) {
+ solveSudokuHelper(board);
+ }
+
+ private boolean solveSudokuHelper(char[][] board){
+ //「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
+ // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
+ for (int i = 0; i < 9; i++){ // 遍历行
+ for (int j = 0; j < 9; j++){ // 遍历列
+ if (board[i][j] != '.'){ // 跳过原始数字
+ continue;
+ }
+ for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
+ if (isValidSudoku(i, j, k, board)){
+ board[i][j] = k;
+ if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
+ return true;
+ }
+ board[i][j] = '.';
+ }
+ }
+ // 9个数都试完了，都不行，那么就返回false
+ return false;
+ // 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
+ // 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
+ }
+ }
+ // 遍历完没有返回false，说明找到了合适棋盘位置了
+ return true;
+ }
+
+ /**
+ * 判断棋盘是否合法有如下三个维度:
+ * 同行是否重复
+ * 同列是否重复
+ * 9宫格里是否重复
+ */
+ private boolean isValidSudoku(int row, int col, char val, char[][] board){
+ // 同行是否重复
+ for (int i = 0; i < 9; i++){
+ if (board[row][i] == val){
+ return false;
+ }
+ }
+ // 同列是否重复
+ for (int j = 0; j < 9; j++){
+ if (board[j][col] == val){
+ return false;
+ }
+ }
+ // 9宫格里是否重复
+ int startRow = (row / 3) * 3;
+ int startCol = (col / 3) * 3;
+ for (int i = startRow; i < startRow + 3; i++){
+ for (int j = startCol; j < startCol + 3; j++){
+ if (board[i][j] == val){
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+}
+```
+解法二(bitmap标记)
+```
+class Solution{
+ int[] rowBit = new int[9];
+ int[] colBit = new int[9];
+ int[] square9Bit = new int[9];
+
+ public void solveSudoku(char[][] board) {
+ // 1 10 11
+ for (int y = 0; y < board.length; y++) {
+ for (int x = 0; x < board[y].length; x++) {
+ int numBit = 1 << (board[y][x] - '1');
+ rowBit[y] ^= numBit;
+ colBit[x] ^= numBit;
+ square9Bit[(y / 3) * 3 + x / 3] ^= numBit;
+ }
+ }
+ backtrack(board, 0);
+ }
+
+ public boolean backtrack(char[][] board, int n) {
+ if (n >= 81) {
+ return true;
+ }
+
+ // 快速算出行列编号 n/9 n%9
+ int row = n / 9;
+ int col = n % 9;
+
+ if (board[row][col] != '.') {
+ return backtrack(board, n + 1);
+ }
+
+ for (char c = '1'; c <= '9'; c++) {
+ int numBit = 1 << (c - '1');
+ if (!isValid(numBit, row, col)) continue;
+ {
+ board[row][col] = c; // 当前的数字放入到数组之中，
+ rowBit[row] ^= numBit; // 第一行rowBit[0],第一个元素eg: 1 , 0^1=1,第一个元素:4, 100^1=101,...
+ colBit[col] ^= numBit;
+ square9Bit[(row / 3) * 3 + col / 3] ^= numBit;
+ }
+ if (backtrack(board, n + 1)) return true;
+ {
+ board[row][col] = '.'; // 不满足条件，回退成'.'
+ rowBit[row] &= ~numBit; // 第一行rowBit[0],第一个元素eg: 1 , 101&=~1==>101&111111110==>100
+ colBit[col] &= ~numBit;
+ square9Bit[(row / 3) * 3 + col / 3] &= ~numBit;
+ }
+ }
+ return false;
+ }
+
+
+ boolean isValid(int numBit, int row, int col) {
+ // 左右
+ if ((rowBit[row] & numBit) > 0) return false;
+ // 上下
+ if ((colBit[col] & numBit) > 0) return false;
+ // 9宫格: 快速算出第n个九宫格,编号[0,8] , 编号=(row / 3) * 3 + col / 3
+ if ((square9Bit[(row / 3) * 3 + col / 3] & numBit) > 0) return false;
+ return true;
+ }
+
+}
+
+```
+### Python
+
+```python
+class Solution:
+ def solveSudoku(self, board: List[List[str]]) -> None:
+ """
+ Do not return anything, modify board in-place instead.
+ """
+ row_used = [set() for _ in range(9)]
+ col_used = [set() for _ in range(9)]
+ box_used = [set() for _ in range(9)]
+ for row in range(9):
+ for col in range(9):
+ num = board[row][col]
+ if num == ".":
+ continue
+ row_used[row].add(num)
+ col_used[col].add(num)
+ box_used[(row // 3) * 3 + col // 3].add(num)
+ self.backtracking(0, 0, board, row_used, col_used, box_used)
+
+ def backtracking(
+ self,
+ row: int,
+ col: int,
+ board: List[List[str]],
+ row_used: List[List[int]],
+ col_used: List[List[int]],
+ box_used: List[List[int]],
+ ) -> bool:
+ if row == 9:
+ return True
+
+ next_row, next_col = (row, col + 1) if col < 8 else (row + 1, 0)
+ if board[row][col] != ".":
+ return self.backtracking(
+ next_row, next_col, board, row_used, col_used, box_used
+ )
+
+ for num in map(str, range(1, 10)):
+ if (
+ num not in row_used[row]
+ and num not in col_used[col]
+ and num not in box_used[(row // 3) * 3 + col // 3]
+ ):
+ board[row][col] = num
+ row_used[row].add(num)
+ col_used[col].add(num)
+ box_used[(row // 3) * 3 + col // 3].add(num)
+ if self.backtracking(
+ next_row, next_col, board, row_used, col_used, box_used
+ ):
+ return True
+ board[row][col] = "."
+ row_used[row].remove(num)
+ col_used[col].remove(num)
+ box_used[(row // 3) * 3 + col // 3].remove(num)
+ return False
+```
+
+### Go
+
+```go
+func solveSudoku(board [][]byte) {
+ var backtracking func(board [][]byte) bool
+ backtracking = func(board [][]byte) bool {
+ for i := 0; i < 9; i++ {
+ for j := 0; j < 9; j++ {
+ //判断此位置是否适合填数字
+ if board[i][j] != '.' {
+ continue
+ }
+ //尝试填1-9
+ for k := '1'; k <= '9'; k++ {
+ if isvalid(i, j, byte(k), board) == true { //如果满足要求就填
+ board[i][j] = byte(k)
+ if backtracking(board) == true {
+ return true
+ }
+ board[i][j] = '.'
+ }
+ }
+ return false
+ }
+ }
+ return true
+ }
+ backtracking(board)
+}
+
+//判断填入数字是否满足要求
+func isvalid(row, col int, k byte, board [][]byte) bool {
+ for i := 0; i < 9; i++ { //行
+ if board[row][i] == k {
+ return false
+ }
+ }
+ for i := 0; i < 9; i++ { //列
+ if board[i][col] == k {
+ return false
+ }
+ }
+ //方格
+ startrow := (row / 3) * 3
+ startcol := (col / 3) * 3
+ for i := startrow; i < startrow+3; i++ {
+ for j := startcol; j < startcol+3; j++ {
+ if board[i][j] == k {
+ return false
+ }
+ }
+ }
+ return true
+}
+```
+
+
+
+### JavaScript
+
+```Javascript
+var solveSudoku = function(board) {
+ function isValid(row, col, val, board) {
+ let len = board.length
+ // 行不能重复
+ for(let i = 0; i < len; i++) {
+ if(board[row][i] === val) {
+ return false
+ }
+ }
+ // 列不能重复
+ for(let i = 0; i < len; i++) {
+ if(board[i][col] === val) {
+ return false
+ }
+ }
+ let startRow = Math.floor(row / 3) * 3
+ let startCol = Math.floor(col / 3) * 3
+
+ for(let i = startRow; i < startRow + 3; i++) {
+ for(let j = startCol; j < startCol + 3; j++) {
+ if(board[i][j] === val) {
+ return false
+ }
+ }
+ }
+
+ return true
+ }
+
+ function backTracking() {
+ for(let i = 0; i < board.length; i++) {
+ for(let j = 0; j < board[0].length; j++) {
+ if(board[i][j] !== '.') continue
+ for(let val = 1; val <= 9; val++) {
+ if(isValid(i, j, `${val}`, board)) {
+ board[i][j] = `${val}`
+ if (backTracking()) {
+ return true
+ }
+
+ board[i][j] = `.`
+ }
+ }
+ return false
+ }
+ }
+ return true
+ }
+ backTracking(board)
+ return board
+
+};
+```
+
+### TypeScript
+
+```typescript
+/**
+ Do not return anything, modify board in-place instead.
+ */
+function isValid(col: number, row: number, val: string, board: string[][]): boolean {
+ let n: number = board.length;
+ // 列向检查
+ for (let rowIndex = 0; rowIndex < n; rowIndex++) {
+ if (board[rowIndex][col] === val) return false;
+ }
+ // 横向检查
+ for (let colIndex = 0; colIndex < n; colIndex++) {
+ if (board[row][colIndex] === val) return false;
+ }
+ // 九宫格检查
+ const startX = Math.floor(col / 3) * 3;
+ const startY = Math.floor(row / 3) * 3;
+ for (let rowIndex = startY; rowIndex < startY + 3; rowIndex++) {
+ for (let colIndex = startX; colIndex < startX + 3; colIndex++) {
+ if (board[rowIndex][colIndex] === val) return false;
+ }
+ }
+ return true;
+}
+function solveSudoku(board: string[][]): void {
+ let n: number = 9;
+ backTracking(n, board);
+ function backTracking(n: number, board: string[][]): boolean {
+ for (let row = 0; row < n; row++) {
+ for (let col = 0; col < n; col++) {
+ if (board[row][col] === '.') {
+ for (let i = 1; i <= n; i++) {
+ if (isValid(col, row, String(i), board)) {
+ board[row][col] = String(i);
+ if (backTracking(n, board) === true) return true;
+ board[row][col] = '.';
+ }
+ }
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+};
+```
+
+### Rust
+
+```Rust
+impl Solution {
+ fn is_valid(row: usize, col: usize, val: char, board: &mut Vec>) -> bool{
+ for i in 0..9 {
+ if board[row][i] == val { return false; }
+ }
+ for j in 0..9 {
+ if board[j][col] == val {
+ return false;
+ }
+ }
+ let start_row = (row / 3) * 3;
+ let start_col = (col / 3) * 3;
+ for i in start_row..(start_row + 3) {
+ for j in start_col..(start_col + 3) {
+ if board[i][j] == val { return false; }
+ }
+ }
+ return true;
+ }
+
+ fn backtracking(board: &mut Vec>) -> bool{
+ for i in 0..board.len() {
+ for j in 0..board[0].len() {
+ if board[i][j] != '.' { continue; }
+ for k in '1'..='9' {
+ if Self::is_valid(i, j, k, board) {
+ board[i][j] = k;
+ if Self::backtracking(board) { return true; }
+ board[i][j] = '.';
+ }
+ }
+ return false;
+ }
+ }
+ return true;
+ }
+
+ pub fn solve_sudoku(board: &mut Vec>) {
+ Self::backtracking(board);
+ }
+}
+```
+
+### C
+
+```C
+bool isValid(char** board, int row, int col, int k) {
+ /* 判断当前行是否有重复元素 */
+ for (int i = 0; i < 9; i++) {
+ if (board[i][col] == k) {
+ return false;
+ }
+ }
+ /* 判断当前列是否有重复元素 */
+ for (int j = 0; j < 9; j++) {
+ if (board[row][j] == k) {
+ return false;
+ }
+ }
+ /* 计算当前9宫格左上角的位置 */
+ int startRow = (row / 3) * 3;
+ int startCol = (col / 3) * 3;
+ /* 判断当前元素所在九宫格是否有重复元素 */
+ for (int i = startRow; i < startRow + 3; i++) {
+ for (int j = startCol; j < startCol + 3; j++) {
+ if (board[i][j] == k) {
+ return false;
+ }
+ }
+ }
+ /* 满足条件，返回true */
+ return true;
+}
+
+bool backtracking(char** board, int boardSize, int* boardColSize) {
+ /* 从上到下、从左到右依次遍历输入数组 */
+ for (int i = 0; i < boardSize; i++) {
+ for (int j = 0; j < *boardColSize; j++) {
+ /* 遇到数字跳过 */
+ if (board[i][j] != '.') {
+ continue;
+ }
+ /* 依次将数组1到9填入当前位置 */
+ for (int k = '1'; k <= '9'; k++) {
+ /* 判断当前位置是否与满足条件，是则进入下一层 */
+ if (isValid(board, i, j, k)) {
+ board[i][j] = k;
+ /* 判断下一层递归之后是否找到一种解法，是则返回true */
+ if (backtracking(board, boardSize, boardColSize)) {
+ return true;
+ }
+ /* 回溯，将当前位置清零 */
+ board[i][j] = '.';
+ }
+ }
+ /* 若填入的9个数均不满足条件，返回false，说明此解法无效 */
+ return false;
+ }
+ }
+ /* 遍历完所有的棋盘，没有返回false，说明找到了解法，返回true */
+ return true;
+}
+
+void solveSudoku(char** board, int boardSize, int* boardColSize) {
+ bool res = backtracking(board, boardSize, boardColSize);
+}
```
+
+### Swift
+
+```swift
+func solveSudoku(_ board: inout [[Character]]) {
+ // 判断对应格子的值是否合法
+ func isValid(row: Int, col: Int, val: Character) -> Bool {
+ // 行中是否重复
+ for i in 0 ..< 9 {
+ if board[row][i] == val { return false }
+ }
+
+ // 列中是否重复
+ for j in 0 ..< 9 {
+ if board[j][col] == val { return false }
+ }
+
+ // 9方格内是否重复
+ let startRow = row / 3 * 3
+ let startCol = col / 3 * 3
+ for i in startRow ..< startRow + 3 {
+ for j in startCol ..< startCol + 3 {
+ if board[i][j] == val { return false }
+ }
+ }
+ return true
+ }
+
+ @discardableResult
+ func backtracking() -> Bool {
+ for i in 0 ..< board.count { // i：行坐标
+ for j in 0 ..< board[0].count { // j：列坐标
+ guard board[i][j] == "." else { continue } // 跳过已填写格子
+ // 填写格子
+ for val in 1 ... 9 {
+ let charVal = Character("\(val)")
+ guard isValid(row: i, col: j, val: charVal) else { continue } // 跳过不合法的
+ board[i][j] = charVal // 填写
+ if backtracking() { return true }
+ board[i][j] = "." // 回溯：擦除
+ }
+ return false // 遍历完数字都不行
+ }
+ }
+ return true // 没有不合法的，填写正确
+ }
+ backtracking()
+}
+```
+
+### Scala
+
+详细写法：
+
+```scala
+object Solution {
+
+ def solveSudoku(board: Array[Array[Char]]): Unit = {
+ backtracking(board)
+ }
+
+ def backtracking(board: Array[Array[Char]]): Boolean = {
+ for (i <- 0 until 9) {
+ for (j <- 0 until 9) {
+ if (board(i)(j) == '.') { // 必须是为 . 的数字才放数字
+ for (k <- '1' to '9') { // 这个位置放k是否合适
+ if (isVaild(i, j, k, board)) {
+ board(i)(j) = k
+ if (backtracking(board)) return true // 找到了立刻返回
+ board(i)(j) = '.' // 回溯
+ }
+ }
+ return false // 9个数都试完了，都不行就返回false
+ }
+ }
+ }
+ true // 遍历完所有的都没返回false，说明找到了
+ }
+
+ def isVaild(x: Int, y: Int, value: Char, board: Array[Array[Char]]): Boolean = {
+ // 行
+ for (i <- 0 until 9 ) {
+ if (board(i)(y) == value) {
+ return false
+ }
+ }
+
+ // 列
+ for (j <- 0 until 9) {
+ if (board(x)(j) == value) {
+ return false
+ }
+ }
+
+ // 宫
+ var row = (x / 3) * 3
+ var col = (y / 3) * 3
+ for (i <- row until row + 3) {
+ for (j <- col until col + 3) {
+ if (board(i)(j) == value) {
+ return false
+ }
+ }
+ }
+
+ true
+ }
+}
+```
+
+遵循Scala至简原则写法：
+
+```scala
+object Solution {
+
+ def solveSudoku(board: Array[Array[Char]]): Unit = {
+ backtracking(board)
+ }
+
+ def backtracking(board: Array[Array[Char]]): Boolean = {
+ // 双重for循环 + 循环守卫
+ for (i <- 0 until 9; j <- 0 until 9 if board(i)(j) == '.') {
+ // 必须是为 . 的数字才放数字，使用循环守卫判断该位置是否可以放置当前循环的数字
+ for (k <- '1' to '9' if isVaild(i, j, k, board)) { // 这个位置放k是否合适
+ board(i)(j) = k
+ if (backtracking(board)) return true // 找到了立刻返回
+ board(i)(j) = '.' // 回溯
+ }
+ return false // 9个数都试完了，都不行就返回false
+ }
+ true // 遍历完所有的都没返回false，说明找到了
+ }
+
+ def isVaild(x: Int, y: Int, value: Char, board: Array[Array[Char]]): Boolean = {
+ // 行，循环守卫进行判断
+ for (i <- 0 until 9 if board(i)(y) == value) return false
+ // 列，循环守卫进行判断
+ for (j <- 0 until 9 if board(x)(j) == value) return false
+ // 宫，循环守卫进行判断
+ var row = (x / 3) * 3
+ var col = (y / 3) * 3
+ for (i <- row until row + 3; j <- col until col + 3 if board(i)(j) == value) return false
+ true // 最终没有返回false，就说明该位置可以填写true
+ }
+}
+```
+### C#
+```csharp
+public class Solution
+{
+ public void SolveSudoku(char[][] board)
+ {
+ BackTracking(board);
+ }
+ public bool BackTracking(char[][] board)
+ {
+ for (int i = 0; i < board.Length; i++)
+ {
+ for (int j = 0; j < board[0].Length; j++)
+ {
+ if (board[i][j] != '.') continue;
+ for (char k = '1'; k <= '9'; k++)
+ {
+ if (IsValid(board, i, j, k))
+ {
+ board[i][j] = k;
+ if (BackTracking(board)) return true;
+ board[i][j] = '.';
+ }
+ }
+ return false;
+ }
+
+ }
+ return true;
+ }
+ public bool IsValid(char[][] board, int row, int col, char val)
+ {
+ for (int i = 0; i < 9; i++)
+ {
+ if (board[i][col] == val) return false;
+ }
+ for (int i = 0; i < 9; i++)
+ {
+ if (board[row][i] == val) return false;
+ }
+ int startRow = (row / 3) * 3;
+ int startCol = (col / 3) * 3;
+ for (int i = startRow; i < startRow + 3; i++)
+ {
+ for (int j = startCol; j < startCol + 3; j++)
+ {
+ if (board[i][j] == val) return false;
+ }
+ }
+ return true;
+ }
+}
+```
+
+
diff --git "a/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md" "b/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
old mode 100644
new mode 100755
index 7f62493878..d8dac0b45b
--- "a/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
+++ "b/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
@@ -1,53 +1,63 @@
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-> 看懂很容易，彻底掌握需要下功夫
-# 第39题. 组合总和
-题目链接：https://leetcode-cn.com/problems/combination-sum/
-给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+# 39. 组合总和
-candidates 中的数字可以无限制重复被选取。
+[力扣题目链接](https://leetcode.cn/problems/combination-sum/)
-说明：
+给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
-* 所有数字（包括 target）都是正整数。
-* 解集不能包含重复的组合。
+candidates 中的数字可以无限制重复被选取。
-示例 1：
-输入：candidates = [2,3,6,7], target = 7,
-所求解集为：
-[
- [7],
- [2,2,3]
-]
+说明：
-示例 2：
-输入：candidates = [2,3,5], target = 8,
-所求解集为：
-[
- [2,2,2,2],
- [2,3,3],
- [3,5]
-]
+* 所有数字（包括 target）都是正整数。
+* 解集不能包含重复的组合。
+
+示例 1：
+
+* 输入：candidates = [2,3,6,7], target = 7,
+* 所求解集为：
+ [
+ [7],
+ [2,2,3]
+ ]
+
+示例 2：
+
+* 输入：candidates = [2,3,5], target = 8,
+* 所求解集为：
+ [
+ [2,2,2,2],
+ [2,3,3],
+ [3,5]
+ ]
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[Leetcode:39. 组合总和讲解](https://www.bilibili.com/video/BV1KT4y1M7HJ)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
-# 思路
题目中的**无限制重复被选取，吓得我赶紧想想 出现0 可咋办**，然后看到下面提示：1 <= candidates[i] <= 200，我就放心了。
-本题和[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)，[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)和区别是：本题没有数量要求，可以无限重复，但是有总和的限制，所以间接的也是有个数的限制。
+本题和[77.组合](https://programmercarl.com/0077.组合.html)，[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)的区别是：本题没有数量要求，可以无限重复，但是有总和的限制，所以间接的也是有个数的限制。
本题搜索的过程抽象成树形结构如下：
-
-
+
注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！
-而在[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w) 中都可以知道要递归K层，因为要取k个元素的组合。
+而在[77.组合](https://programmercarl.com/0077.组合.html)和[216.组合总和III](https://programmercarl.com/0216.组合总和III.html) 中都可以知道要递归K层，因为要取k个元素的组合。
-## 回溯三部曲
+### 回溯三部曲
-* 递归函数参数
+* 递归函数参数
这里依然是定义两个全局变量，二维数组result存放结果集，数组path存放符合条件的结果。（这两个变量可以作为函数参数传入）
@@ -57,31 +67,31 @@ candidates 中的数字可以无限制重复被选取。
**本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？**
-我举过例子，如果是一个集合来求组合的话，就需要startIndex，例如：[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)，[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)。
+我举过例子，如果是一个集合来求组合的话，就需要startIndex，例如：[77.组合](https://programmercarl.com/0077.组合.html)，[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)。
-如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：[回溯算法：电话号码的字母组合](https://mp.weixin.qq.com/s/e2ua2cmkE_vpYjM3j6HY0A)
+如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：[17.电话号码的字母组合](https://programmercarl.com/0017.电话号码的字母组合.html)
-**注意以上我只是说求组合的情况，如果是排列问题，又是另一套分析的套路，后面我再讲解排列的时候就重点介绍**。
+**注意以上我只是说求组合的情况，如果是排列问题，又是另一套分析的套路，后面我在讲解排列的时候会重点介绍**。
代码如下：
-```
+```CPP
vector> result;
vector path;
-void backtracking(vector& candidates, int target, int sum, int startIndex)
+void backtracking(vector& candidates, int target, int sum, int startIndex)
```
* 递归终止条件
在如下树形结构中：
-
+
从叶子节点可以清晰看到，终止只有两种情况，sum大于target和sum等于target。
sum等于target的时候，需要收集结果，代码如下：
-```
+```CPP
if (sum > target) {
return;
}
@@ -91,15 +101,15 @@ if (sum == target) {
}
```
-* 单层搜索的逻辑
+* 单层搜索的逻辑
单层for循环依然是从startIndex开始，搜索candidates集合。
-**注意本题和[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)、[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)的一个区别是：本题元素为可重复选取的**。
+**注意本题和[77.组合](https://programmercarl.com/0077.组合.html)、[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)的一个区别是：本题元素为可重复选取的**。
如何重复选取呢，看代码，注释部分：
-```
+```CPP
for (int i = startIndex; i < candidates.size(); i++) {
sum += candidates[i];
path.push_back(candidates[i]);
@@ -109,9 +119,9 @@ for (int i = startIndex; i < candidates.size(); i++) {
}
```
-按照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中给出的模板，不难写出如下C++完整代码：
+按照[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)中给出的模板，不难写出如下C++完整代码：
-```
+```CPP
// 版本一
class Solution {
private:
@@ -144,11 +154,11 @@ public:
};
```
-## 剪枝优化
+### 剪枝优化
在这个树形结构中：
-
+
以及上面的版本一的代码大家可以看到，对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。
@@ -160,18 +170,18 @@ public:
如图：
-
+
for循环剪枝代码如下：
```
-for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)
+for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)
```
整体代码如下：（注意注释的部分）
-```
+```CPP
class Solution {
private:
vector> result;
@@ -202,17 +212,19 @@ public:
}
};
```
+* 时间复杂度: O(n * 2^n)，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此
+* 空间复杂度: O(target)
-# 总结
+## 总结
-本题和我们之前讲过的[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)、[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)有两点不同：
+本题和我们之前讲过的[77.组合](https://programmercarl.com/0077.组合.html)、[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)有两点不同：
-* 组合没有数量要求
-* 元素可无限重复选取
+* 组合没有数量要求
+* 元素可无限重复选取
针对这两个问题，我都做了详细的分析。
-并且给出了对于组合问题，什么时候用startIndex，什么时候不用，并用[回溯算法：电话号码的字母组合](https://mp.weixin.qq.com/s/e2ua2cmkE_vpYjM3j6HY0A)做了对比。
+并且给出了对于组合问题，什么时候用startIndex，什么时候不用，并用[17.电话号码的字母组合](https://programmercarl.com/0017.电话号码的字母组合.html)做了对比。
最后还给出了本题的剪枝优化，这个优化如果是初学者的话并不容易想到。
@@ -220,5 +232,430 @@ public:
可以看出我写的文章都会大量引用之前的文章，就是要不断作对比，分析其差异，然后给出代码解决的方法，这样才能彻底理解题目的本质与难点。
-**就酱，如果感觉很给力，就帮Carl宣传一波吧，哈哈**。
+
+
+
+
+## 其他语言版本
+
+
+### Java
+
+```Java
+// 剪枝优化
+class Solution {
+ public List> combinationSum(int[] candidates, int target) {
+ List> res = new ArrayList<>();
+ Arrays.sort(candidates); // 先进行排序
+ backtracking(res, new ArrayList<>(), candidates, target, 0, 0);
+ return res;
+ }
+
+ public void backtracking(List> res, List path, int[] candidates, int target, int sum, int idx) {
+ // 找到了数字和为 target 的组合
+ if (sum == target) {
+ res.add(new ArrayList<>(path));
+ return;
+ }
+
+ for (int i = idx; i < candidates.length; i++) {
+ // 如果 sum + candidates[i] > target 就终止遍历
+ if (sum + candidates[i] > target) break;
+ path.add(candidates[i]);
+ backtracking(res, path, candidates, target, sum + candidates[i], i);
+ path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
+ }
+ }
+}
+```
+
+### Python
+
+回溯（版本一）
+
+```python
+class Solution:
+
+ def backtracking(self, candidates, target, total, startIndex, path, result):
+ if total > target:
+ return
+ if total == target:
+ result.append(path[:])
+ return
+
+ for i in range(startIndex, len(candidates)):
+ total += candidates[i]
+ path.append(candidates[i])
+ self.backtracking(candidates, target, total, i, path, result) # 不用i+1了，表示可以重复读取当前的数
+ total -= candidates[i]
+ path.pop()
+
+ def combinationSum(self, candidates, target):
+ result = []
+ self.backtracking(candidates, target, 0, 0, [], result)
+ return result
+
+```
+
+回溯剪枝（版本一）
+
+```python
+class Solution:
+
+ def backtracking(self, candidates, target, total, startIndex, path, result):
+ if total == target:
+ result.append(path[:])
+ return
+
+ for i in range(startIndex, len(candidates)):
+ if total + candidates[i] > target:
+ break
+ total += candidates[i]
+ path.append(candidates[i])
+ self.backtracking(candidates, target, total, i, path, result)
+ total -= candidates[i]
+ path.pop()
+
+ def combinationSum(self, candidates, target):
+ result = []
+ candidates.sort() # 需要排序
+ self.backtracking(candidates, target, 0, 0, [], result)
+ return result
+
+```
+
+回溯（版本二）
+
+```python
+class Solution:
+ def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+ result =[]
+ self.backtracking(candidates, target, 0, [], result)
+ return result
+ def backtracking(self, candidates, target, startIndex, path, result):
+ if target == 0:
+ result.append(path[:])
+ return
+ if target < 0:
+ return
+ for i in range(startIndex, len(candidates)):
+ path.append(candidates[i])
+ self.backtracking(candidates, target - candidates[i], i, path, result)
+ path.pop()
+
+```
+
+回溯剪枝（版本二）
+
+```python
+class Solution:
+ def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+ result =[]
+ candidates.sort()
+ self.backtracking(candidates, target, 0, [], result)
+ return result
+ def backtracking(self, candidates, target, startIndex, path, result):
+ if target == 0:
+ result.append(path[:])
+ return
+
+ for i in range(startIndex, len(candidates)):
+ if target - candidates[i] < 0:
+ break
+ path.append(candidates[i])
+ self.backtracking(candidates, target - candidates[i], i, path, result)
+ path.pop()
+
+```
+
+### Go
+
+主要在于递归中传递下一个数字
+
+```go
+var (
+ res [][]int
+ path []int
+)
+func combinationSum(candidates []int, target int) [][]int {
+ res, path = make([][]int, 0), make([]int, 0, len(candidates))
+ sort.Ints(candidates) // 排序，为剪枝做准备
+ dfs(candidates, 0, target)
+ return res
+}
+
+func dfs(candidates []int, start int, target int) {
+ if target == 0 { // target 不断减小，如果为0说明达到了目标值
+ tmp := make([]int, len(path))
+ copy(tmp, path)
+ res = append(res, tmp)
+ return
+ }
+ for i := start; i < len(candidates); i++ {
+ if candidates[i] > target { // 剪枝，提前返回
+ break
+ }
+ path = append(path, candidates[i])
+ dfs(candidates, i, target - candidates[i])
+ path = path[:len(path) - 1]
+ }
+}
+```
+
+### JavaScript
+
+```js
+var combinationSum = function(candidates, target) {
+ const res = [], path = [];
+ candidates.sort((a,b)=>a-b); // 排序
+ backtracking(0, 0);
+ return res;
+ function backtracking(j, sum) {
+ if (sum === target) {
+ res.push(Array.from(path));
+ return;
+ }
+ for(let i = j; i < candidates.length; i++ ) {
+ const n = candidates[i];
+ if(n > target - sum) break;
+ path.push(n);
+ sum += n;
+ backtracking(i, sum);
+ path.pop();
+ sum -= n;
+ }
+ }
+};
+```
+
+### TypeScript
+
+```typescript
+function combinationSum(candidates: number[], target: number): number[][] {
+ const resArr: number[][] = [];
+ function backTracking(
+ candidates: number[], target: number,
+ startIndex: number, route: number[], curSum: number
+ ): void {
+ if (curSum > target) return;
+ if (curSum === target) {
+ resArr.push(route.slice());
+ return
+ }
+ for (let i = startIndex, length = candidates.length; i < length; i++) {
+ let tempVal: number = candidates[i];
+ route.push(tempVal);
+ backTracking(candidates, target, i, route, curSum + tempVal);
+ route.pop();
+ }
+ }
+ backTracking(candidates, target, 0, [], 0);
+ return resArr;
+};
+```
+
+### Rust
+
+```Rust
+impl Solution {
+ pub fn backtracking(result: &mut Vec>, path: &mut Vec, candidates: &Vec, target: i32, mut sum: i32, start_index: usize) {
+ if sum == target {
+ result.push(path.to_vec());
+ return;
+ }
+ for i in start_index..candidates.len() {
+ if sum + candidates[i] <= target {
+ sum += candidates[i];
+ path.push(candidates[i]);
+ Self::backtracking(result, path, candidates, target, sum, i);
+ sum -= candidates[i];
+ path.pop();
+ }
+ }
+ }
+
+ pub fn combination_sum(candidates: Vec, target: i32) -> Vec> {
+ let mut result: Vec> = Vec::new();
+ let mut path: Vec = Vec::new();
+ Self::backtracking(&mut result, &mut path, &candidates, target, 0, 0);
+ result
+ }
+}
+```
+
+### C
+
+```c
+int* path;
+int pathTop;
+int** ans;
+int ansTop;
+//记录每一个和等于target的path数组长度
+int* length;
+
+void backTracking(int target, int index, int* candidates, int candidatesSize, int sum) {
+ //若sum>=target就应该终止遍历
+ if(sum >= target) {
+ //若sum等于target，将当前的组合放入ans数组中
+ if(sum == target) {
+ int* tempPath = (int*)malloc(sizeof(int) * pathTop);
+ int j;
+ for(j = 0; j < pathTop; j++) {
+ tempPath[j] = path[j];
+ }
+ ans[ansTop] = tempPath;
+ length[ansTop++] = pathTop;
+ }
+ return ;
+ }
+
+ int i;
+ for(i = index; i < candidatesSize; i++) {
+ //将当前数字大小加入sum
+ sum+=candidates[i];
+ path[pathTop++] = candidates[i];
+ backTracking(target, i, candidates, candidatesSize, sum);
+ sum-=candidates[i];
+ pathTop--;
+ }
+}
+
+int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
+ //初始化变量
+ path = (int*)malloc(sizeof(int) * 50);
+ ans = (int**)malloc(sizeof(int*) * 200);
+ length = (int*)malloc(sizeof(int) * 200);
+ ansTop = pathTop = 0;
+ backTracking(target, 0, candidates, candidatesSize, 0);
+
+ //设置返回的数组大小
+ *returnSize = ansTop;
+ *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
+ int i;
+ for(i = 0; i < ansTop; i++) {
+ (*returnColumnSizes)[i] = length[i];
+ }
+ return ans;
+}
+```
+
+### Swift
+
+```swift
+func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
+ var result = [[Int]]()
+ var path = [Int]()
+ func backtracking(sum: Int, startIndex: Int) {
+ // 终止条件
+ if sum == target {
+ result.append(path)
+ return
+ }
+
+ let end = candidates.count
+ guard startIndex < end else { return }
+ for i in startIndex ..< end {
+ let sum = sum + candidates[i] // 使用局部变量隐藏回溯
+ if sum > target { continue } // 剪枝
+
+ path.append(candidates[i]) // 处理
+ backtracking(sum: sum, startIndex: i) // i不用+1以重复访问
+ path.removeLast() // 回溯
+ }
+ }
+ backtracking(sum: 0, startIndex: 0)
+ return result
+}
+```
+
+### Scala
+
+```scala
+object Solution {
+ import scala.collection.mutable
+ def combinationSum(candidates: Array[Int], target: Int): List[List[Int]] = {
+ var result = mutable.ListBuffer[List[Int]]()
+ var path = mutable.ListBuffer[Int]()
+
+ def backtracking(sum: Int, index: Int): Unit = {
+ if (sum == target) {
+ result.append(path.toList) // 如果正好等于target，就添加到结果集
+ return
+ }
+ // 应该是从当前索引开始的，而不是从0
+ // 剪枝优化：添加循环守卫，当sum + c(i) <= target的时候才循环，才可以进入下一次递归
+ for (i <- index until candidates.size if sum + candidates(i) <= target) {
+ path.append(candidates(i))
+ backtracking(sum + candidates(i), i)
+ path = path.take(path.size - 1)
+ }
+ }
+
+ backtracking(0, 0)
+ result.toList
+ }
+}
+```
+### C#
+```csharp
+public class Solution
+{
+ public IList> res = new List>();
+ public IList path = new List();
+ public IList> CombinationSum(int[] candidates, int target)
+ {
+ BackTracking(candidates, target, 0, 0);
+ return res;
+ }
+ public void BackTracking(int[] candidates, int target, int start, int sum)
+ {
+ if (sum > target) return;
+ if (sum == target)
+ {
+ res.Add(new List(path));
+ return;
+ }
+ for (int i = start; i < candidates.Length; i++)
+ {
+ sum += candidates[i];
+ path.Add(candidates[i]);
+ BackTracking(candidates, target, i, sum);
+ sum -= candidates[i];
+ path.RemoveAt(path.Count - 1);
+ }
+ }
+}
+
+// 剪枝优化
+public class Solution
+{
+ public IList> res = new List>();
+ public IList path = new List();
+ public IList> CombinationSum(int[] candidates, int target)
+ {
+ Array.Sort(candidates);
+ BackTracking(candidates, target, 0, 0);
+ return res;
+ }
+ public void BackTracking(int[] candidates, int target, int start, int sum)
+ {
+ if (sum > target) return;
+ if (sum == target)
+ {
+ res.Add(new List(path));
+ return;
+ }
+ for (int i = start; i < candidates.Length && sum + candidates[i] <= target; i++)
+ {
+ sum += candidates[i];
+ path.Add(candidates[i]);
+ BackTracking(candidates, target, i, sum);
+ sum -= candidates[i];
+ path.RemoveAt(path.Count - 1);
+ }
+ }
+}
+```
+
+
diff --git "a/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md" "b/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
old mode 100644
new mode 100755
index 6ff491dfab..0d3972662f
--- "a/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
+++ "b/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
@@ -1,50 +1,61 @@
-> 这篇可以说是全网把组合问题如何去重，讲的最清晰的了！
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
# 40.组合总和II
-题目链接：https://leetcode-cn.com/problems/combination-sum-ii/
+[力扣题目链接](https://leetcode.cn/problems/combination-sum-ii/)
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
-说明：
-所有数字（包括目标数）都是正整数。
-解集不能包含重复的组合。
-
-示例 1:
-输入: candidates = [10,1,2,7,6,1,5], target = 8,
-所求解集为:
-[
- [1, 7],
- [1, 2, 5],
- [2, 6],
- [1, 1, 6]
-]
-
-示例 2:
-输入: candidates = [2,5,2,1,2], target = 5,
-所求解集为:
-[
- [1,2,2],
- [5]
-]
+说明：
+所有数字（包括目标数）都是正整数。解集不能包含重复的组合。
+
+* 示例 1:
+* 输入: candidates = [10,1,2,7,6,1,5], target = 8,
+* 所求解集为:
+```
+[
+ [1, 7],
+ [1, 2, 5],
+ [2, 6],
+ [1, 1, 6]
+]
+```
+
+* 示例 2:
+* 输入: candidates = [2,5,2,1,2], target = 5,
+* 所求解集为:
+
+```
+[
+ [1,2,2],
+ [5]
+]
+```
+
+## 算法公开课
-# 思路
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[回溯算法中的去重，树层去重树枝去重，你弄清楚了没？| LeetCode:40.组合总和II](https://www.bilibili.com/video/BV12V4y1V73A)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
-这道题目和[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)如下区别：
+## 思路
+
+
+这道题目和[39.组合总和](https://programmercarl.com/0039.组合总和.html)如下区别：
1. 本题candidates 中的每个数字在每个组合中只能使用一次。
-2. 本题数组candidates的元素是有重复的，而[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)是无重复元素的数组candidates
+2. 本题数组candidates的元素是有重复的，而[39.组合总和](https://programmercarl.com/0039.组合总和.html)是无重复元素的数组candidates
-最后本题和[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)要求一样，解集不能包含重复的组合。
+最后本题和[39.组合总和](https://programmercarl.com/0039.组合总和.html)要求一样，解集不能包含重复的组合。
**本题的难点在于区别2中：集合（数组candidates）有重复元素，但还不能有重复的组合**。
一些同学可能想了：我把所有组合求出来，再用set或者map去重，这么做很容易超时！
-所以要在搜索的过程中就去掉重复组合。
+所以要在搜索的过程中就去掉重复组合。
很多同学在去重的问题上想不明白，其实很多题解也没有讲清楚，反正代码是能过的，感觉是那么回事，稀里糊涂的先把题目过了。
@@ -52,31 +63,34 @@ candidates 中的每个数字在每个组合中只能使用一次。
都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。**没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。**
-那么问题来了，我们是要同一树层上使用过，还是统一树枝上使用过呢？
+那么问题来了，我们是要同一树层上使用过，还是同一树枝上使用过呢？
回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。
+
**所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重**。
为了理解去重我们来举一个例子，candidates = [1, 1, 2], target = 3，（方便起见candidates已经排序了）
+**强调一下，树层去重的话，需要对数组排序！**
+
选择过程树形结构如图所示：
-
+
可以看到图中，每个节点相对于 [39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)我多加了used数组，这个used数组下面会重点介绍。
-## 回溯三部曲
+### 回溯三部曲
-* **递归函数参数**
+* **递归函数参数**
-与[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)套路相同，此题还需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。
+与[39.组合总和](https://programmercarl.com/0039.组合总和.html)套路相同，此题还需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。
这个集合去重的重任就是used来完成的。
代码如下：
-```
+```CPP
vector> result; // 存放组合集合
vector path; // 符合条件的组合
void backtracking(vector& candidates, int target, int sum, int startIndex, vector& used) {
@@ -84,12 +98,12 @@ void backtracking(vector& candidates, int target, int sum, int startIndex,
* **递归终止条件**
-与[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)相同，终止条件为 `sum > target` 和 `sum == target`。
+与[39.组合总和](https://programmercarl.com/0039.组合总和.html)相同，终止条件为 `sum > target` 和 `sum == target`。
代码如下：
-```
-if (sum > target) { // 这个条件其实可以省略
+```CPP
+if (sum > target) { // 这个条件其实可以省略
return;
}
if (sum == target) {
@@ -98,13 +112,13 @@ if (sum == target) {
}
```
-`sum > target` 这个条件其实可以省略，因为和在递归单层遍历的时候，会有剪枝的操作，下面会介绍到。
+`sum > target` 这个条件其实可以省略，因为在递归单层遍历的时候，会有剪枝的操作，下面会介绍到。
* **单层搜索的逻辑**
-这里与[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)最大的不同就是要去重了。
+这里与[39.组合总和](https://programmercarl.com/0039.组合总和.html)最大的不同就是要去重了。
-前面我们提到：要去重的是“同一树层上的使用过”，如果判断同一树层上元素（相同的元素）是否使用过了呢。
+前面我们提到：要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。
**如果`candidates[i] == candidates[i - 1]` 并且 `used[i - 1] == false`，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]**。
@@ -112,20 +126,28 @@ if (sum == target) {
这块比较抽象，如图：
-
+
我在图中将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的情况下：
-* used[i - 1] == true，说明同一树支candidates[i - 1]使用过
+* used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
* used[i - 1] == false，说明同一树层candidates[i - 1]使用过
+可能有的录友想，为什么 used[i - 1] == false 就是同一树层呢，因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。
+
+而 used[i - 1] == true，说明是进入下一层递归，去下一个数，所以是树枝上，如图所示：
+
+
+
+
**这块去重的逻辑很抽象，网上搜的题解基本没有能讲清楚的，如果大家之前思考过这个问题或者刷过这道题目，看到这里一定会感觉通透了很多！**
+
那么单层搜索的逻辑代码如下：
-```
+```CPP
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
- // used[i - 1] == true，说明同一树支candidates[i - 1]使用过
+ // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 要对同一树层使用过的元素进行跳过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
@@ -143,11 +165,10 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;
**注意sum + candidates[i] <= target为剪枝操作，在[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)有讲解过！**
-## C++代码
回溯三部曲分析完了，整体C++代码如下：
-```
+```CPP
class Solution {
private:
vector> result;
@@ -158,7 +179,7 @@ private:
return;
}
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
- // used[i - 1] == true，说明同一树支candidates[i - 1]使用过
+ // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 要对同一树层使用过的元素进行跳过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
@@ -187,15 +208,598 @@ public:
};
```
+* 时间复杂度: O(n * 2^n)
+* 空间复杂度: O(n)
-# 总结
+### 补充
-本题同样是求组合总和，但就是因为其数组candidates有重复元素，而要求不能有重复的组合，所以相对于[39.组合总和](https://mp.weixin.qq.com/s/FLg8G6EjVcxBjwCbzpACPw)难度提升了不少。
+这里直接用startIndex来去重也是可以的， 就不用used数组了。
+
+```CPP
+class Solution {
+private:
+ vector> result;
+ vector path;
+ void backtracking(vector& candidates, int target, int sum, int startIndex) {
+ if (sum == target) {
+ result.push_back(path);
+ return;
+ }
+ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
+ // 要对同一树层使用过的元素进行跳过
+ if (i > startIndex && candidates[i] == candidates[i - 1]) {
+ continue;
+ }
+ sum += candidates[i];
+ path.push_back(candidates[i]);
+ backtracking(candidates, target, sum, i + 1); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
+ sum -= candidates[i];
+ path.pop_back();
+ }
+ }
+
+public:
+ vector> combinationSum2(vector& candidates, int target) {
+ path.clear();
+ result.clear();
+ // 首先把给candidates排序，让其相同的元素都挨在一起。
+ sort(candidates.begin(), candidates.end());
+ backtracking(candidates, target, 0, 0);
+ return result;
+ }
+};
+
+```
+
+## 总结
+
+本题同样是求组合总和，但就是因为其数组candidates有重复元素，而要求不能有重复的组合，所以相对于[39.组合总和](https://programmercarl.com/0039.组合总和.html)难度提升了不少。
**关键是去重的逻辑，代码很简单，网上一搜一大把，但几乎没有能把这块代码含义讲明白的，基本都是给出代码，然后说这就是去重了，究竟怎么个去重法也是模棱两可**。
所以Carl有必要把去重的这块彻彻底底的给大家讲清楚，**就连“树层去重”和“树枝去重”都是我自创的词汇，希望对大家理解有帮助！**
-**就酱，如果感觉「代码随想录」诚意满满，就帮Carl宣传一波吧，感谢啦！**
+## 其他语言版本
+
+
+### Java
+**使用标记数组**
+```Java
+class Solution {
+ LinkedList path = new LinkedList<>();
+ List> ans = new ArrayList<>();
+ boolean[] used;
+ int sum = 0;
+
+ public List> combinationSum2(int[] candidates, int target) {
+ used = new boolean[candidates.length];
+ // 加标志数组，用来辅助判断同层节点是否已经遍历
+ Arrays.fill(used, false);
+ // 为了将重复的数字都放到一起，所以先进行排序
+ Arrays.sort(candidates);
+ backTracking(candidates, target, 0);
+ return ans;
+ }
+
+ private void backTracking(int[] candidates, int target, int startIndex) {
+ if (sum == target) {
+ ans.add(new ArrayList(path));
+ }
+ for (int i = startIndex; i < candidates.length; i++) {
+ if (sum + candidates[i] > target) {
+ break;
+ }
+ // 出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
+ if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
+ continue;
+ }
+ used[i] = true;
+ sum += candidates[i];
+ path.add(candidates[i]);
+ // 每个节点仅能选择一次，所以从下一位开始
+ backTracking(candidates, target, i + 1);
+ used[i] = false;
+ sum -= candidates[i];
+ path.removeLast();
+ }
+ }
+}
+
+```
+**不使用标记数组**
+```Java
+class Solution {
+ List> res = new ArrayList<>();
+ LinkedList path = new LinkedList<>();
+ int sum = 0;
+
+ public List> combinationSum2( int[] candidates, int target ) {
+ //为了将重复的数字都放到一起，所以先进行排序
+ Arrays.sort( candidates );
+ backTracking( candidates, target, 0 );
+ return res;
+ }
+
+ private void backTracking( int[] candidates, int target, int start ) {
+ if ( sum == target ) {
+ res.add( new ArrayList<>( path ) );
+ return;
+ }
+ for ( int i = start; i < candidates.length && sum + candidates[i] <= target; i++ ) {
+ //正确剔除重复解的办法
+ //跳过同一树层使用过的元素
+ if ( i > start && candidates[i] == candidates[i - 1] ) {
+ continue;
+ }
+
+ sum += candidates[i];
+ path.add( candidates[i] );
+ // i+1 代表当前组内元素只选取一次
+ backTracking( candidates, target, i + 1 );
+
+ int temp = path.getLast();
+ sum -= temp;
+ path.removeLast();
+ }
+ }
+}
+```
+
+### Python
+回溯
+```python
+class Solution:
+
+
+ def backtracking(self, candidates, target, total, startIndex, path, result):
+ if total == target:
+ result.append(path[:])
+ return
+
+ for i in range(startIndex, len(candidates)):
+ if i > startIndex and candidates[i] == candidates[i - 1]:
+ continue
+ if total + candidates[i] > target:
+ break
+
+ total += candidates[i]
+ path.append(candidates[i])
+ self.backtracking(candidates, target, total, i + 1, path, result)
+ total -= candidates[i]
+ path.pop()
+
+ def combinationSum2(self, candidates, target):
+ result = []
+ candidates.sort()
+ self.backtracking(candidates, target, 0, 0, [], result)
+ return result
+
+```
+回溯 使用used
+```python
+class Solution:
+
+
+ def backtracking(self, candidates, target, total, startIndex, used, path, result):
+ if total == target:
+ result.append(path[:])
+ return
+
+ for i in range(startIndex, len(candidates)):
+ # 对于相同的数字，只选择第一个未被使用的数字，跳过其他相同数字
+ if i > startIndex and candidates[i] == candidates[i - 1] and not used[i - 1]:
+ continue
+
+ if total + candidates[i] > target:
+ break
+
+ total += candidates[i]
+ path.append(candidates[i])
+ used[i] = True
+ self.backtracking(candidates, target, total, i + 1, used, path, result)
+ used[i] = False
+ total -= candidates[i]
+ path.pop()
+
+ def combinationSum2(self, candidates, target):
+ used = [False] * len(candidates)
+ result = []
+ candidates.sort()
+ self.backtracking(candidates, target, 0, 0, used, [], result)
+ return result
+
+```
+回溯优化
+```python
+class Solution:
+ def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
+ candidates.sort()
+ results = []
+ self.combinationSumHelper(candidates, target, 0, [], results)
+ return results
+
+ def combinationSumHelper(self, candidates, target, index, path, results):
+ if target == 0:
+ results.append(path[:])
+ return
+ for i in range(index, len(candidates)):
+ if i > index and candidates[i] == candidates[i - 1]:
+ continue
+ if candidates[i] > target:
+ break
+ path.append(candidates[i])
+ self.combinationSumHelper(candidates, target - candidates[i], i + 1, path, results)
+ path.pop()
+```
+### Go
+主要在于如何在回溯中去重
+
+**使用used数组**
+```go
+var (
+ res [][]int
+ path []int
+ used []bool
+)
+func combinationSum2(candidates []int, target int) [][]int {
+ res, path = make([][]int, 0), make([]int, 0, len(candidates))
+ used = make([]bool, len(candidates))
+ sort.Ints(candidates) // 排序，为剪枝做准备
+ dfs(candidates, 0, target)
+ return res
+}
+
+func dfs(candidates []int, start int, target int) {
+ if target == 0 { // target 不断减小，如果为0说明达到了目标值
+ tmp := make([]int, len(path))
+ copy(tmp, path)
+ res = append(res, tmp)
+ return
+ }
+ for i := start; i < len(candidates); i++ {
+ if candidates[i] > target { // 剪枝，提前返回
+ break
+ }
+ // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
+ // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
+ if i > 0 && candidates[i] == candidates[i-1] && used[i-1] == false {
+ continue
+ }
+ path = append(path, candidates[i])
+ used[i] = true
+ dfs(candidates, i+1, target - candidates[i])
+ used[i] = false
+ path = path[:len(path) - 1]
+ }
+}
+```
+**不使用used数组**
+```go
+var (
+ res [][]int
+ path []int
+)
+func combinationSum2(candidates []int, target int) [][]int {
+ res, path = make([][]int, 0), make([]int, 0, len(candidates))
+ sort.Ints(candidates) // 排序，为剪枝做准备
+ dfs(candidates, 0, target)
+ return res
+}
+
+func dfs(candidates []int, start int, target int) {
+ if target == 0 { // target 不断减小，如果为0说明达到了目标值
+ tmp := make([]int, len(path))
+ copy(tmp, path)
+ res = append(res, tmp)
+ return
+ }
+ for i := start; i < len(candidates); i++ {
+ if candidates[i] > target { // 剪枝，提前返回
+ break
+ }
+ // i != start 限制了这不对深度遍历到达的此值去重
+ if i != start && candidates[i] == candidates[i-1] { // 去重
+ continue
+ }
+ path = append(path, candidates[i])
+ dfs(candidates, i+1, target - candidates[i])
+ path = path[:len(path) - 1]
+ }
+}
+```
+### JavaScript
+
+```js
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum2 = function(candidates, target) {
+ const res = []; path = [], len = candidates.length;
+ candidates.sort((a,b)=>a-b);
+ backtracking(0, 0);
+ return res;
+ function backtracking(sum, i) {
+ if (sum === target) {
+ res.push(Array.from(path));
+ return;
+ }
+ for(let j = i; j < len; j++) {
+ const n = candidates[j];
+ if(j > i && candidates[j] === candidates[j-1]){
+ //若当前元素和前一个元素相等
+ //则本次循环结束，防止出现重复组合
+ continue;
+ }
+ //如果当前元素值大于目标值-总和的值
+ //由于数组已排序，那么该元素之后的元素必定不满足条件
+ //直接终止当前层的递归
+ if(n > target - sum) break;
+ path.push(n);
+ sum += n;
+ backtracking(sum, j + 1);
+ path.pop();
+ sum -= n;
+ }
+ }
+};
+```
+**使用used去重**
+
+```js
+var combinationSum2 = function(candidates, target) {
+ let res = [];
+ let path = [];
+ let total = 0;
+ const len = candidates.length;
+ candidates.sort((a, b) => a - b);
+ let used = new Array(len).fill(false);
+ const backtracking = (startIndex) => {
+ if (total === target) {
+ res.push([...path]);
+ return;
+ }
+ for(let i = startIndex; i < len && total < target; i++) {
+ const cur = candidates[i];
+ if (cur > target - total || (i > 0 && cur === candidates[i - 1] && !used[i - 1])) continue;
+ path.push(cur);
+ total += cur;
+ used[i] = true;
+ backtracking(i + 1);
+ path.pop();
+ total -= cur;
+ used[i] = false;
+ }
+ }
+ backtracking(0);
+ return res;
+};
+```
+
+### TypeScript
+
+```typescript
+function combinationSum2(candidates: number[], target: number): number[][] {
+ candidates.sort((a, b) => a - b);
+ const resArr: number[][] = [];
+ function backTracking(
+ candidates: number[], target: number,
+ curSum: number, startIndex: number, route: number[]
+ ) {
+ if (curSum > target) return;
+ if (curSum === target) {
+ resArr.push(route.slice());
+ return;
+ }
+ for (let i = startIndex, length = candidates.length; i < length; i++) {
+ if (i > startIndex && candidates[i] === candidates[i - 1]) {
+ continue;
+ }
+ let tempVal: number = candidates[i];
+ route.push(tempVal);
+ backTracking(candidates, target, curSum + tempVal, i + 1, route);
+ route.pop();
+
+ }
+ }
+ backTracking(candidates, target, 0, 0, []);
+ return resArr;
+};
+```
+
+### Rust
+
+```Rust
+impl Solution {
+ pub fn backtracking(result: &mut Vec>, path: &mut Vec, candidates: &Vec, target: i32, mut sum: i32, start_index: usize, used: &mut Vec) {
+ if sum == target {
+ result.push(path.to_vec());
+ return;
+ }
+ for i in start_index..candidates.len() {
+ if sum + candidates[i] <= target {
+ if i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false { continue; }
+ sum += candidates[i];
+ path.push(candidates[i]);
+ used[i] = true;
+ Self::backtracking(result, path, candidates, target, sum, i + 1, used);
+ used[i] = false;
+ sum -= candidates[i];
+ path.pop();
+ }
+ }
+ }
+
+ pub fn combination_sum2(candidates: Vec, target: i32) -> Vec> {
+ let mut result: Vec> = Vec::new();
+ let mut path: Vec = Vec::new();
+ let mut used: Vec = vec![false; candidates.len()];
+ let mut candidates = candidates;
+ candidates.sort();
+ Self::backtracking(&mut result, &mut path, &candidates, target, 0, 0, &mut used);
+ result
+ }
+}
+```
+
+### C
+
+```c
+int* path;
+int pathTop;
+int** ans;
+int ansTop;
+//记录ans中每一个一维数组的大小
+int* length;
+int cmp(const void* a1, const void* a2) {
+ return *((int*)a1) - *((int*)a2);
+}
+
+void backTracking(int* candidates, int candidatesSize, int target, int sum, int startIndex) {
+ if(sum >= target) {
+ //若sum等于target，复制当前path进入
+ if(sum == target) {
+ int* tempPath = (int*)malloc(sizeof(int) * pathTop);
+ int j;
+ for(j = 0; j < pathTop; j++) {
+ tempPath[j] = path[j];
+ }
+ length[ansTop] = pathTop;
+ ans[ansTop++] = tempPath;
+ }
+ return ;
+ }
+
+ int i;
+ for(i = startIndex; i < candidatesSize; i++) {
+ //对同一层树中使用过的元素跳过
+ if(i > startIndex && candidates[i] == candidates[i-1])
+ continue;
+ path[pathTop++] = candidates[i];
+ sum += candidates[i];
+ backTracking(candidates, candidatesSize, target, sum, i + 1);
+ //回溯
+ sum -= candidates[i];
+ pathTop--;
+ }
+}
+
+int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
+ path = (int*)malloc(sizeof(int) * 50);
+ ans = (int**)malloc(sizeof(int*) * 100);
+ length = (int*)malloc(sizeof(int) * 100);
+ pathTop = ansTop = 0;
+ //快速排序candidates，让相同元素挨到一起
+ qsort(candidates, candidatesSize, sizeof(int), cmp);
+
+ backTracking(candidates, candidatesSize, target, 0, 0);
+
+ *returnSize = ansTop;
+ *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
+ int i;
+ for(i = 0; i < ansTop; i++) {
+ (*returnColumnSizes)[i] = length[i];
+ }
+ return ans;
+}
+```
+
+### Swift
+
+```swift
+func combinationSum2(_ candidates: [Int], _ target: Int) -> [[Int]] {
+ // 为了方便去重复，先对集合排序
+ let candidates = candidates.sorted()
+ var result = [[Int]]()
+ var path = [Int]()
+ func backtracking(sum: Int, startIndex: Int) {
+ // 终止条件
+ if sum == target {
+ result.append(path)
+ return
+ }
+
+ let end = candidates.count
+ guard startIndex < end else { return }
+ for i in startIndex ..< end {
+ if i > startIndex, candidates[i] == candidates[i - 1] { continue } // 去重复
+ let sum = sum + candidates[i] // 使用局部变量隐藏回溯
+ if sum > target { continue } // 剪枝
+
+ path.append(candidates[i]) // 处理
+ backtracking(sum: sum, startIndex: i + 1) // i+1避免重复访问
+ path.removeLast() // 回溯
+ }
+ }
+ backtracking(sum: 0, startIndex: 0)
+ return result
+}
+```
+
+
+### Scala
+
+```scala
+object Solution {
+ import scala.collection.mutable
+ def combinationSum2(candidates: Array[Int], target: Int): List[List[Int]] = {
+ var res = mutable.ListBuffer[List[Int]]()
+ var path = mutable.ListBuffer[Int]()
+ var candidate = candidates.sorted
+
+ def backtracking(sum: Int, startIndex: Int): Unit = {
+ if (sum == target) {
+ res.append(path.toList)
+ return
+ }
+
+ for (i <- startIndex until candidate.size if sum + candidate(i) <= target) {
+ if (!(i > startIndex && candidate(i) == candidate(i - 1))) {
+ path.append(candidate(i))
+ backtracking(sum + candidate(i), i + 1)
+ path = path.take(path.size - 1)
+ }
+ }
+ }
+
+ backtracking(0, 0)
+ res.toList
+ }
+}
+```
+### C#
+```csharp
+public class Solution
+{
+ public List> res = new List>();
+ public List path = new List();
+ public IList> CombinationSum2(int[] candidates, int target)
+ {
+
+ Array.Sort(candidates);
+ BackTracking(candidates, target, 0, 0);
+ return res;
+ }
+ public void BackTracking(int[] candidates, int target, int start, int sum)
+ {
+ if (sum > target) return;
+ if (sum == target)
+ {
+ res.Add(new List(path));
+ return;
+ }
+ for (int i = start; i < candidates.Length && sum + candidates[i] <= target; i++)
+ {
+ if (i > start && candidates[i] == candidates[i - 1]) continue;
+ sum += candidates[i];
+ path.Add(candidates[i]);
+ BackTracking(candidates, target, i + 1, sum);
+ sum -= candidates[i];
+ path.RemoveAt(path.Count - 1);
+ }
+ }
+}
+```
diff --git "a/problems/0042.\346\216\245\351\233\250\346\260\264.md" "b/problems/0042.\346\216\245\351\233\250\346\260\264.md"
old mode 100644
new mode 100755
index 05cf9e08d2..62fbe270b7
--- "a/problems/0042.\346\216\245\351\233\250\346\260\264.md"
+++ "b/problems/0042.\346\216\245\351\233\250\346\260\264.md"
@@ -1,25 +1,57 @@
-# 题目链接
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-# 思路
+
+
+
+
+# 42. 接雨水
+
+[力扣题目链接](https://leetcode.cn/problems/trapping-rain-water/)
+
+给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
+
+示例 1：
+
+
+* 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
+* 输出：6
+* 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
+
+示例 2：
+
+* 输入：height = [4,2,0,3,2,5]
+* 输出：9
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[单调栈，经典来袭！LeetCode:42.接雨水](https://www.bilibili.com/video/BV1uD4y1u75P/)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
+
+
+## 思路
接雨水问题在面试中还是常见题目的，有必要好好讲一讲。
本文深度讲解如下三种方法：
-* 双指针法
-* 动态规划
+
+* 暴力解法
+* 双指针优化
* 单调栈
-## 双指针解法
+### 暴力解法
-这道题目暴力解法并不简单，我们来看一下思路。
+本题暴力解法也是也是使用双指针。
-首先要明确，要按照行来计算，还是按照列来计算。如图所示：
+首先要明确，要按照行来计算，还是按照列来计算。
-
+按照行来计算如图：
+
-
+按照列来计算如图：
+
-一些同学在实现暴力解法的时候，很容易一会按照行来计算一会按照列来计算，这样就会越写越乱。
+一些同学在实现的时候，很容易一会按照行来计算一会按照列来计算，这样就会越写越乱。
我个人倾向于按照列来计算，比较容易理解，接下来看一下按照列如何计算。
@@ -29,7 +61,7 @@
这句话可以有点绕，来举一个理解，例如求列4的雨水高度，如图：
-
+
列4 左侧最高的柱子是列3，高度为2（以下用lHeight表示）。
@@ -43,10 +75,11 @@
此时求出了列4的雨水体积。
-一样的方法，只要从头遍历一遍所有的列，然后求出每一列雨水的体积，相加之后就是总雨水的体积了。
+一样的方法，只要从头遍历一遍所有的列，然后求出每一列雨水的体积，相加之后就是总雨水的体积了。
首先从头遍历所有的列，并且**要注意第一个柱子和最后一个柱子不接雨水**，代码如下：
-```
+
+```CPP
for (int i = 0; i < height.size(); i++) {
// 第一个柱子和最后一个柱子不接雨水
if (i == 0 || i == height.size() - 1) continue;
@@ -55,7 +88,7 @@ for (int i = 0; i < height.size(); i++) {
在for循环中求左右两边最高柱子，代码如下：
-```
+```CPP
int rHeight = height[i]; // 记录右边柱子的最高高度
int lHeight = height[i]; // 记录左边柱子的最高高度
for (int r = i + 1; r < height.size(); r++) {
@@ -68,14 +101,14 @@ for (int l = i - 1; l >= 0; l--) {
最后，计算该列的雨水高度，代码如下：
-```
+```CPP
int h = min(lHeight, rHeight) - height[i];
if (h > 0) sum += h; // 注意只有h大于零的时候，在统计到总和中
```
整体代码如下：
-```
+```CPP
class Solution {
public:
int trap(vector& height) {
@@ -100,36 +133,28 @@ public:
};
```
-因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为O(n^2)。
-空间复杂度为O(1)。
-
-## 动态规划解法
+因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为O(n^2)，空间复杂度为O(1)。
-在上面的双指针解法，我们可以看到，只要知道左边柱子的最高高度 和 记录右边柱子的最高高度，就可以计算当前位置的雨水面积，这也是也列来计算的。
+力扣后面修改了后台测试数据，所以以上暴力解法超时了。
-即，当前列雨水面积：min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度
+### 双指针优化
-为了的到两边的最高高度，使用了双指针来遍历，每到一个柱子都向两边遍历一波。
-这其实是有重复计算的。
+在暴力解法中，我们可以看到只要记录左边柱子的最高高度 和 右边柱子的最高高度，就可以计算当前位置的雨水面积，这就是通过列来计算。
-我们把每一个位置的左边最高高度记录在一个数组上（maxLeft），右边最高高度记录在一个数组上（maxRight）。
+当前列雨水面积：min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度。
-避免的重复计算，者就用到了动态规划。
+为了得到两边的最高高度，使用了双指针来遍历，每到一个柱子都向两边遍历一遍，这其实是有重复计算的。我们把每一个位置的左边最高高度记录在一个数组上（maxLeft），右边最高高度记录在一个数组上（maxRight），这样就避免了重复计算。
-当前位置，左边的最高高度，是前一个位置的最高高度和本高度的最大值。
+当前位置，左边的最高高度是前一个位置的左边最高高度和本高度的最大值。
即从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);
从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);
-这样就找到递推公式。
-
-是不是地推公式还挺简单的，其实动态规划就是这样，只要想到了递推公式，其实就比较简单了。
-
代码如下：
-```
+```CPP
class Solution {
public:
int trap(vector& height) {
@@ -159,59 +184,61 @@ public:
};
```
-## 单调栈解法
+### 单调栈解法
+
+关于单调栈的理论基础，单调栈适合解决什么问题，单调栈的工作过程，大家可以先看这题讲解 [739. 每日温度](https://programmercarl.com/0739.每日温度.html)。
-这个解法可以说是最不好理解的了，所以下面我花了大量的篇幅来介绍这种方法。
+单调栈就是保持栈内元素有序。和[栈与队列：单调队列](https://programmercarl.com/0239.滑动窗口最大值.html)一样，需要我们自己维持顺序，没有现成的容器可以用。
-单调栈就是保持栈内元素有序。和[栈与队列：单调队列](https://mp.weixin.qq.com/s/8c6l2bO74xyMjph09gQtpA)一样，需要我们自己维持顺序，没有现成的容器可以用。
+通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。
+而接雨水这道题目，我们正需要寻找一个元素，右边最大元素以及左边最大元素，来计算雨水面积。
-### 准备工作
+#### 准备工作
那么本题使用单调栈有如下几个问题：
1. 首先单调栈是按照行方向来计算雨水，如图：
-
+
知道这一点，后面的就可以理解了。
2. 使用单调栈内元素的顺序
-从大到小还是从小打到呢？
+从大到小还是从小到大呢？
-要从栈底到栈头（元素从栈头弹出）是从大到小的顺序。
+从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。
因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。
如图：
-
+
+关于单调栈的顺序给大家一个总结： [739. 每日温度](https://programmercarl.com/0739.每日温度.html) 中求一个元素右边第一个更大元素，单调栈就是递增的，[84.柱状图中最大的矩形](https://programmercarl.com/0084.柱状图中最大的矩形.html)求一个元素右边第一个更小元素，单调栈就是递减的。
-3. 遇到相同高度的柱子怎么办。
+3. 遇到相同高度的柱子怎么办。
-遇到相同的元素，更新栈内下表，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。
+遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。
例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。
-因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。
+**因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度**。
如图所示：
-
-
-
+
4. 栈里要保存什么数值
-是用单调栈，其实是通过 长 * 宽 来计算雨水面积的。
+使用单调栈，也是通过 长 * 宽 来计算雨水面积的。
-长就是通过柱子的高度来计算，宽是通过柱子之间的下表来计算，
+长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算，
-那么栈里有没有必要存一个pair类型的元素，保存柱子的高度和下表呢。
+那么栈里有没有必要存一个pair类型的元素，保存柱子的高度和下标呢。
-其实不用，栈里就存放int类型的元素就行了，表示下表，想要知道对应的高度，通过height[stack.top()] 就知道弹出的下表对应的高度了。
+其实不用，栈里就存放下标就行，想要知道对应的高度，通过height[stack.top()] 就知道弹出的下标对应的高度了。
所以栈的定义如下：
@@ -221,13 +248,21 @@ stack st; // 存着下标，计算的时候用下标对应的柱子高度
明确了如上几点，我们再来看处理逻辑。
-### 单调栈处理逻辑
+#### 单调栈处理逻辑
+
+以下操作过程其实和 [739. 每日温度](https://programmercarl.com/0739.每日温度.html) 也是一样的，建议先做 [739. 每日温度](https://programmercarl.com/0739.每日温度.html)。
-先将下表0的柱子加入到栈中，`st.push(0);`。
+以下逻辑主要就是三种情况
-然后开始从下表1开始遍历所有的柱子，`for (int i = 1; i < height.size(); i++)`。
+* 情况一：当前遍历的元素（柱子）高度小于栈顶元素的高度 height[i] < height[st.top()]
+* 情况二：当前遍历的元素（柱子）高度等于栈顶元素的高度 height[i] == height[st.top()]
+* 情况三：当前遍历的元素（柱子）高度大于栈顶元素的高度 height[i] > height[st.top()]
-如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从大到小的顺序（从栈底到栈头）。
+先将下标0的柱子加入到栈中，`st.push(0);`。 栈中存放我们遍历过的元素，所以先将下标0加进来。
+
+然后开始从下标1开始遍历所有的柱子，`for (int i = 1; i < height.size(); i++)`。
+
+如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从小到大的顺序（从栈头到栈底）。
代码如下：
@@ -246,25 +281,27 @@ if (height[i] == height[st.top()]) { // 例如 5 5 1 7 这种情况
}
```
-如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：
+如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：
-
+
-取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下表记为mid，对应的高度为height[mid]（就是图中的高度1）。
+取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下标记为mid，对应的高度为height[mid]（就是图中的高度1）。
-栈顶元素st.top()，就是凹槽的左边位置，下表为st.top()，对应的高度为height[st.top()]（就是图中的高度2）。
+此时的栈顶元素st.top()，就是凹槽的左边位置，下标为st.top()，对应的高度为height[st.top()]（就是图中的高度2）。
-当前遍历的元素i，就是凹槽右边的位置，下表为i，对应的高度为height[i]（就是图中的高度3）。
+当前遍历的元素i，就是凹槽右边的位置，下标为i，对应的高度为height[i]（就是图中的高度3）。
-那么雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，代码为：`int h = min(height[st.top()], height[i]) - height[mid];`
+此时大家应该可以发现其实就是**栈顶和栈顶的下一个元素以及要入栈的元素，三个元素来接水！**
-雨水的宽度是 凹槽右边的下表 - 凹槽左边的下表 - 1（因为只求中间宽度），代码为：`int w = i - st.top() - 1 ;`
+那么雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，代码为：`int h = min(height[st.top()], height[i]) - height[mid];`
+
+雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），代码为：`int w = i - st.top() - 1 ;`
当前凹槽雨水的体积就是：`h * w`。
求当前凹槽雨水的体积代码如下：
-```
+```CPP
while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，持续跟新栈顶元素
int mid = st.top();
st.pop();
@@ -278,7 +315,7 @@ while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，
关键部分讲完了，整体代码如下：
-```
+```CPP
class Solution {
public:
int trap(vector& height) {
@@ -312,7 +349,7 @@ public:
以上代码冗余了一些，但是思路是清晰的，下面我将代码精简一下，如下：
-```
+```CPP
class Solution {
public:
int trap(vector& height) {
@@ -338,3 +375,719 @@ public:
精简之后的代码，大家就看不出去三种情况的处理了，貌似好像只处理的情况三，其实是把情况一和情况二融合了。 这样的代码不太利于理解。
+
+## 其他语言版本
+
+### Java:
+
+暴力解法：
+
+```java
+class Solution {
+ public int trap(int[] height) {
+ int sum = 0;
+ for (int i = 0; i < height.length; i++) {
+ // 第一个柱子和最后一个柱子不接雨水
+ if (i==0 || i== height.length - 1) continue;
+
+ int rHeight = height[i]; // 记录右边柱子的最高高度
+ int lHeight = height[i]; // 记录左边柱子的最高高度
+ for (int r = i+1; r < height.length; r++) {
+ if (height[r] > rHeight) rHeight = height[r];
+ }
+ for (int l = i-1; l >= 0; l--) {
+ if(height[l] > lHeight) lHeight = height[l];
+ }
+ int h = Math.min(lHeight, rHeight) - height[i];
+ if (h > 0) sum += h;
+ }
+ return sum;
+
+ }
+}
+```
+
+双指针：
+
+```java
+class Solution {
+ public int trap(int[] height) {
+ int length = height.length;
+ if (length <= 2) return 0;
+ int[] maxLeft = new int[length];
+ int[] maxRight = new int[length];
+
+ // 记录每个柱子左边柱子最大高度
+ maxLeft[0] = height[0];
+ for (int i = 1; i< length; i++) maxLeft[i] = Math.max(height[i], maxLeft[i-1]);
+
+ // 记录每个柱子右边柱子最大高度
+ maxRight[length - 1] = height[length - 1];
+ for(int i = length - 2; i >= 0; i--) maxRight[i] = Math.max(height[i], maxRight[i+1]);
+
+ // 求和
+ int sum = 0;
+ for (int i = 0; i < length; i++) {
+ int count = Math.min(maxLeft[i], maxRight[i]) - height[i];
+ if (count > 0) sum += count;
+ }
+ return sum;
+ }
+}
+```
+
+双指针优化
+```java
+class Solution {
+ public int trap(int[] height) {
+ if (height.length <= 2) {
+ return 0;
+ }
+ // 从两边向中间寻找最值
+ int maxLeft = height[0], maxRight = height[height.length - 1];
+ int l = 1, r = height.length - 2;
+ int res = 0;
+ while (l <= r) {
+ // 不确定上一轮是左边移动还是右边移动，所以两边都需更新最值
+ maxLeft = Math.max(maxLeft, height[l]);
+ maxRight = Math.max(maxRight, height[r]);
+ // 最值较小的一边所能装的水量已定，所以移动较小的一边。
+ if (maxLeft < maxRight) {
+ res += maxLeft - height[l ++];
+ } else {
+ res += maxRight - height[r --];
+ }
+ }
+ return res;
+ }
+}
+```
+
+单调栈法
+
+```java
+class Solution {
+ public int trap(int[] height){
+ int size = height.length;
+
+ if (size <= 2) return 0;
+
+ // in the stack, we push the index of array
+ // using height[] to access the real height
+ Stack stack = new Stack();
+ stack.push(0);
+
+ int sum = 0;
+ for (int index = 1; index < size; index++){
+ int stackTop = stack.peek();
+ if (height[index] < height[stackTop]){
+ stack.push(index);
+ }else if (height[index] == height[stackTop]){
+ // 因为相等的相邻墙，左边一个是不可能存放雨水的，所以pop左边的index, push当前的index
+ stack.pop();
+ stack.push(index);
+ }else{
+ //pop up all lower value
+ int heightAtIdx = height[index];
+ while (!stack.isEmpty() && (heightAtIdx > height[stackTop])){
+ int mid = stack.pop();
+
+ if (!stack.isEmpty()){
+ int left = stack.peek();
+
+ int h = Math.min(height[left], height[index]) - height[mid];
+ int w = index - left - 1;
+ int hold = h * w;
+ if (hold > 0) sum += hold;
+ stackTop = stack.peek();
+ }
+ }
+ stack.push(index);
+ }
+ }
+
+ return sum;
+ }
+}
+```
+
+### Python:
+
+暴力解法：
+
+```Python
+class Solution:
+ def trap(self, height: List[int]) -> int:
+ res = 0
+ for i in range(len(height)):
+ if i == 0 or i == len(height)-1: continue
+ lHight = height[i-1]
+ rHight = height[i+1]
+ for j in range(i-1):
+ if height[j] > lHight:
+ lHight = height[j]
+ for k in range(i+2,len(height)):
+ if height[k] > rHight:
+ rHight = height[k]
+ res1 = min(lHight,rHight) - height[i]
+ if res1 > 0:
+ res += res1
+ return res
+```
+
+双指针：
+
+```python
+class Solution:
+ def trap(self, height: List[int]) -> int:
+ leftheight, rightheight = [0]*len(height), [0]*len(height)
+
+ leftheight[0]=height[0]
+ for i in range(1,len(height)):
+ leftheight[i]=max(leftheight[i-1],height[i])
+ rightheight[-1]=height[-1]
+ for i in range(len(height)-2,-1,-1):
+ rightheight[i]=max(rightheight[i+1],height[i])
+
+ result = 0
+ for i in range(0,len(height)):
+ summ = min(leftheight[i],rightheight[i])-height[i]
+ result += summ
+ return result
+```
+
+单调栈
+
+```Python
+class Solution:
+ def trap(self, height: List[int]) -> int:
+ # 单调栈
+ '''
+ 单调栈是按照 行 的方向来计算雨水
+ 从栈顶到栈底的顺序：从小到大
+ 通过三个元素来接水：栈顶，栈顶的下一个元素，以及即将入栈的元素
+ 雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度
+ 雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度）
+ '''
+ # stack储存index，用于计算对应的柱子高度
+ stack = [0]
+ result = 0
+ for i in range(1, len(height)):
+ # 情况一
+ if height[i] < height[stack[-1]]:
+ stack.append(i)
+
+ # 情况二
+ # 当当前柱子高度和栈顶一致时，左边的一个是不可能存放雨水的，所以保留右侧新柱子
+ # 需要使用最右边的柱子来计算宽度
+ elif height[i] == height[stack[-1]]:
+ stack.pop()
+ stack.append(i)
+
+ # 情况三
+ else:
+ # 抛出所有较低的柱子
+ while stack and height[i] > height[stack[-1]]:
+ # 栈顶就是中间的柱子：储水槽，就是凹槽的地步
+ mid_height = height[stack[-1]]
+ stack.pop()
+ if stack:
+ right_height = height[i]
+ left_height = height[stack[-1]]
+ # 两侧的较矮一方的高度 - 凹槽底部高度
+ h = min(right_height, left_height) - mid_height
+ # 凹槽右侧下标 - 凹槽左侧下标 - 1: 只求中间宽度
+ w = i - stack[-1] - 1
+ # 体积：高乘宽
+ result += h * w
+ stack.append(i)
+ return result
+
+# 单调栈压缩版
+class Solution:
+ def trap(self, height: List[int]) -> int:
+ stack = [0]
+ result = 0
+ for i in range(1, len(height)):
+ while stack and height[i] > height[stack[-1]]:
+ mid_height = stack.pop()
+ if stack:
+ # 雨水高度是 min(凹槽左侧高度, 凹槽右侧高度) - 凹槽底部高度
+ h = min(height[stack[-1]], height[i]) - height[mid_height]
+ # 雨水宽度是 凹槽右侧的下标 - 凹槽左侧的下标 - 1
+ w = i - stack[-1] - 1
+ # 累计总雨水体积
+ result += h * w
+ stack.append(i)
+ return result
+
+```
+
+### Go:
+
+```go
+func trap(height []int) int {
+ var left, right, leftMax, rightMax, res int
+ right = len(height) - 1
+ for left < right {
+ if height[left] < height[right] {
+ if height[left] >= leftMax {
+ leftMax = height[left] // 设置左边最高柱子
+ } else {
+ res += leftMax - height[left] // //右边必定有柱子挡水，所以遇到所有值小于等于leftMax的，全部加入水池中
+ }
+ left++
+ } else {
+ if height[right] > rightMax {
+ rightMax = height[right] // //设置右边最高柱子
+ } else {
+ res += rightMax - height[right] // //左边必定有柱子挡水，所以，遇到所有值小于等于rightMax的，全部加入水池
+ }
+ right--
+ }
+ }
+ return res
+}
+```
+
+双指针解法：
+
+```go
+func trap(height []int) int {
+ sum:=0
+ n:=len(height)
+ lh:=make([]int,n)
+ rh:=make([]int,n)
+ lh[0]=height[0]
+ rh[n-1]=height[n-1]
+ for i:=1;i=0;i--{
+ rh[i]=max(rh[i+1],height[i])
+ }
+ for i:=1;i0{
+ sum+=h
+ }
+ }
+ return sum
+}
+func max(a,b int)int{
+ if a>b{
+ return a
+ }
+ return b
+}
+func min(a,b int)int{
+ if a height[st[len(st)-1]] {
+ top := st[len(st)-1]
+ st = st[:len(st)-1]
+ if len(st) != 0 {
+ tmp := (min(height[i], height[st[len(st)-1]]) - height[top]) * (i - st[len(st)-1] - 1)
+ res += tmp
+ }
+ }
+ st = append(st, i)
+ }
+ }
+ return res
+}
+
+
+func min(x, y int) int {
+ if x >= y {
+ return y
+ }
+ return x
+}
+```
+
+单调栈压缩版：
+
+```go
+func trap(height []int) int {
+ stack := make([]int, 0)
+ res := 0
+
+ // 无需事先将第一个柱子的坐标入栈，因为它会在该for循环的最后入栈
+ for i := 0; i < len(height); i ++ {
+ // 满足栈不为空并且当前柱子高度大于栈顶对应的柱子高度的情况时
+ for len(stack) > 0 && height[stack[len(stack) - 1]] < height[i] {
+ // 获得凹槽高度
+ mid := height[stack[len(stack) - 1]]
+ // 凹槽坐标出栈
+ stack = stack[: len(stack) - 1]
+
+ // 如果栈不为空则此时栈顶元素为左侧柱子坐标
+ if len(stack) > 0 {
+ // 求得雨水高度
+ h := min(height[i], height[stack[len(stack) - 1]]) - mid
+ // 求得雨水宽度
+ w := i - stack[len(stack) - 1] - 1
+ res += h * w
+ }
+ }
+ // 如果栈为空或者当前柱子高度小于等于栈顶对应的柱子高度时入栈
+ stack = append(stack, i)
+ }
+ return res
+}
+
+func min(x, y int) int {
+ if x < y {
+ return x
+ }
+ return y
+}
+```
+
+### JavaScript:
+
+```javascript
+//暴力解法
+var trap = function(height) {
+ const len = height.length;
+ let sum = 0;
+ for(let i = 0; i < len; i++){
+ // 第一个柱子和最后一个柱子不接雨水
+ if(i == 0 || i == len - 1) continue;
+ let rHeight = height[i]; // 记录右边柱子的最高高度
+ let lHeight = height[i]; // 记录左边柱子的最高高度
+ for(let r = i + 1; r < len; r++){
+ if(height[r] > rHeight) rHeight = height[r];
+ }
+ for(let l = i - 1; l >= 0; l--){
+ if(height[l] > lHeight) lHeight = height[l];
+ }
+ let h = Math.min(lHeight, rHeight) - height[i];
+ if(h > 0) sum += h;
+ }
+ return sum;
+};
+
+//双指针
+var trap = function(height) {
+ const len = height.length;
+ if(len <= 2) return 0;
+ const maxLeft = new Array(len).fill(0);
+ const maxRight = new Array(len).fill(0);
+ // 记录每个柱子左边柱子最大高度
+ maxLeft[0] = height[0];
+ for(let i = 1; i < len; i++){
+ maxLeft[i] = Math.max(height[i], maxLeft[i - 1]);
+ }
+ // 记录每个柱子右边柱子最大高度
+ maxRight[len - 1] = height[len - 1];
+ for(let i = len - 2; i >= 0; i--){
+ maxRight[i] = Math.max(height[i], maxRight[i + 1]);
+ }
+ // 求和
+ let sum = 0;
+ for(let i = 0; i < len; i++){
+ let count = Math.min(maxLeft[i], maxRight[i]) - height[i];
+ if(count > 0) sum += count;
+ }
+ return sum;
+};
+
+//单调栈 js数组作为栈
+var trap = function(height) {
+ const len = height.length;
+ if(len <= 2) return 0; // 可以不加
+ const st = [];// 存着下标，计算的时候用下标对应的柱子高度
+ st.push(0);
+ let sum = 0;
+ for(let i = 1; i < len; i++){
+ if(height[i] < height[st[st.length - 1]]){ // 情况一
+ st.push(i);
+ }
+ if (height[i] == height[st[st.length - 1]]) { // 情况二
+ st.pop(); // 其实这一句可以不加，效果是一样的，但处理相同的情况的思路却变了。
+ st.push(i);
+ } else { // 情况三
+ while (st.length !== 0 && height[i] > height[st[st.length - 1]]) { // 注意这里是while
+ let mid = st[st.length - 1];
+ st.pop();
+ if (st.length !== 0) {
+ let h = Math.min(height[st[st.length - 1]], height[i]) - height[mid];
+ let w = i - st[st.length - 1] - 1; // 注意减一，只求中间宽度
+ sum += h * w;
+ }
+ }
+ st.push(i);
+ }
+ }
+ return sum;
+};
+
+//单调栈 简洁版本 只处理情况三
+var trap = function(height) {
+ const len = height.length;
+ if(len <= 2) return 0; // 可以不加
+ const st = [];// 存着下标，计算的时候用下标对应的柱子高度
+ st.push(0);
+ let sum = 0;
+ for(let i = 1; i < len; i++){ // 只处理的情况三，其实是把情况一和情况二融合了
+ while (st.length !== 0 && height[i] > height[st[st.length - 1]]) { // 注意这里是while
+ let mid = st[st.length - 1];
+ st.pop();
+ if (st.length !== 0) {
+ let h = Math.min(height[st[st.length - 1]], height[i]) - height[mid];
+ let w = i - st[st.length - 1] - 1; // 注意减一，只求中间宽度
+ sum += h * w;
+ }
+ }
+ st.push(i);
+ }
+ return sum;
+};
+```
+
+### TypeScript:
+
+暴力解法：
+
+```typescript
+function trap(height: number[]): number {
+ const length: number = height.length;
+ let resVal: number = 0;
+ for (let i = 0; i < length; i++) {
+ let leftMaxHeight: number = height[i],
+ rightMaxHeight: number = height[i];
+ let leftIndex: number = i - 1,
+ rightIndex: number = i + 1;
+ while (leftIndex >= 0) {
+ if (height[leftIndex] > leftMaxHeight)
+ leftMaxHeight = height[leftIndex];
+ leftIndex--;
+ }
+ while (rightIndex < length) {
+ if (height[rightIndex] > rightMaxHeight)
+ rightMaxHeight = height[rightIndex];
+ rightIndex++;
+ }
+ resVal += Math.min(leftMaxHeight, rightMaxHeight) - height[i];
+ }
+ return resVal;
+};
+```
+
+双指针：
+
+```typescript
+function trap(height: number[]): number {
+ const length: number = height.length;
+ const leftMaxHeightDp: number[] = [],
+ rightMaxHeightDp: number[] = [];
+ leftMaxHeightDp[0] = height[0];
+ rightMaxHeightDp[length - 1] = height[length - 1];
+ for (let i = 1; i < length; i++) {
+ leftMaxHeightDp[i] = Math.max(height[i], leftMaxHeightDp[i - 1]);
+ }
+ for (let i = length - 2; i >= 0; i--) {
+ rightMaxHeightDp[i] = Math.max(height[i], rightMaxHeightDp[i + 1]);
+ }
+ let resVal: number = 0;
+ for (let i = 0; i < length; i++) {
+ resVal += Math.min(leftMaxHeightDp[i], rightMaxHeightDp[i]) - height[i];
+ }
+ return resVal;
+};
+```
+
+单调栈：
+
+```typescript
+function trap(height: number[]): number {
+ const length: number = height.length;
+ const stack: number[] = [];
+ stack.push(0);
+ let resVal: number = 0;
+ for (let i = 1; i < length; i++) {
+ let top = stack[stack.length - 1];
+ if (height[top] > height[i]) {
+ stack.push(i);
+ } else if (height[top] === height[i]) {
+ stack.pop();
+ stack.push(i);
+ } else {
+ while (stack.length > 0 && height[top] < height[i]) {
+ let mid = stack.pop();
+ if (stack.length > 0) {
+ let left = stack[stack.length - 1];
+ let h = Math.min(height[left], height[i]) - height[mid];
+ let w = i - left - 1;
+ resVal += h * w;
+ top = stack[stack.length - 1];
+ }
+ }
+ stack.push(i);
+ }
+ }
+ return resVal;
+};
+```
+
+### C:
+
+一种更简便的双指针方法：
+
+之前的双指针方法的原理是固定“底”的位置，往两边找比它高的“壁”，循环若干次求和。
+
+我们逆向思维，把“壁”用两个初始位置在数组首末位置的指针表示，“壁”往中间推，同样可以让每个“底”都能找到最高的“壁”
+
+本质上就是改变了运算方向，从而减少了重复运算
+
+代码如下：
+
+```C
+int trap(int* height, int heightSize) {
+ int ans = 0;
+ int left = 0, right = heightSize - 1; //初始化两个指针到左右两边
+ int leftMax = 0, rightMax = 0; //这两个值用来记录左右的“壁”的最高值
+ while (left < right) { //两个指针重合就结束
+ leftMax = fmax(leftMax, height[left]);
+ rightMax = fmax(rightMax, height[right]);
+ if (leftMax < rightMax) {
+ ans += leftMax - height[left]; //这里考虑的是下标为left的“底”能装多少水
+ ++left;//指针的移动次序是这个方法的关键
+ //这里左指针右移是因为左“墙”较矮，左边这一片实际情况下的盛水量是受制于这个矮的左“墙”的
+ //而较高的右边在实际情况下的限制条件可能不是当前的左“墙”，比如限制条件可能是右“墙”，就能装更高的水，
+ }
+ else {
+ ans += rightMax - height[right]; //同理，考虑下标为right的元素
+ --right;
+ }
+ }
+ return ans;
+}
+```
+
+* 时间复杂度 O(n)
+* 空间复杂度 O(1)
+
+### Rust:
+
+双指针
+
+```rust
+impl Solution {
+ pub fn trap(height: Vec) -> i32 {
+ let n = height.len();
+ let mut max_left = vec![0; height.len()];
+ let mut max_right = vec![0; height.len()];
+ max_left.iter_mut().zip(max_right.iter_mut().rev()).enumerate().fold((0, 0), |(lm, rm), (idx, (x, y))| {
+ let lmax = lm.max(height[idx]);
+ let rmax = rm.max(height[n - 1 - idx]);
+ *x = lmax; *y = rmax;
+ (lmax, rmax)
+ });
+ height.iter().enumerate().fold(0, |acc, (idx, x)| {
+ let h = max_left[idx].min(max_right[idx]);
+ if h > 0 { h - x + acc } else { acc }
+ })
+ }
+}
+```
+
+单调栈
+
+```rust
+impl Solution {
+ pub fn trap(height: Vec) -> i32 {
+ let mut stack = vec![];
+ let mut ans = 0;
+ for (right_pos, &right_h) in height.iter().enumerate() {
+ while !stack.is_empty() && height[*stack.last().unwrap()] <= right_h {
+ let mid_pos = stack.pop().unwrap();
+ if !stack.is_empty() {
+ let left_pos = *stack.last().unwrap();
+ let left_h = height[left_pos];
+ let top = std::cmp::min(left_h, right_h);
+ if top > height[mid_pos] {
+ ans += (top - height[mid_pos]) * (right_pos - left_pos - 1) as i32;
+ }
+ }
+ }
+ stack.push(right_pos);
+ }
+ ans
+ }
+}
+```
+
+Rust
+
+双指针
+
+```rust
+impl Solution {
+ pub fn trap(height: Vec) -> i32 {
+ let n = height.len();
+ let mut max_left = vec![0; height.len()];
+ let mut max_right = vec![0; height.len()];
+ max_left.iter_mut().zip(max_right.iter_mut().rev()).enumerate().fold((0, 0), |(lm, rm), (idx, (x, y))| {
+ let lmax = lm.max(height[idx]);
+ let rmax = rm.max(height[n - 1 - idx]);
+ *x = lmax; *y = rmax;
+ (lmax, rmax)
+ });
+ height.iter().enumerate().fold(0, |acc, (idx, x)| {
+ let h = max_left[idx].min(max_right[idx]);
+ if h > 0 { h - x + acc } else { acc }
+ })
+ }
+}
+```
+
+单调栈
+
+```rust
+impl Solution {
+ pub fn trap(height: Vec) -> i32 {
+ let mut stack = vec![];
+ let mut ans = 0;
+ for (right_pos, &right_h) in height.iter().enumerate() {
+ while !stack.is_empty() && height[*stack.last().unwrap()] <= right_h {
+ let mid_pos = stack.pop().unwrap();
+ if !stack.is_empty() {
+ let left_pos = *stack.last().unwrap();
+ let left_h = height[left_pos];
+ let top = std::cmp::min(left_h, right_h);
+ if top > height[mid_pos] {
+ ans += (top - height[mid_pos]) * (right_pos - left_pos - 1) as i32;
+ }
+ }
+ }
+ stack.push(right_pos);
+ }
+ ans
+ }
+}
+```
+
diff --git "a/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md" "b/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
old mode 100644
new mode 100755
index a079b66617..c20cdc65e6
--- "a/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
+++ "b/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -1,43 +1,82 @@
-## 题目链接
-https://leetcode-cn.com/problems/jump-game-ii/
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-## 思路
+> 相对于[贪心算法：跳跃游戏](https://mp.weixin.qq.com/s/606_N9j8ACKCODoCbV1lSA)难了不少，做好心理准备！
-本题相对于[0055.跳跃游戏](https://github.com/youngyangyang04/leetcode/blob/master/problems/0053.最大子序和.md)还是难了不少。
+# 45.跳跃游戏 II
-本题要计算最大步数，那么就要想清楚什么时候步数加一？
+[力扣题目链接](https://leetcode.cn/problems/jump-game-ii/)
-**这里需要统计两个距离，当前可移动距离和下一步最远距离**。
+给定一个非负整数数组，你最初位于数组的第一个位置。
-如果移动范围超过当前可移动距离，那么就必须再走一步来达到增加可移动距离的目的。
+数组中的每个元素代表你在该位置可以跳跃的最大长度。
+
+你的目标是使用最少的跳跃次数到达数组的最后一个位置。
+
+示例:
+
+- 输入: [2,3,1,1,4]
+- 输出: 2
+- 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+
+说明:
+假设你总是可以到达数组的最后一个位置。
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[贪心算法，最少跳几步还得看覆盖范围 | LeetCode： 45.跳跃游戏 II](https://www.bilibili.com/video/BV1Y24y1r7XZ)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
+
+本题相对于[55.跳跃游戏](https://programmercarl.com/0055.跳跃游戏.html)还是难了不少。
+
+但思路是相似的，还是要看最大覆盖范围。
+
+本题要计算最少步数，那么就要想清楚什么时候步数才一定要加一呢？
+
+贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。
+
+思路虽然是这样，但在写代码的时候还不能真的能跳多远就跳多远，那样就不知道下一步最远能跳到哪里了。
+
+**所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！**
+
+**这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖**。
+
+如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。
如图：
-
+
+
+**图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）**
### 方法一
-这里还是有个特殊情况需要考虑，如果当前可移动距离的终点就是是集合终点，那么就不用增加步数了，因为不能再往后走了。
+从图中可以看出来，就是移动下标达到了当前覆盖的最远距离下标时，步数就要加一，来增加覆盖距离。最后的步数就是最少步数。
-详情可看代码（详细注释）
+这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时
-```
+- 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。
+- 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。
+
+C++代码如下：（详细注释）
+
+```CPP
// 版本一
class Solution {
public:
int jump(vector& nums) {
if (nums.size() == 1) return 0;
- int curDistance = 0; // 当前可移动距离
+ int curDistance = 0; // 当前覆盖最远距离下标
int ans = 0; // 记录走的最大步数
- int nextDistance = 0; // 下一步最远距离
+ int nextDistance = 0; // 下一步覆盖最远距离下标
for (int i = 0; i < nums.size(); i++) {
- nextDistance = max(nums[i] + i, nextDistance);
- if (i == curDistance) { // 遇到当前可移动距离的终点
- if (curDistance != nums.size() - 1) { // 如果当前可移动距离的终点不是集合终点
- ans++; // 需要走下一步
- curDistance = nextDistance; // 更新下一步最远距离的范围
- if (nextDistance >= nums.size() - 1) break; // 下一步最远距离已经可以达到终点，结束循环
- } else break; // 当前可移动距离的终点是集合终点
+ nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖最远距离下标
+ if (i == curDistance) { // 遇到当前覆盖最远距离下标
+ ans++; // 需要走下一步
+ curDistance = nextDistance; // 更新当前覆盖最远距离下标（相当于加油了）
+ if (nextDistance >= nums.size() - 1) break; // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
}
}
return ans;
@@ -45,28 +84,41 @@ public:
};
```
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
### 方法二
依然是贪心，思路和方法一差不多，代码可以简洁一些。
-在方法一种，处理 当前可移动距离的终点 是不是集合终点 来判断ans是否要做相应的加一操作。
+**针对于方法一的特殊情况，可以统一处理**，即：移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不考虑是不是终点的情况。
-其实可以用 for循环遍历的时候i < nums.size() - 1，这样就是默认最后一步，一定是可以到终点的。
+想要达到这样的效果，只要让移动下标，最大只能移动到 nums.size - 2 的地方就可以了。
-代码如下：
+因为当移动下标指向 nums.size - 2 时：
-```
+- 如果移动下标等于当前覆盖最大距离下标， 需要再走一步（即 ans++），因为最后一步一定是可以到的终点。（题目假设总是可以到达数组的最后一个位置），如图：
+ 
+
+- 如果移动下标不等于当前覆盖最大距离下标，说明当前覆盖最远距离就可以直接达到终点了，不需要再走一步。如图：
+
+
+代码如下：
+
+```CPP
+// 版本二
class Solution {
public:
int jump(vector& nums) {
- int curDistance = 0;
- int ans = 0; // 记录走的最大步数，初始为0
- int nextDistance = 0; // 每走一步获得的跳跃范围
- for (int i = 0; i < nums.size() - 1; i++) { // 注意这里是小于nums.size() - 1
- nextDistance = max(nums[i] + i, nextDistance);
- if (i == curDistance) { // 遇到本次跳跃范围的终点
- curDistance = nextDistance;
+ int curDistance = 0; // 当前覆盖的最远距离下标
+ int ans = 0; // 记录走的最大步数
+ int nextDistance = 0; // 下一步覆盖的最远距离下标
+ for (int i = 0; i < nums.size() - 1; i++) { // 注意这里是小于nums.size() - 1，这是关键所在
+ nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖的最远距离下标
+ if (i == curDistance) { // 遇到当前覆盖的最远距离下标
+ curDistance = nextDistance; // 更新当前覆盖的最远距离下标
ans++;
}
}
@@ -74,3 +126,417 @@ public:
}
};
```
+
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
+
+可以看出版本二的代码相对于版本一简化了不少！
+
+**其精髓在于控制移动下标 i 只移动到 nums.size() - 2 的位置**，所以移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不用考虑别的了。
+
+## 总结
+
+相信大家可以发现，这道题目相当于[55.跳跃游戏](https://programmercarl.com/0055.跳跃游戏.html)难了不止一点。
+
+但代码又十分简单，贪心就是这么巧妙。
+
+理解本题的关键在于：**以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点**，这个范围内最少步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位。
+
+## 其他语言版本
+
+### Java
+
+```Java
+// 版本一
+class Solution {
+ public int jump(int[] nums) {
+ if (nums == null || nums.length == 0 || nums.length == 1) {
+ return 0;
+ }
+ //记录跳跃的次数
+ int count=0;
+ //当前的覆盖最大区域
+ int curDistance = 0;
+ //最大的覆盖区域
+ int maxDistance = 0;
+ for (int i = 0; i < nums.length; i++) {
+ //在可覆盖区域内更新最大的覆盖区域
+ maxDistance = Math.max(maxDistance,i+nums[i]);
+ //说明当前一步，再跳一步就到达了末尾
+ if (maxDistance>=nums.length-1){
+ count++;
+ break;
+ }
+ //走到当前覆盖的最大区域时，更新下一步可达的最大区域
+ if (i==curDistance){
+ curDistance = maxDistance;
+ count++;
+ }
+ }
+ return count;
+ }
+}
+```
+
+```java
+// 版本二
+class Solution {
+ public int jump(int[] nums) {
+ int result = 0;
+ // 当前覆盖的最远距离下标
+ int end = 0;
+ // 下一步覆盖的最远距离下标
+ int temp = 0;
+ for (int i = 0; i <= end && end < nums.length - 1; ++i) {
+ temp = Math.max(temp, i + nums[i]);
+ // 可达位置的改变次数就是跳跃次数
+ if (i == end) {
+ end = temp;
+ result++;
+ }
+ }
+ return result;
+ }
+}
+```
+
+### Python
+贪心（版本一）
+```python
+class Solution:
+ def jump(self, nums):
+ if len(nums) == 1:
+ return 0
+
+ cur_distance = 0 # 当前覆盖最远距离下标
+ ans = 0 # 记录走的最大步数
+ next_distance = 0 # 下一步覆盖最远距离下标
+
+ for i in range(len(nums)):
+ next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖最远距离下标
+ if i == cur_distance: # 遇到当前覆盖最远距离下标
+ ans += 1 # 需要走下一步
+ cur_distance = next_distance # 更新当前覆盖最远距离下标（相当于加油了）
+ if next_distance >= len(nums) - 1: # 当前覆盖最远距离达到数组末尾，不用再做ans++操作，直接结束
+ break
+
+ return ans
+
+```
+贪心（版本二）
+
+```python
+class Solution:
+ def jump(self, nums):
+ cur_distance = 0 # 当前覆盖的最远距离下标
+ ans = 0 # 记录走的最大步数
+ next_distance = 0 # 下一步覆盖的最远距离下标
+
+ for i in range(len(nums) - 1): # 注意这里是小于len(nums) - 1，这是关键所在
+ next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖的最远距离下标
+ if i == cur_distance: # 遇到当前覆盖的最远距离下标
+ cur_distance = next_distance # 更新当前覆盖的最远距离下标
+ ans += 1
+
+ return ans
+
+```
+贪心（版本三） 类似‘55-跳跃游戏’写法
+
+```python
+class Solution:
+ def jump(self, nums) -> int:
+ if len(nums)==1: # 如果数组只有一个元素，不需要跳跃，步数为0
+ return 0
+
+ i = 0 # 当前位置
+ count = 0 # 步数计数器
+ cover = 0 # 当前能够覆盖的最远距离
+
+ while i <= cover: # 当前位置小于等于当前能够覆盖的最远距离时循环
+ for i in range(i, cover+1): # 遍历从当前位置到当前能够覆盖的最远距离之间的所有位置
+ cover = max(nums[i]+i, cover) # 更新当前能够覆盖的最远距离
+ if cover >= len(nums)-1: # 如果当前能够覆盖的最远距离达到或超过数组的最后一个位置，直接返回步数+1
+ return count+1
+ count += 1 # 每一轮遍历结束后，步数+1
+
+
+```
+动态规划
+```python
+class Solution:
+ def jump(self, nums: List[int]) -> int:
+ result = [10**4+1] * len(nums) # 初始化结果数组，初始值为一个较大的数
+ result[0] = 0 # 起始位置的步数为0
+
+ for i in range(len(nums)): # 遍历数组
+ for j in range(nums[i] + 1): # 在当前位置能够跳跃的范围内遍历
+ if i + j < len(nums): # 确保下一跳的位置不超过数组范围
+ result[i + j] = min(result[i + j], result[i] + 1) # 更新到达下一跳位置的最少步数
+
+ return result[-1] # 返回到达最后一个位置的最少步数
+
+
+```
+
+### Go
+
+
+```go
+/**
+ * @date: 2024 Jan 06
+ * @time: 13:44
+ * @author: Chris
+**/
+// 贪心算法优化版
+
+// 记录步骤规则：每超过上一次可达最大范围，需要跳跃一次，次数+1
+// 记录位置：i == lastDistance + 1
+func jump(nums []int) int {
+ // 根据题目规则，初始位置为nums[0]
+ lastDistance := 0 // 上一次覆盖范围
+ curDistance := 0 // 当前覆盖范围（可达最大范围）
+ minStep := 0 // 记录最少跳跃次数
+
+ for i := 0; i < len(nums); i++ {
+ if i == lastDistance+1 { // 在上一次可达范围+1的位置，记录步骤
+ minStep++ // 跳跃次数+1
+ lastDistance = curDistance // 记录时才可以更新
+ }
+ curDistance = max(nums[i]+i, curDistance) // 更新当前可达的最大范围
+ }
+ return minStep
+}
+```
+
+```go
+// 贪心版本一
+func jump(nums []int) int {
+ n := len(nums)
+ if n == 1 {
+ return 0
+ }
+ cur, next := 0, 0
+ step := 0
+ for i := 0; i < n; i++ {
+ next = max(nums[i]+i, next)
+ if i == cur {
+ if cur != n-1 {
+ step++
+ cur = next
+ if cur >= n-1 {
+ return step
+ }
+ } else {
+ return step
+ }
+ }
+ }
+ return step
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+
+```go
+// 贪心版本二
+func jump(nums []int) int {
+ n := len(nums)
+ if n == 1 {
+ return 0
+ }
+ cur, next := 0, 0
+ step := 0
+ for i := 0; i < n-1; i++ {
+ next = max(nums[i]+i, next)
+ if i == cur {
+ cur = next
+ step++
+ }
+ }
+ return step
+}
+
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+```
+
+### JavaScript
+
+```Javascript
+var jump = function(nums) {
+ let curIndex = 0
+ let nextIndex = 0
+ let steps = 0
+ for(let i = 0; i < nums.length - 1; i++) {
+ nextIndex = Math.max(nums[i] + i, nextIndex)
+ if(i === curIndex) {
+ curIndex = nextIndex
+ steps++
+ }
+ }
+
+ return steps
+};
+```
+
+### TypeScript
+
+```typescript
+function jump(nums: number[]): number {
+ const length: number = nums.length;
+ let curFarthestIndex: number = 0,
+ nextFarthestIndex: number = 0;
+ let curIndex: number = 0;
+ let stepNum: number = 0;
+ while (curIndex < length - 1) {
+ nextFarthestIndex = Math.max(nextFarthestIndex, curIndex + nums[curIndex]);
+ if (curIndex === curFarthestIndex) {
+ curFarthestIndex = nextFarthestIndex;
+ stepNum++;
+ }
+ curIndex++;
+ }
+ return stepNum;
+}
+```
+
+### Scala
+
+```scala
+object Solution {
+ def jump(nums: Array[Int]): Int = {
+ if (nums.length == 0) return 0
+ var result = 0 // 记录走的最大步数
+ var curDistance = 0 // 当前覆盖最远距离下标
+ var nextDistance = 0 // 下一步覆盖最远距离下标
+ for (i <- nums.indices) {
+ nextDistance = math.max(nums(i) + i, nextDistance) // 更新下一步覆盖最远距离下标
+ if (i == curDistance) {
+ if (curDistance != nums.length - 1) {
+ result += 1
+ curDistance = nextDistance
+ if (nextDistance >= nums.length - 1) return result
+ } else {
+ return result
+ }
+ }
+ }
+ result
+ }
+}
+```
+
+### Rust
+
+```Rust
+//版本一
+impl Solution {
+ pub fn jump(nums: Vec) -> i32 {
+ if nums.len() == 1 {
+ return 0;
+ }
+ let mut cur_distance = 0;
+ let mut ans = 0;
+ let mut next_distance = 0;
+ for (i, &n) in nums.iter().enumerate().take(nums.len() - 1) {
+ next_distance = (n as usize + i).max(next_distance);
+ if i == cur_distance {
+ if cur_distance < nums.len() - 1 {
+ ans += 1;
+ cur_distance = next_distance;
+ if next_distance >= nums.len() - 1 {
+ break;
+ };
+ } else {
+ break;
+ }
+ }
+ }
+ ans
+ }
+}
+```
+
+```Rust
+//版本二
+impl Solution {
+ pub fn jump(nums: Vec) -> i32 {
+ if nums.len() == 1 {
+ return 0;
+ }
+ let mut cur_distance = 0;
+ let mut ans = 0;
+ let mut next_distance = 0;
+ for (i, &n) in nums.iter().enumerate().take(nums.len() - 1) {
+ next_distance = (n as usize + i).max(next_distance);
+ if i == cur_distance {
+ cur_distance = next_distance;
+ ans += 1;
+ }
+ }
+ ans
+ }
+}
+```
+### C
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int jump(int* nums, int numsSize) {
+ if(numsSize == 1){
+ return 0;
+ }
+ int count = 0;
+ // 记录当前能走的最远距离
+ int curDistance = 0;
+ // 记录下一步能走的最远距离
+ int nextDistance = 0;
+ for(int i = 0; i < numsSize; i++){
+ nextDistance = max(i + nums[i], nextDistance);
+ // 下标到了当前的最大距离
+ if(i == nextDistance){
+ count++;
+ curDistance = nextDistance;
+ }
+ }
+ return count;
+}
+```
+
+### C#
+
+```csharp
+// 版本二
+public class Solution
+{
+ public int Jump(int[] nums)
+ {
+ int cur = 0, next = 0, step = 0;
+ for (int i = 0; i < nums.Length - 1; i++)
+ {
+ next = Math.Max(next, i + nums[i]);
+ if (i == cur)
+ {
+ cur = next;
+ step++;
+ }
+ }
+ return step;
+ }
+}
+```
+
+
diff --git "a/problems/0046.\345\205\250\346\216\222\345\210\227.md" "b/problems/0046.\345\205\250\346\216\222\345\210\227.md"
old mode 100644
new mode 100755
index b083f78f4a..356f51b5a8
--- "a/problems/0046.\345\205\250\346\216\222\345\210\227.md"
+++ "b/problems/0046.\345\205\250\346\216\222\345\210\227.md"
@@ -1,62 +1,522 @@
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
-## 题目地址
-https://leetcode-cn.com/problems/permutations/
-## 思路
+# 46.全排列
-先写逻辑，再确认参数，先把for循环写出来，在写 结束语句，在写 函数参数。
+[力扣题目链接](https://leetcode.cn/problems/permutations/)
-这道题目树形结构还不太一样
+给定一个 没有重复 数字的序列，返回其所有可能的全排列。
-## 解法
+示例:
+* 输入: [1,2,3]
+* 输出:
+[
+ [1,2,3],
+ [1,3,2],
+ [2,1,3],
+ [2,3,1],
+ [3,1,2],
+ [3,2,1]
+]
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[组合与排列的区别，回溯算法求解的时候，有何不同？| LeetCode：46.全排列](https://www.bilibili.com/video/BV19v4y1S79W/)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+
+## 思路
+
+
+此时我们已经学习了[77.组合问题](https://programmercarl.com/0077.组合.html)、 [131.分割回文串](https://programmercarl.com/0131.分割回文串.html)和[78.子集问题](https://programmercarl.com/0078.子集.html)，接下来看一看排列问题。
+
+相信这个排列问题就算是让你用for循环暴力把结果搜索出来，这个暴力也不是很好写。
+
+所以正如我们在[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)所讲的为什么回溯法是暴力搜索，效率这么低，还要用它？
+
+**因为一些问题能暴力搜出来就已经很不错了！**
+
+我以[1,2,3]为例，抽象成树形结构如下：
+
+
+
+
+### 回溯三部曲
+
+* 递归函数参数
+
+**首先排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方**。
+
+可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。
+
+但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:
+
+
+
+代码如下：
+
+```cpp
+vector> result;
+vector path;
+void backtracking (vector& nums, vector& used)
+```
+
+* 递归终止条件
+
+
+
+可以看出叶子节点，就是收割结果的地方。
+
+那么什么时候，算是到达叶子节点呢？
+
+当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。
+
+代码如下：
+
+```cpp
+// 此时说明找到了一组
+if (path.size() == nums.size()) {
+ result.push_back(path);
+ return;
+}
+```
+
+* 单层搜索的逻辑
+
+这里和[77.组合问题](https://programmercarl.com/0077.组合.html)、[131.切割问题](https://programmercarl.com/0131.分割回文串.html)和[78.子集问题](https://programmercarl.com/0078.子集.html)最大的不同就是for循环里不用startIndex了。
+
+因为排列问题，每次都要从头开始搜索，例如元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1。
+
+**而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次**。
+
+代码如下：
+
+```cpp
+for (int i = 0; i < nums.size(); i++) {
+ if (used[i] == true) continue; // path里已经收录的元素，直接跳过
+ used[i] = true;
+ path.push_back(nums[i]);
+ backtracking(nums, used);
+ path.pop_back();
+ used[i] = false;
+}
```
+
+整体C++代码如下：
+
+```CPP
class Solution {
public:
vector> result;
- void backtracking (vector& nums, vector& vec, vector& used) {
+ vector path;
+ void backtracking (vector& nums, vector& used) {
// 此时说明找到了一组
- if (vec.size() == nums.size()) {
- result.push_back(vec);
+ if (path.size() == nums.size()) {
+ result.push_back(path);
return;
}
-
for (int i = 0; i < nums.size(); i++) {
- if (used[i] == false) {
- used[i] = true;
- vec.push_back(nums[i]);
- backtracking(nums, vec, used);
- vec.pop_back();
- used[i] = false;
- }
+ if (used[i] == true) continue; // path里已经收录的元素，直接跳过
+ used[i] = true;
+ path.push_back(nums[i]);
+ backtracking(nums, used);
+ path.pop_back();
+ used[i] = false;
}
}
vector> permute(vector& nums) {
+ result.clear();
+ path.clear();
vector used(nums.size(), false);
- vector vec;
- backtracking(nums, vec, used);
+ backtracking(nums, used);
return result;
}
};
```
+* 时间复杂度: O(n!)
+* 空间复杂度: O(n)
+
+## 总结
+
+大家此时可以感受出排列问题的不同：
+
+* 每层都是从0开始搜索而不是startIndex
+* 需要used数组记录path里都放了哪些元素了
+
+排列问题是回溯算法解决的经典题目，大家可以好好体会体会。
+
-这是一个思路：
+## 其他语言版本
+
+### Java
+
+```java
class Solution {
-public:
- vector> res;
- vector> permute(vector& nums) {
- solve(nums, 0);
- return res;
+
+ List> result = new ArrayList<>();// 存放符合条件结果的集合
+ LinkedList path = new LinkedList<>();// 用来存放符合条件结果
+ boolean[] used;
+ public List> permute(int[] nums) {
+ if (nums.length == 0){
+ return result;
+ }
+ used = new boolean[nums.length];
+ permuteHelper(nums);
+ return result;
+ }
+
+ private void permuteHelper(int[] nums){
+ if (path.size() == nums.length){
+ result.add(new ArrayList<>(path));
+ return;
+ }
+ for (int i = 0; i < nums.length; i++){
+ if (used[i]){
+ continue;
+ }
+ used[i] = true;
+ path.add(nums[i]);
+ permuteHelper(nums);
+ path.removeLast();
+ used[i] = false;
+ }
+ }
+}
+```
+
+```java
+// 解法2：通过判断path中是否存在数字，排除已经选择的数字
+class Solution {
+ List> result = new ArrayList<>();
+ LinkedList path = new LinkedList<>();
+ public List> permute(int[] nums) {
+ if (nums.length == 0) return result;
+ backtrack(nums, path);
+ return result;
+ }
+ public void backtrack(int[] nums, LinkedList path) {
+ if (path.size() == nums.length) {
+ result.add(new ArrayList<>(path));
+ return;
+ }
+ for (int i =0; i < nums.length; i++) {
+ // 如果path中已有，则跳过
+ if (path.contains(nums[i])) {
+ continue;
+ }
+ path.add(nums[i]);
+ backtrack(nums, path);
+ path.removeLast();
+ }
+ }
+}
+```
+
+### Python
+回溯 使用used
+```python
+class Solution:
+ def permute(self, nums):
+ result = []
+ self.backtracking(nums, [], [False] * len(nums), result)
+ return result
+
+ def backtracking(self, nums, path, used, result):
+ if len(path) == len(nums):
+ result.append(path[:])
+ return
+ for i in range(len(nums)):
+ if used[i]:
+ continue
+ used[i] = True
+ path.append(nums[i])
+ self.backtracking(nums, path, used, result)
+ path.pop()
+ used[i] = False
+
+```
+
+### Go
+```Go
+var (
+ res [][]int
+ path []int
+ st []bool // state的缩写
+)
+func permute(nums []int) [][]int {
+ res, path = make([][]int, 0), make([]int, 0, len(nums))
+ st = make([]bool, len(nums))
+ dfs(nums, 0)
+ return res
+}
+
+func dfs(nums []int, cur int) {
+ if cur == len(nums) {
+ tmp := make([]int, len(path))
+ copy(tmp, path)
+ res = append(res, tmp)
+ }
+ for i := 0; i < len(nums); i++ {
+ if !st[i] {
+ path = append(path, nums[i])
+ st[i] = true
+ dfs(nums, cur + 1)
+ st[i] = false
+ path = path[:len(path)-1]
+ }
}
- void solve(vector &nums, int idx) {
- if(idx == nums.size()-1 || nums.size() == 0){
- res.push_back(nums);
+}
+```
+
+### JavaScript
+
+```js
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function(nums) {
+ const res = [], path = [];
+ backtracking(nums, nums.length, []);
+ return res;
+
+ function backtracking(n, k, used) {
+ if(path.length === k) {
+ res.push(Array.from(path));
return;
}
- for(int i = idx; i < nums.size(); i++){
- swap(nums[idx], nums[i]);
- solve(nums, idx+1);
- swap(nums[idx], nums[i]);
+ for (let i = 0; i < k; i++ ) {
+ if(used[i]) continue;
+ path.push(n[i]);
+ used[i] = true; // 同支
+ backtracking(n, k, used);
+ path.pop();
+ used[i] = false;
}
}
};
+
+```
+
+### TypeScript
+
+```typescript
+function permute(nums: number[]): number[][] {
+ const resArr: number[][] = [];
+ const helperSet: Set = new Set();
+ backTracking(nums, []);
+ return resArr;
+ function backTracking(nums: number[], route: number[]): void {
+ if (route.length === nums.length) {
+ resArr.push([...route]);
+ return;
+ }
+ let tempVal: number;
+ for (let i = 0, length = nums.length; i < length; i++) {
+ tempVal = nums[i];
+ if (!helperSet.has(tempVal)) {
+ route.push(tempVal);
+ helperSet.add(tempVal);
+ backTracking(nums, route);
+ route.pop();
+ helperSet.delete(tempVal);
+ }
+ }
+ }
+};
+```
+
+### Rust
+
+```Rust
+impl Solution {
+ fn backtracking(result: &mut Vec>, path: &mut Vec, nums: &Vec, used: &mut Vec) {
+ let len = nums.len();
+ if path.len() == len {
+ result.push(path.clone());
+ return;
+ }
+ for i in 0..len {
+ if used[i] == true { continue; }
+ used[i] = true;
+ path.push(nums[i]);
+ Self::backtracking(result, path, nums, used);
+ path.pop();
+ used[i] = false;
+ }
+ }
+
+ pub fn permute(nums: Vec) -> Vec> {
+ let mut result: Vec> = Vec::new();
+ let mut path: Vec
+ 
+ 
+ 
+
+
+
-
-# 我的公众号
-
-更多精彩文章持续更新，微信搜索：「代码随想录」第一时间围观，关注后回复：「简历模板」「java」「C++」「python」等关键字就可以获得我多年整理出来的学习资料。
-
-**每天8：35准时为你推送一篇经典面试题目，帮你梳理算法知识体系，轻松学习算法！**，并且公众号里有大量学习资源，也有我自己的学习心得和方法总结，更有很多志同道合的好伙伴在这里打卡学习，来看看就你知道了，相信一定会有所收获！
-
-
-
-
+ * [关于时间复杂度，你不知道的都在这里！](./problems/前序/时间复杂度.md)
+ * [O(n)的算法居然超时了，此时的n究竟是多大？](./problems/前序/算法超时.md)
+ * [通过一道面试题目，讲一讲递归算法的时间复杂度！](./problems/前序/递归算法的时间复杂度.md)
+ * [关于空间复杂度，可能有几个疑问？](./problems/前序/空间复杂度.md)
+ * [递归算法的时间与空间复杂度分析！](./problems/前序/递归算法的时间与空间复杂度分析.md)
+ * [刷了这么多题，你了解自己代码的内存消耗么？](./problems/前序/内存消耗.md)
+
+
+1. [关于二叉树，你该了解这些！](./problems/二叉树理论基础.md)
+2. [二叉树：二叉树的递归遍历](./problems/二叉树的递归遍历.md)
+3. [二叉树：二叉树的迭代遍历](./problems/二叉树的迭代遍历.md)
+4. [二叉树：二叉树的统一迭代法](./problems/二叉树的统一迭代法.md)
+5. [二叉树：二叉树的层序遍历](./problems/0102.二叉树的层序遍历.md)
+6. [二叉树：226.翻转二叉树](./problems/0226.翻转二叉树.md)
+7. [本周小结！（二叉树）](./problems/周总结/20200927二叉树周末总结.md)
+8. [二叉树：101.对称二叉树](./problems/0101.对称二叉树.md)
+9. [二叉树：104.二叉树的最大深度](./problems/0104.二叉树的最大深度.md)
+10. [二叉树：111.二叉树的最小深度](./problems/0111.二叉树的最小深度.md)
+11. [二叉树：222.完全二叉树的节点个数](./problems/0222.完全二叉树的节点个数.md)
+12. [二叉树：110.平衡二叉树](./problems/0110.平衡二叉树.md)
+13. [二叉树：257.二叉树的所有路径](./problems/0257.二叉树的所有路径.md)
+14. [本周总结！（二叉树）](./problems/周总结/20201003二叉树周末总结.md)
+16. [二叉树：404.左叶子之和](./problems/0404.左叶子之和.md)
+17. [二叉树：513.找树左下角的值](./problems/0513.找树左下角的值.md)
+18. [二叉树：112.路径总和](./problems/0112.路径总和.md)
+19. [二叉树：106.构造二叉树](./problems/0106.从中序与后序遍历序列构造二叉树.md)
+20. [二叉树：654.最大二叉树](./problems/0654.最大二叉树.md)
+21. [本周小结！（二叉树）](./problems/周总结/20201010二叉树周末总结.md)
+22. [二叉树：617.合并两个二叉树](./problems/0617.合并二叉树.md)
+23. [二叉树：700.二叉搜索树登场！](./problems/0700.二叉搜索树中的搜索.md)
+24. [二叉树：98.验证二叉搜索树](./problems/0098.验证二叉搜索树.md)
+25. [二叉树：530.搜索树的最小绝对差](./problems/0530.二叉搜索树的最小绝对差.md)
+26. [二叉树：501.二叉搜索树中的众数](./problems/0501.二叉搜索树中的众数.md)
+27. [二叉树：236.公共祖先问题](./problems/0236.二叉树的最近公共祖先.md)
+28. [本周小结！（二叉树）](./problems/周总结/20201017二叉树周末总结.md)
+29. [二叉树：235.搜索树的最近公共祖先](./problems/0235.二叉搜索树的最近公共祖先.md)
+30. [二叉树：701.搜索树中的插入操作](./problems/0701.二叉搜索树中的插入操作.md)
+31. [二叉树：450.搜索树中的删除操作](./problems/0450.删除二叉搜索树中的节点.md)
+32. [二叉树：669.修剪二叉搜索树](./problems/0669.修剪二叉搜索树.md)
+33. [二叉树：108.将有序数组转换为二叉搜索树](./problems/0108.将有序数组转换为二叉搜索树.md)
+34. [二叉树：538.把二叉搜索树转换为累加树](./problems/0538.把二叉搜索树转换为累加树.md)
+35. [二叉树：总结篇！（需要掌握的二叉树技能都在这里了）](./problems/二叉树总结篇.md)
+
+
+1. [关于回溯算法，你该了解这些！](./problems/回溯算法理论基础.md)
+2. [回溯算法：77.组合](./problems/0077.组合.md)
+3. [回溯算法：77.组合优化](./problems/0077.组合优化.md)
+4. [回溯算法：216.组合总和III](./problems/0216.组合总和III.md)
+5. [回溯算法：17.电话号码的字母组合](./problems/0017.电话号码的字母组合.md)
+6. [本周小结！（回溯算法系列一）](./problems/周总结/20201030回溯周末总结.md)
+7. [回溯算法：39.组合总和](./problems/0039.组合总和.md)
+8. [回溯算法：40.组合总和II](./problems/0040.组合总和II.md)
+9. [回溯算法：131.分割回文串](./problems/0131.分割回文串.md)
+10. [回溯算法：93.复原IP地址](./problems/0093.复原IP地址.md)
+11. [回溯算法：78.子集](./problems/0078.子集.md)
+12. [本周小结！（回溯算法系列二）](./problems/周总结/20201107回溯周末总结.md)
+13. [回溯算法：90.子集II](./problems/0090.子集II.md)
+14. [回溯算法：491.递增子序列](./problems/0491.递增子序列.md)
+15. [回溯算法：46.全排列](./problems/0046.全排列.md)
+16. [回溯算法：47.全排列II](./problems/0047.全排列II.md)
+17. [本周小结！（回溯算法系列三）](./problems/周总结/20201112回溯周末总结.md)
+18. [回溯算法去重问题的另一种写法](./problems/回溯算法去重问题的另一种写法.md)
+19. [回溯算法：332.重新安排行程](./problems/0332.重新安排行程.md)
+20. [回溯算法：51.N皇后](./problems/0051.N皇后.md)
+21. [回溯算法：37.解数独](./problems/0037.解数独.md)
+22. [回溯算法总结篇](./problems/回溯总结.md)
+
+
+1. [关于贪心算法，你该了解这些！](./problems/贪心算法理论基础.md)
+2. [贪心算法：455.分发饼干](./problems/0455.分发饼干.md)
+3. [贪心算法：376.摆动序列](./problems/0376.摆动序列.md)
+4. [贪心算法：53.最大子序和](./problems/0053.最大子序和.md)
+5. [本周小结！（贪心算法系列一）](./problems/周总结/20201126贪心周末总结.md)
+6. [贪心算法：122.买卖股票的最佳时机II](./problems/0122.买卖股票的最佳时机II.md)
+7. [贪心算法：55.跳跃游戏](./problems/0055.跳跃游戏.md)
+8. [贪心算法：45.跳跃游戏II](./problems/0045.跳跃游戏II.md)
+9. [贪心算法：1005.K次取反后最大化的数组和](./problems/1005.K次取反后最大化的数组和.md)
+10. [本周小结！（贪心算法系列二）](./problems/周总结/20201203贪心周末总结.md)
+11. [贪心算法：134.加油站](./problems/0134.加油站.md)
+12. [贪心算法：135.分发糖果](./problems/0135.分发糖果.md)
+13. [贪心算法：860.柠檬水找零](./problems/0860.柠檬水找零.md)
+14. [贪心算法：406.根据身高重建队列](./problems/0406.根据身高重建队列.md)
+15. [本周小结！（贪心算法系列三）](./problems/周总结/20201217贪心周末总结.md)
+16. [贪心算法：406.根据身高重建队列（续集）](./problems/根据身高重建队列（vector原理讲解）.md)
+17. [贪心算法：452.用最少数量的箭引爆气球](./problems/0452.用最少数量的箭引爆气球.md)
+18. [贪心算法：435.无重叠区间](./problems/0435.无重叠区间.md)
+19. [贪心算法：763.划分字母区间](./problems/0763.划分字母区间.md)
+20. [贪心算法：56.合并区间](./problems/0056.合并区间.md)
+21. [本周小结！（贪心算法系列四）](./problems/周总结/20201224贪心周末总结.md)
+22. [贪心算法：738.单调递增的数字](./problems/0738.单调递增的数字.md)
+23. [贪心算法：968.监控二叉树](./problems/0968.监控二叉树.md)
+24. [贪心算法：总结篇！（每逢总结必经典）](./problems/贪心算法总结篇.md)
+
+1. [关于动态规划，你该了解这些！](./problems/动态规划理论基础.md)
+2. [动态规划：509.斐波那契数](./problems/0509.斐波那契数.md)
+3. [动态规划：70.爬楼梯](./problems/0070.爬楼梯.md)
+4. [动态规划：746.使用最小花费爬楼梯](./problems/0746.使用最小花费爬楼梯.md)
+5. [本周小结！（动态规划系列一）](./problems/周总结/20210107动规周末总结.md)
+6. [动态规划：62.不同路径](./problems/0062.不同路径.md)
+7. [动态规划：63.不同路径II](./problems/0063.不同路径II.md)
+8. [动态规划：343.整数拆分](./problems/0343.整数拆分.md)
+9. [动态规划：96.不同的二叉搜索树](./problems/0096.不同的二叉搜索树.md)
+10. [本周小结！（动态规划系列二）](./problems/周总结/20210114动规周末总结.md)
+
+背包问题系列：
+
+
+
+
+11. [动态规划：01背包理论基础（二维dp数组）](./problems/背包理论基础01背包-1.md)
+12. [动态规划：01背包理论基础（一维dp数组）](./problems/背包理论基础01背包-2.md)
+13. [动态规划：416.分割等和子集](./problems/0416.分割等和子集.md)
+14. [动态规划：1049.最后一块石头的重量II](./problems/1049.最后一块石头的重量II.md)
+15. [本周小结！（动态规划系列三）](./problems/周总结/20210121动规周末总结.md)
+16. [动态规划：494.目标和](./problems/0494.目标和.md)
+17. [动态规划：474.一和零](./problems/0474.一和零.md)
+18. [动态规划：完全背包理论基础（二维dp数组）](./problems/背包问题理论基础完全背包.md)
+19. [动态规划：完全背包理论基础（一维dp数组）](./problems/背包问题完全背包一维.md)
+20. [动态规划：518.零钱兑换II](./problems/0518.零钱兑换II.md)
+21. [本周小结！（动态规划系列四）](./problems/周总结/20210128动规周末总结.md)
+22. [动态规划：377.组合总和Ⅳ](./problems/0377.组合总和Ⅳ.md)
+23. [动态规划：70.爬楼梯（完全背包版本）](./problems/0070.爬楼梯完全背包版本.md)
+24. [动态规划：322.零钱兑换](./problems/0322.零钱兑换.md)
+25. [动态规划：279.完全平方数](./problems/0279.完全平方数.md)
+26. [本周小结！（动态规划系列五）](./problems/周总结/20210204动规周末总结.md)
+27. [动态规划：139.单词拆分](./problems/0139.单词拆分.md)
+28. [动态规划：多重背包理论基础](./problems/背包问题理论基础多重背包.md)
+29. [背包问题总结篇](./problems/背包总结篇.md)
+
+打家劫舍系列：
+
+29. [动态规划：198.打家劫舍](./problems/0198.打家劫舍.md)
+30. [动态规划：213.打家劫舍II](./problems/0213.打家劫舍II.md)
+31. [动态规划：337.打家劫舍III](./problems/0337.打家劫舍III.md)
+
+股票系列：
+
+
+
+
+32. [动态规划：121.买卖股票的最佳时机](./problems/0121.买卖股票的最佳时机.md)
+33. [动态规划：本周小结（系列六）](./problems/周总结/20210225动规周末总结.md)
+34. [动态规划：122.买卖股票的最佳时机II](./problems/0122.买卖股票的最佳时机II（动态规划）.md)
+35. [动态规划：123.买卖股票的最佳时机III](./problems/0123.买卖股票的最佳时机III.md)
+36. [动态规划：188.买卖股票的最佳时机IV](./problems/0188.买卖股票的最佳时机IV.md)
+37. [动态规划：309.最佳买卖股票时机含冷冻期](./problems/0309.最佳买卖股票时机含冷冻期.md)
+38. [动态规划：本周小结（系列七）](./problems/周总结/20210304动规周末总结.md)
+39. [动态规划：714.买卖股票的最佳时机含手续费](./problems/0714.买卖股票的最佳时机含手续费（动态规划）.md)
+40. [动态规划：股票系列总结篇](./problems/动态规划-股票问题总结篇.md)
+
+子序列系列：
+
+
+
+
+41. [动态规划：300.最长递增子序列](./problems/0300.最长上升子序列.md)
+42. [动态规划：674.最长连续递增序列](./problems/0674.最长连续递增序列.md)
+43. [动态规划：718.最长重复子数组](./problems/0718.最长重复子数组.md)
+44. [动态规划：1143.最长公共子序列](./problems/1143.最长公共子序列.md)
+45. [动态规划：1035.不相交的线](./problems/1035.不相交的线.md)
+46. [动态规划：53.最大子序和](./problems/0053.最大子序和（动态规划）.md)
+47. [动态规划：392.判断子序列](./problems/0392.判断子序列.md)
+48. [动态规划：115.不同的子序列](./problems/0115.不同的子序列.md)
+49. [动态规划：583.两个字符串的删除操作](./problems/0583.两个字符串的删除操作.md)
+50. [动态规划：72.编辑距离](./problems/0072.编辑距离.md)
+51. [编辑距离总结篇](./problems/为了绝杀编辑距离，卡尔做了三步铺垫.md)
+52. [动态规划：647.回文子串](./problems/0647.回文子串.md)
+53. [动态规划：516.最长回文子序列](./problems/0516.最长回文子序列.md)
+54. [动态规划总结篇](./problems/动态规划总结篇.md)
+
+
+
图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
回溯三部曲：
-* 确定回溯函数参数
+* 确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。
-注意这个index可不是 [回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)中的startIndex了。
+注意这个index可不是 [77.组合](https://programmercarl.com/0077.组合.html)和[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)中的startIndex了。
这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
代码如下：
-```
+```cpp
vector
+
* fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：
-
-
-* fast和slow同时移动，之道fast指向末尾，如题：
-
+
+* fast和slow同时移动，直到fast指向末尾，如题：
+
+//图片中有错别词：应该将“只到”改为“直到”
* 删除slow指向的下一个节点，如图：
-
+
此时不难写出如下C++代码：
-```
+```CPP
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
@@ -42,8 +78,402 @@ public:
fast = fast->next;
slow = slow->next;
}
- slow->next = slow->next->next;
+ slow->next = slow->next->next;
+
+ // ListNode *tmp = slow->next; C++释放内存的逻辑
+ // slow->next = tmp->next;
+ // delete tmp;
+
return dummyHead->next;
}
};
```
+
+* 时间复杂度: O(n)
+* 空间复杂度: O(1)
+
+
+## 其他语言版本
+
+### Java:
+
+```java
+class Solution {
+ public ListNode removeNthFromEnd(ListNode head, int n) {
+ //新建一个虚拟头节点指向head
+ ListNode dummyNode = new ListNode(0);
+ dummyNode.next = head;
+ //快慢指针指向虚拟头节点
+ ListNode fastIndex = dummyNode;
+ ListNode slowIndex = dummyNode;
+
+ // 只要快慢指针相差 n 个结点即可
+ for (int i = 0; i <= n; i++) {
+ fastIndex = fastIndex.next;
+ }
+ while (fastIndex != null) {
+ fastIndex = fastIndex.next;
+ slowIndex = slowIndex.next;
+ }
+
+ // 此时 slowIndex 的位置就是待删除元素的前一个位置。
+ // 具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
+ // 检查 slowIndex.next 是否为 null，以避免空指针异常
+ if (slowIndex.next != null) {
+ slowIndex.next = slowIndex.next.next;
+ }
+ return dummyNode.next;
+ }
+}
+```
+
+
+```java
+class Solution {
+ public ListNode removeNthFromEnd(ListNode head, int n) {
+ // 创建一个新的哑节点，指向原链表头
+ ListNode s = new ListNode(-1, head);
+ // 递归调用remove方法，从哑节点开始进行删除操作
+ remove(s, n);
+ // 返回新链表的头（去掉可能的哑节点）
+ return s.next;
+ }
+
+ public int remove(ListNode p, int n) {
+ // 递归结束条件：如果当前节点为空，返回0
+ if (p == null) {
+ return 0;
+ }
+ // 递归深入到下一个节点
+ int net = remove(p.next, n);
+ // 如果当前节点是倒数第n个节点，进行删除操作
+ if (net == n) {
+ p.next = p.next.next;
+ }
+ // 返回当前节点的总深度
+ return net + 1;
+ }
+}
+```
+
+
+### Python:
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+# def __init__(self, val=0, next=None):
+# self.val = val
+# self.next = next
+
+class Solution:
+ def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
+ # 创建一个虚拟节点，并将其下一个指针设置为链表的头部
+ dummy_head = ListNode(0, head)
+
+ # 创建两个指针，慢指针和快指针，并将它们初始化为虚拟节点
+ slow = fast = dummy_head
+
+ # 快指针比慢指针快 n+1 步
+ for i in range(n+1):
+ fast = fast.next
+
+ # 移动两个指针，直到快速指针到达链表的末尾
+ while fast:
+ slow = slow.next
+ fast = fast.next
+
+ # 通过更新第 (n-1) 个节点的 next 指针删除第 n 个节点
+ slow.next = slow.next.next
+
+ return dummy_head.next
+
+```
+### Go:
+
+```Go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ * Val int
+ * Next *ListNode
+ * }
+ */
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+ dummyNode := &ListNode{0, head}
+ fast, slow := dummyNode, dummyNode
+ for i := 0; i <= n; i++ { // 注意<=，否则快指针为空时，慢指针正好在倒数第n个上面
+ fast = fast.Next
+ }
+ for fast != nil {
+ fast = fast.Next
+ slow = slow.Next
+ }
+ slow.Next = slow.Next.Next
+ return dummyNode.Next
+}
+```
+
+### JavaScript:
+
+```js
+/**
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+var removeNthFromEnd = function (head, n) {
+ // 创建哨兵节点，简化解题逻辑
+ let dummyHead = new ListNode(0, head);
+ let fast = dummyHead;
+ let slow = dummyHead;
+ while (n--) fast = fast.next;
+ while (fast.next !== null) {
+ slow = slow.next;
+ fast = fast.next;
+ }
+ slow.next = slow.next.next;
+ return dummyHead.next;
+};
+```
+### TypeScript:
+
+版本一（快慢指针法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+ let newHead: ListNode | null = new ListNode(0, head);
+ //根据leetcode题目的定义可推断这里快慢指针均不需要定义为ListNode | null。
+ let slowNode: ListNode = newHead;
+ let fastNode: ListNode = newHead;
+
+ while(n--) {
+ fastNode = fastNode.next!; //由虚拟头节点前进n个节点时,fastNode.next可推断不为null。
+ }
+ while(fastNode.next) { //遍历直至fastNode.next = null， 即尾部节点。 此时slowNode指向倒数第n个节点。
+ fastNode = fastNode.next;
+ slowNode = slowNode.next!;
+ }
+ slowNode.next = slowNode.next!.next; //倒数第n个节点可推断其next节点不为空。
+ return newHead.next;
+}
+```
+
+版本二（计算节点总数法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+ let curNode: ListNode | null = head;
+ let listSize: number = 0;
+ while (curNode) {
+ curNode = curNode.next;
+ listSize++;
+ }
+ if (listSize === n) {
+ head = head.next;
+ } else {
+ curNode = head;
+ for (let i = 0; i < listSize - n - 1; i++) {
+ curNode = curNode.next;
+ }
+ curNode.next = curNode.next.next;
+ }
+ return head;
+};
+```
+
+版本三（递归倒退n法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+ let newHead: ListNode | null = new ListNode(0, head);
+ let cnt = 0;
+ function recur(node) {
+ if (node === null) return;
+ recur(node.next);
+ cnt++;
+ if (cnt === n + 1) {
+ node.next = node.next.next;
+ }
+ }
+ recur(newHead);
+ return newHead.next;
+};
+```
+
+### Kotlin:
+
+```Kotlin
+fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
+ val pre = ListNode(0).apply {
+ this.next = head
+ }
+ var fastNode: ListNode? = pre
+ var slowNode: ListNode? = pre
+ for (i in 0..n) {
+ fastNode = fastNode?.next
+ }
+ while (fastNode != null) {
+ slowNode = slowNode?.next
+ fastNode = fastNode.next
+ }
+ slowNode?.next = slowNode?.next?.next
+ return pre.next
+}
+```
+
+### Swift：
+
+```swift
+func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+ if head == nil {
+ return nil
+ }
+ if n == 0 {
+ return head
+ }
+ let dummyHead = ListNode(-1, head)
+ var fast: ListNode? = dummyHead
+ var slow: ListNode? = dummyHead
+ // fast 前移 n
+ for _ in 0 ..< n {
+ fast = fast?.next
+ }
+ while fast?.next != nil {
+ fast = fast?.next
+ slow = slow?.next
+ }
+ slow?.next = slow?.next?.next
+ return dummyHead.next
+}
+```
+
+### PHP:
+
+```php
+function removeNthFromEnd($head, $n) {
+ // 设置虚拟头节点
+ $dummyHead = new ListNode();
+ $dummyHead->next = $head;
+
+ $slow = $fast = $dummyHead;
+ while($n-- && $fast != null){
+ $fast = $fast->next;
+ }
+ // fast 再走一步，让 slow 指向删除节点的上一个节点
+ $fast = $fast->next;
+ while ($fast != NULL) {
+ $fast = $fast->next;
+ $slow = $slow->next;
+ }
+ $slow->next = $slow->next->next;
+ 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
+ }
+}
+```
+
+### Rust:
+
+```rust
+impl Solution {
+ pub fn remove_nth_from_end(head: Option
+
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
-## 思路
这道题目正常模拟就可以了。
建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。
-对虚拟头结点的操作，还不熟悉的话，可以看这篇[链表：听说用虚拟头节点会方便很多？](https://mp.weixin.qq.com/s/slM1CH5Ew9XzK93YOQYSjA)。
+对虚拟头结点的操作，还不熟悉的话，可以看这篇[链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)。
接下来就是交换相邻两个元素了，**此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序**
-初始时，cur指向虚拟头结点，然后进行如下三步：
+初始时，cur指向虚拟头结点，然后进行如下三步：
-
+
操作之后，链表如下：
-
-
+
看这个可能就更直观一些了：
-
+
-对应的C++代码实现如下：
+对应的C++代码实现如下： （注释中详细和如上图中的三步做对应）
-```
+```CPP
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
- dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
+ dummyHead->next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
ListNode* cur = dummyHead;
while(cur->next != nullptr && cur->next->next != nullptr) {
ListNode* tmp = cur->next; // 记录临时节点
@@ -45,26 +61,467 @@ public:
cur = cur->next->next; // cur移动两位，准备下一轮交换
}
- return dummyHead->next;
+ ListNode* result = dummyHead->next;
+ delete dummyHead;
+ return result;
}
};
```
-时间复杂度：O(n)
-空间复杂度：O(1)
-## 拓展
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
+
+## 拓展
-**这里还是说一下，大家不必太在意leetcode上执行用时，打败多少多少用户，这个就是一个玩具，非常不准确。**
+**这里还是说一下，大家不必太在意力扣上执行用时，打败多少多少用户，这个统计不准确的。**
-做题的时候自己能分析出来时间复杂度就可以了，至于leetcode上执行用时，大概看一下就行。
+做题的时候自己能分析出来时间复杂度就可以了，至于力扣上执行用时，大概看一下就行。
上面的代码我第一次提交执行用时8ms，打败6.5%的用户，差点吓到我了。
-心想应该没有更好的方法了吧，也就O(n)的时间复杂度，重复提交几次，这样了：
+心想应该没有更好的方法了吧，也就 $O(n)$ 的时间复杂度，重复提交几次，这样了：
+
+
+
+力扣上的统计如果两份代码是 100ms 和 300ms的耗时，其实是需要注意的。
+
+如果一个是 4ms 一个是 12ms，看上去好像是一个打败了80%，一个打败了20%，其实是没有差别的。 只不过是力扣上统计的误差而已。
-
-所以，不必过于在意leetcode上这个统计。
+## 其他语言版本
+### C:
+```c
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * struct ListNode *next;
+ * };
+ */
+//递归版本
+struct ListNode* swapPairs(struct ListNode* head){
+ //递归结束条件：头节点不存在或头节点的下一个节点不存在。此时不需要交换，直接返回head
+ if(!head || !head->next)
+ return head;
+ //创建一个节点指针类型保存头结点下一个节点
+ struct ListNode *newHead = head->next;
+ //更改头结点+2位节点后的值，并将头结点的next指针指向这个更改过的list
+ head->next = swapPairs(newHead->next);
+ //将新的头结点的next指针指向老的头节点
+ newHead->next = head;
+ return newHead;
+}
+```
+
+```c
+//迭代版本
+struct ListNode* swapPairs(struct ListNode* head){
+ //使用双指针避免使用中间变量
+ typedef struct ListNode ListNode;
+ ListNode *fakehead = (ListNode *)malloc(sizeof(ListNode));
+ fakehead->next = head;
+ ListNode* right = fakehead->next;
+ ListNode* left = fakehead;
+ while(left && right && right->next ){
+ left->next = right->next;
+ right->next = left->next->next;
+ left->next->next = right;
+ left = right;
+ right = left->next;
+ }
+ return fakehead->next;
+}
+```
+
+### Java：
+
+```Java
+// 递归版本
+class Solution {
+ public ListNode swapPairs(ListNode head) {
+ // base case 退出提交
+ if(head == null || head.next == null) return head;
+ // 获取当前节点的下一个节点
+ ListNode next = head.next;
+ // 进行递归
+ ListNode newNode = swapPairs(next.next);
+ // 这里进行交换
+ next.next = head;
+ head.next = newNode;
+
+ return next;
+ }
+}
+```
+
+```java
+class Solution {
+ public ListNode swapPairs(ListNode head) {
+ ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
+ dumyhead.next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
+ ListNode cur = dumyhead;
+ ListNode temp; // 临时节点，保存两个节点后面的节点
+ ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
+ ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
+ while (cur.next != null && cur.next.next != null) {
+ temp = cur.next.next.next;
+ firstnode = cur.next;
+ secondnode = cur.next.next;
+ cur.next = secondnode; // 步骤一
+ secondnode.next = firstnode; // 步骤二
+ firstnode.next = temp; // 步骤三
+ cur = firstnode; // cur移动，准备下一轮交换
+ }
+ return dumyhead.next;
+ }
+}
+```
+
+```java
+// 将步骤 2,3 交换顺序，这样不用定义 temp 节点
+public ListNode swapPairs(ListNode head) {
+ ListNode dummy = new ListNode(0, head);
+ ListNode cur = dummy;
+ while (cur.next != null && cur.next.next != null) {
+ ListNode node1 = cur.next;// 第 1 个节点
+ ListNode node2 = cur.next.next;// 第 2 个节点
+ cur.next = node2; // 步骤 1
+ node1.next = node2.next;// 步骤 3
+ node2.next = node1;// 步骤 2
+ cur = cur.next.next;
+ }
+ return dummy.next;
+}
+```
+
+### Python：
+
+```python
+# 递归版本
+# Definition for singly-linked list.
+# class ListNode:
+# def __init__(self, val=0, next=None):
+# self.val = val
+# self.next = next
+
+class Solution:
+ def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
+ if head is None or head.next is None:
+ return head
+
+ # 待翻转的两个node分别是pre和cur
+ pre = head
+ cur = head.next
+ next = head.next.next
+
+ cur.next = pre # 交换
+ pre.next = self.swapPairs(next) # 将以next为head的后续链表两两交换
+
+ return cur
+```
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+# def __init__(self, val=0, next=None):
+# self.val = val
+# self.next = next
+
+class Solution:
+ def swapPairs(self, head: ListNode) -> ListNode:
+ dummy_head = ListNode(next=head)
+ current = dummy_head
+
+ # 必须有cur的下一个和下下个才能交换，否则说明已经交换结束了
+ while current.next and current.next.next:
+ temp = current.next # 防止节点修改
+ temp1 = current.next.next.next
+
+ current.next = current.next.next
+ current.next.next = temp
+ temp.next = temp1
+ current = current.next.next
+ return dummy_head.next
+
+```
+
+### Go：
+
+```go
+func swapPairs(head *ListNode) *ListNode {
+ dummy := &ListNode{
+ Next: head,
+ }
+ //head=list[i]
+ //pre=list[i-1]
+ pre := dummy
+ for head != nil && head.Next != nil {
+ pre.Next = head.Next
+ next := head.Next.Next
+ head.Next.Next = head
+ head.Next = next
+ //pre=list[(i+2)-1]
+ pre = head
+ //head=list[(i+2)]
+ head = next
+ }
+ return dummy.Next
+}
+```
+
+```go
+// 递归版本
+func swapPairs(head *ListNode) *ListNode {
+ if head == nil || head.Next == nil {
+ return head
+ }
+ next := head.Next
+ head.Next = swapPairs(next.Next)
+ next.Next = head
+ return next
+}
+```
+
+### JavaScript:
+
+```javascript
+var swapPairs = function (head) {
+ let ret = new ListNode(0, head), temp = ret;
+ while (temp.next && temp.next.next) {
+ let cur = temp.next.next, pre = temp.next;
+ pre.next = cur.next;
+ cur.next = pre;
+ temp.next = cur;
+ temp = pre;
+ }
+ return ret.next;
+};
+```
+
+```javascript
+// 递归版本
+var swapPairs = function (head) {
+ if (head == null || head.next == null) {
+ return head;
+ }
+
+ let after = head.next;
+ head.next = swapPairs(after.next);
+ after.next = head;
+
+ return after;
+};
+```
+
+### TypeScript：
+
+```typescript
+function swapPairs(head: ListNode | null): ListNode | null {
+ const dummyNode: ListNode = new ListNode(0, head);
+ let curNode: ListNode | null = dummyNode;
+ while (curNode && curNode.next && curNode.next.next) {
+ let firstNode: ListNode = curNode.next,
+ secNode: ListNode = curNode.next.next,
+ thirdNode: ListNode | null = curNode.next.next.next;
+ curNode.next = secNode;
+ secNode.next = firstNode;
+ firstNode.next = thirdNode;
+ curNode = firstNode;
+ }
+ return dummyNode.next;
+};
+```
+
+### Kotlin:
+
+```kotlin
+fun swapPairs(head: ListNode?): ListNode? {
+ val dummyNode = ListNode(0).apply {
+ this.next = head
+ }
+ var cur: ListNode? = dummyNode
+ while (cur?.next != null && cur.next?.next != null) {
+ val temp = cur.next
+ val temp2 = cur.next?.next?.next
+ cur.next = cur.next?.next
+ cur.next?.next = temp
+ cur.next?.next?.next = temp2
+ cur = cur.next?.next
+ }
+ return dummyNode.next
+}
+```
+
+### Swift:
+
+```swift
+func swapPairs(_ head: ListNode?) -> ListNode? {
+ if head == nil || head?.next == nil {
+ return head
+ }
+ let dummyHead: ListNode = ListNode(-1, head)
+ var current: ListNode? = dummyHead
+ while current?.next != nil && current?.next?.next != nil {
+ let temp1 = current?.next
+ let temp2 = current?.next?.next?.next
+
+ current?.next = current?.next?.next
+ current?.next?.next = temp1
+ current?.next?.next?.next = temp2
+
+ current = current?.next?.next
+ }
+ 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
+ }
+}
+```
+
+### PHP:
+
+```php
+//虚拟头结点
+function swapPairs($head) {
+ if ($head == null || $head->next == null) {
+ return $head;
+ }
+
+ $dummyNode = new ListNode(0, $head);
+ $preNode = $dummyNode; //虚拟头结点
+ $curNode = $head;
+ $nextNode = $head->next;
+ while($curNode && $nextNode) {
+ $nextNextNode = $nextNode->next; //存下一个节点
+ $nextNode->next = $curNode; //交换curHead 和 nextHead
+ $curNode->next = $nextNextNode;
+ $preNode->next = $nextNode; //上一个节点的下一个指向指向nextHead
+
+ //更新当前的几个指针
+ $preNode = $preNode->next->next;
+ $curNode = $nextNextNode;
+ $nextNode = $nextNextNode->next;
+ }
+
+ return $dummyNode->next;
+}
+
+//递归版本
+function swapPairs($head)
+{
+ // 终止条件
+ if ($head === null || $head->next === null) {
+ return $head;
+ }
+
+ //结果要返回的头结点
+ $next = $head->next;
+ $head->next = $this->swapPairs($next->next); //当前头结点->next指向更新
+ $next->next = $head; //当前第二个节点的->next指向更新
+ return $next; //返回翻转后的头结点
+}
+```
+
+### Rust:
+
+```rust
+// 虚拟头节点
+impl Solution {
+ pub fn swap_pairs(head: Option
+
很明显暴力解法的时间复杂度是O(n^2)，这道题目暴力解法在leetcode上是可以过的。
-# 暴力解法C++代码
+代码如下：
-```
+```CPP
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
@@ -57,7 +61,7 @@ public:
for (int j = i + 1; j < size; j++) {
nums[j - 1] = nums[j];
}
- i--; // 因为下表i以后的数值都向前移动了一位，所以i也向前移动一位
+ i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
size--; // 此时数组的大小-1
}
}
@@ -67,50 +71,449 @@ public:
};
```
-# 双指针法
-
-双指针法（快慢指针法）： **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
-删除过程如下：
+### 双指针法
-
+双指针法（快慢指针法）： **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
-**双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组和链表操作的面试题，都使用双指针法。**
+定义快慢指针
-我们来回顾一下，之前已经讲过有四道题目使用了双指针法。
+* 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
+* 慢指针：指向更新 新数组下标的位置
-双指针法将时间复杂度O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：
+很多同学这道题目做的很懵，就是不理解 快慢指针究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。
-* [15.三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)
-* [18.四数之和](https://mp.weixin.qq.com/s/nQrcco8AZJV1pAOVjeIU_g)
+删除过程如下：
-双指针来记录前后指针实现链表反转：
+
-* [206.反转链表](https://mp.weixin.qq.com/s/pnvVP-0ZM7epB8y3w_Njwg)
+很多同学不了解
-使用双指针来确定有环：
-* [142题.环形链表II](https://mp.weixin.qq.com/s/_QVP3IkRZWx9zIpQRgajzA)
+**双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。**
-双指针法在数组和链表中还有很多应用，后面还会介绍到。
+后续都会一一介绍到，本题代码如下：
-# 双指针法C++代码：
-```
+```CPP
// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
int removeElement(vector
-
-动画里，我特意把 子串`aa` 标记上了，这是有原因的，大家先注意一下，后面还会说道。
-
-可以看出，文本串中第六个字符b 和 模式串的第六个字符f，不匹配了。如果暴力匹配，会发现不匹配，此时就要从头匹配了。
-
-但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。
-
-此时就要问了**前缀表是如何记录的呢？**
-
-首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，在重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
-
-那么什么是前缀表：**记录下表i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
-
-# 为什么一定要用前缀表
-
-这就是前缀表那为啥就能告诉我们 上次匹配的位置，并跳过去呢？
-
-回顾一下，刚刚匹配的过程在下表5的地方遇到不匹配，模式串是指向f，如图：
-
-
-
-然后就找到了下表2，指向b，继续匹配：如图：
-
-
-以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要！
-
-**下表5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面从新匹配就可以了。**
-
-所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。
-
-**很多介绍KMP的文章或者视频并没有把为什么要用前缀表？这个问题说清楚，而是直接默认使用前缀表。**
-
-# 如何计算前缀表
-
-接下来就要说一说怎么计算前缀表。
-
-如图：
-
-
-
-长度为前1个字符的子串`a`，最长相同前后缀的长度为0。（注意字符串的**前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串**；**后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串**。）
-
-
-长度为前2个字符的子串`aa`，最长相同前后缀的长度为1。
-
-
-长度为前3个字符的子串`aab`，最长相同前后缀的长度为0。
-
-以此类推：
-长度为前4个字符的子串`aaba`，最长相同前后缀的长度为1。
-长度为前5个字符的子串`aabaa`，最长相同前后缀的长度为2。
-长度为前6个字符的子串`aabaaf`，最长相同前后缀的长度为0。
-
-那么把求得的最长相同前后缀的长度就是对应前缀表的元素，如图：
-
-
-可以看出模式串与前缀表对应位置的数字表示的就是：**下表i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
-
-再来看一下如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示：
-
-
-
-找到的不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。
-
-为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。
-
-所以要看前一位的 前缀表的数值。
-
-前一个字符的前缀表的数值是2， 所有把下表移动到下表2的位置继续比配。 可以再反复看一下上面的动画。
-
-最后就在文本串中找到了和模式串匹配的子串了。
-
-# 前缀表与next数组
-
-很多KMP算法的时间都是使用next数组来做回退操作，那么next数组与前缀表有什么关系呢？
-
-next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。
-
-为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。
-
-其实**这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。**
-
-后面我会提供两种不同的实现代码，大家就明白了了。
-
-# 使用next数组来匹配
-
-以下我们以前缀表统一减一之后的next数组来做演示。
-
-有了next数组，就可以根据next数组来 匹配文本串s，和模式串t了。
-
-注意next数组是新前缀表（旧前缀表统一减一了）。
-
-匹配过程动画如下：
-
-
-
-# 时间复杂度分析
-
-
-其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
-
-暴力的解法显而易见是O(n * m)，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
-
-为了和[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)字符串命名统一，方便大家理解，以下文章统称haystack为文本串, needle为模式串。
-
-都知道使用KMP算法，一定要构造next数组。
-
-# 构造next数组
-
-我们定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。 代码如下：
-
-```
-void getNext(int* next, const string& s)
-```
-
-**构造next数组其实就是计算模式串s，前缀表的过程。** 主要有如下三步：
-
-1. 初始化
-2. 处理前后缀不相同的情况
-3. 处理前后缀相同的情况
-
-接下来我们详解详解一下。
-
-1. 初始化：
-
-定义两个指针i和j，j指向前缀终止位置（严格来说是终止位置减一的位置），i指向后缀终止位置（与j同理）。
-
-然后还要对next数组进行初始化赋值，如下：
-
-```
-int j = -1;
-next[0] = j;
-```
-
-j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择j初始化为-1，下文我还会给出j不初始化为-1的实现代码。
-
-next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）
-
-所以初始化next[0] = j 。
-
-
-2. 处理前后缀不相同的情况
-
-
-因为j初始化为-1，那么i就从1开始，进行s[i] 与 s[j+1]的比较。
-
-所以遍历模式串s的循环下表i 要从 1开始，代码如下：
-
-```
-for(int i = 1; i < s.size(); i++) {
-```
-
-如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回溯。
-
-怎么回溯呢？
-
-next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。
-
-那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。
-
-所以，处理前后缀不相同的情况代码如下：
-
-```
-while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
- j = next[j]; // 向前回溯
-}
-```
-
-3. 处理前后缀相同的情况
-
-如果s[i] 与 s[j + 1] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
-
-代码如下：
-
-```
-if (s[i] == s[j + 1]) { // 找到相同的前后缀
- j++;
-}
-next[i] = j;
-```
-
-最后整体构建next数组的函数代码如下：
-
-```
-void getNext(int* next, const string& s){
- int j = -1;
- next[0] = j;
- for(int i = 1; i < s.size(); i++) { // 注意i从1开始
- while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
- j = next[j]; // 向前回溯
- }
- if (s[i] == s[j + 1]) { // 找到相同的前后缀
- j++;
- }
- next[i] = j; // 将j（前缀的长度）赋给next[i]
- }
-}
-```
-
-
-代码构造next数组的逻辑流程动画如下：
-
-
-
-
-得到了next数组之后，就要用这个来做匹配了。
-
-# 使用next数组来做匹配
-
-在文本串s里 找是否出现过模式串t。
-
-定义两个下表j 指向模式串起始位置，i指向文本串其实位置。
-
-那么j初始值依然为-1，为什么呢？ **依然因为next数组里记录的起始位置为-1。**
-
-i就从0开始，遍历文本串，代码如下：
-
-```
-for (int i = 0; i < s.size(); i++)
-```
-
-接下来就是 s[i] 与 t[j + 1] （因为j从-1开始的） 经行比较。
-
-如果 s[i] 与 t[j + 1] 不相同，j就要从next数组里寻找下一个匹配的位置。
-
-代码如下：
-
-```
-while(j >= 0 && s[i] != t[j + 1]) {
- j = next[j];
-}
-```
-
-如果 s[i] 与 t[j + 1] 相同，那么i 和 j 同时向后移动， 代码如下：
-
-```
-if (s[i] == t[j + 1]) {
- j++; // i的增加在for循环里
-}
-```
-
-如何判断在文本串s里出现了模式串t呢，如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。
-
-本题要在文本串字符串中找出模式串出现的第一个位置 (从0开始)，所以返回当前在文本串匹配模式串的位置i 减去 模式串的长度，就是文本串字符串中出现模式串的第一个位置。
-
-代码如下：
-
-```
-if (j == (t.size() - 1) ) {
- return (i - t.size() + 1);
-}
-```
-
-那么使用next数组，用模式串匹配文本串的整体代码如下：
-
-```
-int j = -1; // 因为next数组里记录的起始位置为-1
-for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
- while(j >= 0 && s[i] != t[j + 1]) { // 不匹配
- j = next[j]; // j 寻找之前匹配的位置
- }
- if (s[i] == t[j + 1]) { // 匹配，j和i同时向后移动
- j++; // i的增加在for循环里
- }
- if (j == (t.size() - 1) ) { // 文本串s里出现了模式串t
- return (i - t.size() + 1);
- }
-}
-```
-
-此时所有逻辑的代码都已经写出来了，本题整体代码如下：
-
-# 前缀表统一减一 C++代码实现
-
-```
-class Solution {
-public:
- void getNext(int* next, const string& s) {
- int j = -1;
- next[0] = j;
- for(int i = 1; i < s.size(); i++) { // 注意i从1开始
- while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
- j = next[j]; // 向前回溯
- }
- if (s[i] == s[j + 1]) { // 找到相同的前后缀
- j++;
- }
- next[i] = j; // 将j（前缀的长度）赋给next[i]
- }
- }
- int strStr(string haystack, string needle) {
- if (needle.size() == 0) {
- return 0;
- }
- int next[needle.size()];
- getNext(next, needle);
- int j = -1; // // 因为next数组里记录的起始位置为-1
- for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
- while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
- j = next[j]; // j 寻找之前匹配的位置
- }
- if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
- j++; // i的增加在for循环里
- }
- if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
- return (i - needle.size() + 1);
- }
- }
- return -1;
- }
-};
-
-```
-
-# 前缀表（不减一）C++实现
-
-那么前缀表就不减一了，也不右移的，到底行不行呢？行！
-
-我之前说过，这仅仅是KMP算法实现上的问题，如果就直接使用前缀表可以换一种回退方式，找j=next[j-1] 来进行回退。
-
-主要就是j=next[x]这一步最为关键！
-
-我给出的getNext的实现为：（前缀表统一减一）
-
-```
-void getNext(int* next, const string& s) {
- int j = -1;
- next[0] = j;
- for(int i = 1; i < s.size(); i++) { // 注意i从1开始
- while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
- j = next[j]; // 向前回溯
- }
- if (s[i] == s[j + 1]) { // 找到相同的前后缀
- j++;
- }
- next[i] = j; // 将j（前缀的长度）赋给next[i]
- }
-}
-
-```
-此时如果输入的模式串为aabaaf，对应的next为-1 0 -1 0 1 -1。
-
-这里j和next[0]初始化为-1，整个next数组是以 前缀表减一之后的效果来构建的。
-
-那么前缀表不减一来构建next数组，代码如下：
-
-```
- void getNext(int* next, const string& s) {
- int j = 0;
- next[0] = 0;
- for(int i = 1; i < s.size(); i++) {
- while (j > 0 && s[i] != s[j]) { // j要保证大于0，因为下面有取j-1作为数组下表的操作
- j = next[j - 1]; // 注意这里，是要找前一位的对应的回退位置了
- }
- if (s[i] == s[j]) {
- j++;
- }
- next[i] = j;
- }
- }
-
-```
-
-此时如果输入的模式串为aabaaf，对应的next为 0 1 0 1 2 0，（其实这就是前缀表的数值了）。
-
-那么用这样的next数组也可以用来做匹配，代码要有所改动。
-
-实现代码如下：
-
-```
-class Solution {
-public:
- void getNext(int* next, const string& s) {
- int j = 0;
- next[0] = 0;
- for(int i = 1; i < s.size(); i++) {
- while (j > 0 && s[i] != s[j]) {
- j = next[j - 1];
- }
- if (s[i] == s[j]) {
- j++;
- }
- next[i] = j;
- }
- }
- int strStr(string haystack, string needle) {
- if (needle.size() == 0) {
- return 0;
- }
- int next[needle.size()];
- getNext(next, needle);
- int j = 0;
- for (int i = 0; i < haystack.size(); i++) {
- while(j > 0 && haystack[i] != needle[j]) {
- j = next[j - 1];
- }
- if (haystack[i] == needle[j]) {
- j++;
- }
- if (j == needle.size() ) {
- return (i - needle.size() + 1);
- }
- }
- return -1;
- }
-};
-```
-
-# 总结
-
-我们介绍了什么是KMP，KMP可以解决什么问题，然后分析KMP算法里的next数组，知道了next数组就是前缀表，再分析为什么要是前缀表而不是什么其他表。
-
-接着从给出的模式串中，我们一步一步的推导出了前缀表，得出前缀表无论是统一减一还是不同意减一得到的next数组仅仅是kmp的实现方式的不同。
-
-其中还分析了KMP算法的时间复杂度，并且和暴力方法做了对比。
-
-然后先用前缀表统一减一得到的next数组，求得文本串s里是否出现过模式串t，并给出了具体分析代码。
-
-又给出了直接用前缀表作为next数组，来做匹配的实现代码。
-
-可以说把KMP的每一个细微的细节都扣了出来，毫无遮掩的展示给大家了！
-
-
-
-
-> 更多算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。
-
diff --git "a/problems/0028.\345\256\236\347\216\260strStr.md" "b/problems/0028.\345\256\236\347\216\260strStr.md"
new file mode 100755
index 0000000000..ef8a6c58e6
--- /dev/null
+++ "b/problems/0028.\345\256\236\347\216\260strStr.md"
@@ -0,0 +1,1520 @@
+* [做项目（多个C++、Java、Go、测开、前端项目）](https://www.programmercarl.com/other/kstar.html)
+* [刷算法（两个月高强度学算法）](https://www.programmercarl.com/xunlian/xunlianying.html)
+* [背八股（40天挑战高频面试题）](https://www.programmercarl.com/xunlian/bagu.html)
+
+
+> 在一个串中查找是否出现过另一个串，这是KMP的看家本领。
+
+# 28. 实现 strStr()
+
+[力扣题目链接](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string/)
+
+实现 strStr() 函数。
+
+给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
+
+示例 1:
+输入: haystack = "hello", needle = "ll"
+输出: 2
+
+示例 2:
+输入: haystack = "aaaaa", needle = "bba"
+输出: -1
+
+说明:
+当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
+对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
+
+## 算法公开课
+
+本题是KMP 经典题目。以下文字如果看不进去，可以看[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)，相信结合视频再看本篇题解，更有助于大家对本题的理解。
+
+* [帮你把KMP算法学个通透！B站（理论篇）](https://www.bilibili.com/video/BV1PD4y1o7nd/)
+* [帮你把KMP算法学个通透！（求next数组代码篇）](https://www.bilibili.com/video/BV1M5411j7Xx)
+
+
+## 思路
+
+KMP的经典思想就是:**当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。**
+
+本篇将以如下顺序来讲解KMP，
+
+
+* 什么是KMP
+* KMP有什么用
+* 什么是前缀表
+* 为什么一定要用前缀表
+* 如何计算前缀表
+* 前缀表与next数组
+* 使用next数组来匹配
+* 时间复杂度分析
+* 构造next数组
+* 使用next数组来做匹配
+* 前缀表统一减一 C++代码实现
+* 前缀表（不减一）C++实现
+* 总结
+
+
+读完本篇可以顺便把leetcode上28.实现strStr()题目做了。
+
+
+### 什么是KMP
+
+说到KMP，先说一下KMP这个名字是怎么来的，为什么叫做KMP呢。
+
+因为是由这三位学者发明的：Knuth，Morris和Pratt，所以取了三位学者名字的首字母。所以叫做KMP
+
+### KMP有什么用
+
+KMP主要应用在字符串匹配上。
+
+KMP的主要思想是**当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。**
+
+所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。
+
+其实KMP的代码不好理解，一些同学甚至直接把KMP代码的模板背下来。
+
+没有彻底搞懂，懵懵懂懂就把代码背下来太容易忘了。
+
+不仅面试的时候可能写不出来，如果面试官问：**next数组里的数字表示的是什么，为什么这么表示？**
+
+估计大多数候选人都是懵逼的。
+
+下面Carl就带大家把KMP的精髓，next数组弄清楚。
+
+### 什么是前缀表
+
+写过KMP的同学，一定都写过next数组，那么这个next数组究竟是个啥呢？
+
+next数组就是一个前缀表（prefix table）。
+
+前缀表有什么作用呢？
+
+**前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。**
+
+为了清楚地了解前缀表的来历，我们来举一个例子：
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+请记住文本串和模式串的作用，对于理解下文很重要，要不然容易看懵。所以说三遍：
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+如动画所示：
+
+
+
+动画里，我特意把 子串`aa` 标记上了，这是有原因的，大家先注意一下，后面还会说到。
+
+可以看出，文本串中第六个字符b 和 模式串的第六个字符f，不匹配了。如果暴力匹配，发现不匹配，此时就要从头匹配了。
+
+但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。
+
+此时就要问了**前缀表是如何记录的呢？**
+
+首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
+
+那么什么是前缀表：**记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
+
+### 最长公共前后缀
+
+文章中字符串的**前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串**。
+
+**后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串**。
+
+**正确理解什么是前缀什么是后缀很重要**!
+
+那么网上清一色都说 “kmp 最长公共前后缀” 又是什么回事呢？
+
+我查了一遍 算法导论 和 算法4里KMP的章节，都没有提到 “最长公共前后缀”这个词，也不知道从哪里来了，我理解是用“最长相等前后缀” 更准确一些。
+
+**因为前缀表要求的就是相同前后缀的长度。**
+
+而最长公共前后缀里面的“公共”，更像是说前缀和后缀公共的长度。这其实并不是前缀表所需要的。
+
+所以字符串a的最长相等前后缀为0。
+字符串aa的最长相等前后缀为1。
+字符串aaa的最长相等前后缀为2。
+等等.....。
+
+
+### 为什么一定要用前缀表
+
+这就是前缀表，那为啥就能告诉我们 上次匹配的位置，并跳过去呢？
+
+回顾一下，刚刚匹配的过程在下标5的地方遇到不匹配，模式串是指向f，如图：
+
+
+
+然后就找到了下标2，指向b，继续匹配：如图：
+
+
+以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要！
+
+**下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。**
+
+所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。
+
+**很多介绍KMP的文章或者视频并没有把为什么要用前缀表？这个问题说清楚，而是直接默认使用前缀表。**
+
+### 如何计算前缀表
+
+接下来就要说一说怎么计算前缀表。
+
+如图：
+
+
+
+长度为前1个字符的子串`a`，最长相同前后缀的长度为0。（注意字符串的**前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串**；**后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串**。）
+
+
+
+长度为前2个字符的子串`aa`，最长相同前后缀的长度为1。
+
+
+
+长度为前3个字符的子串`aab`，最长相同前后缀的长度为0。
+
+以此类推：
+长度为前4个字符的子串`aaba`，最长相同前后缀的长度为1。
+长度为前5个字符的子串`aabaa`，最长相同前后缀的长度为2。
+长度为前6个字符的子串`aabaaf`，最长相同前后缀的长度为0。
+
+那么把求得的最长相同前后缀的长度就是对应前缀表的元素，如图：
+
+
+可以看出模式串与前缀表对应位置的数字表示的就是：**下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
+
+再来看一下如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示：
+
+
+
+找到的不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。
+
+为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。
+
+所以要看前一位的 前缀表的数值。
+
+前一个字符的前缀表的数值是2， 所以把下标移动到下标2的位置继续比配。 可以再反复看一下上面的动画。
+
+最后就在文本串中找到了和模式串匹配的子串了。
+
+### 前缀表与next数组
+
+很多KMP算法的实现都是使用next数组来做回退操作，那么next数组与前缀表有什么关系呢？
+
+next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。
+
+为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。
+
+其实**这并不涉及到KMP的原理，而是具体实现，next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。**
+
+后面我会提供两种不同的实现代码，大家就明白了。
+
+### 使用next数组来匹配
+
+**以下我们以前缀表统一减一之后的next数组来做演示**。
+
+有了next数组，就可以根据next数组来 匹配文本串s，和模式串t了。
+
+注意next数组是新前缀表（旧前缀表统一减一了）。
+
+匹配过程动画如下：
+
+
+
+### 时间复杂度分析
+
+其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
+
+暴力的解法显而易见是O(n × m)，所以**KMP在字符串匹配中极大地提高了搜索的效率。**
+
+为了和力扣题目28.实现strStr保持一致，方便大家理解，以下文章统称haystack为文本串, needle为模式串。
+
+都知道使用KMP算法，一定要构造next数组。
+
+### 构造next数组
+
+我们定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。 代码如下：
+
+```
+void getNext(int* next, const string& s)
+```
+
+**构造next数组其实就是计算模式串s，前缀表的过程。** 主要有如下三步：
+
+1. 初始化
+2. 处理前后缀不相同的情况
+3. 处理前后缀相同的情况
+
+接下来我们详解一下。
+
+1. 初始化：
+
+定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。
+
+然后还要对next数组进行初始化赋值，如下：
+
+```cpp
+int j = -1;
+next[0] = j;
+```
+
+j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择j初始化为-1，下文我还会给出j不初始化为-1的实现代码。
+
+next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）
+
+所以初始化next[0] = j 。
+
+
+2. 处理前后缀不相同的情况
+
+
+因为j初始化为-1，那么i就从1开始，进行s[i] 与 s[j+1]的比较。
+
+所以遍历模式串s的循环下标i 要从 1开始，代码如下：
+
+```cpp
+for (int i = 1; i < s.size(); i++) {
+```
+
+如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。
+
+怎么回退呢？
+
+next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。
+
+那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。
+
+所以，处理前后缀不相同的情况代码如下：
+
+```cpp
+while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
+ j = next[j]; // 向前回退
+}
+```
+
+3. 处理前后缀相同的情况
+
+如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
+
+代码如下：
+
+```
+if (s[i] == s[j + 1]) { // 找到相同的前后缀
+ j++;
+}
+next[i] = j;
+```
+
+最后整体构建next数组的函数代码如下：
+
+```CPP
+void getNext(int* next, const string& s){
+ int j = -1;
+ next[0] = j;
+ for(int i = 1; i < s.size(); i++) { // 注意i从1开始
+ while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
+ j = next[j]; // 向前回退
+ }
+ if (s[i] == s[j + 1]) { // 找到相同的前后缀
+ j++;
+ }
+ next[i] = j; // 将j（前缀的长度）赋给next[i]
+ }
+}
+```
+
+
+代码构造next数组的逻辑流程动画如下：
+
+
+
+得到了next数组之后，就要用这个来做匹配了。
+
+### 使用next数组来做匹配
+
+在文本串s里 找是否出现过模式串t。
+
+定义两个下标j 指向模式串起始位置，i指向文本串起始位置。
+
+那么j初始值依然为-1，为什么呢？ **依然因为next数组里记录的起始位置为-1。**
+
+i就从0开始，遍历文本串，代码如下：
+
+```cpp
+for (int i = 0; i < s.size(); i++)
+```
+
+接下来就是 s[i] 与 t[j + 1] （因为j从-1开始的） 进行比较。
+
+如果 s[i] 与 t[j + 1] 不相同，j就要从next数组里寻找下一个匹配的位置。
+
+代码如下：
+
+```cpp
+while(j >= 0 && s[i] != t[j + 1]) {
+ j = next[j];
+}
+```
+
+如果 s[i] 与 t[j + 1] 相同，那么i 和 j 同时向后移动， 代码如下：
+
+```cpp
+if (s[i] == t[j + 1]) {
+ j++; // i的增加在for循环里
+}
+```
+
+如何判断在文本串s里出现了模式串t呢，如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。
+
+本题要在文本串字符串中找出模式串出现的第一个位置 (从0开始)，所以返回当前在文本串匹配模式串的位置i 减去 模式串的长度，就是文本串字符串中出现模式串的第一个位置。
+
+代码如下：
+
+```cpp
+if (j == (t.size() - 1) ) {
+ return (i - t.size() + 1);
+}
+```
+
+那么使用next数组，用模式串匹配文本串的整体代码如下：
+
+```CPP
+int j = -1; // 因为next数组里记录的起始位置为-1
+for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
+ while(j >= 0 && s[i] != t[j + 1]) { // 不匹配
+ j = next[j]; // j 寻找之前匹配的位置
+ }
+ if (s[i] == t[j + 1]) { // 匹配，j和i同时向后移动
+ j++; // i的增加在for循环里
+ }
+ if (j == (t.size() - 1) ) { // 文本串s里出现了模式串t
+ return (i - t.size() + 1);
+ }
+}
+```
+
+此时所有逻辑的代码都已经写出来了，力扣 28.实现strStr 题目的整体代码如下：
+
+### 前缀表统一减一 C++代码实现
+
+```CPP
+class Solution {
+public:
+ void getNext(int* next, const string& s) {
+ int j = -1;
+ next[0] = j;
+ for(int i = 1; i < s.size(); i++) { // 注意i从1开始
+ while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
+ j = next[j]; // 向前回退
+ }
+ if (s[i] == s[j + 1]) { // 找到相同的前后缀
+ j++;
+ }
+ next[i] = j; // 将j（前缀的长度）赋给next[i]
+ }
+ }
+ int strStr(string haystack, string needle) {
+ if (needle.size() == 0) {
+ return 0;
+ }
+ vector