leetcode题解

Author: xin

content/leetcode-problems/.DS_Store

@@ -36,7 +36,7 @@ draft = false
 
 ## 解题思路
 
-排序+双指针，和[3Sum](/leetcode-problems/3sum)思路一样，只是求的是最接近target的三数之和，维护最接近的和ans和最小差值minDiff，当总和更靠近时更新ans和minDiff。
+排序+双指针，和[3Sum](/leetcode-problems/3sum)思路一样，只是求的是最接近target的三数之和，维护最接近的和`ans`和最小差值`minDiff`，当总和更靠近时更新`ans`和`minDiff`。
 
 ## 代码
 

content/leetcode-problems/3sum-closest.md

@@ -62,7 +62,7 @@ nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
 
 以第一层循环为例，枚举过的一个三元组是`(-1, 0, 1)`，下一次枚举的元素也是-1，也会枚举到相同的三元组是`(-1, 0, 1)`。因此需要跳到下一个不相同的元素，也就是0。
 
-此时时间复杂度依然是$O(n^3)$，可以发现，如果固定a，找到a + b + c = 0，当第二重循环往后枚举一个元素 b′ 时，由于 b′ > b，所以那么满足 a + b′ + c′ = 0的c′ 一定小于c，即 c′一定在c的左侧。因此可以将第二重和第三重循环用对撞指针实现。
+此时时间复杂度依然是$O(n^3)$，可以发现，如果固定`a`，找到`a + b + c = 0`，当第二重循环往后枚举一个元素` b′` 时，由于`b′ > b`，所以那么满足` a + b′ + c′ = 0`的`c′` 一定小于`c`，即 `c′`一定在`c`的左侧。因此可以将第二重和第三重循环用对撞指针实现。
 
 当需要枚举数组中的两个元素时，如果发现随着第一个元素的递增，第二个元素是递减的，那么就可以使用双指针的方法，将枚举的时间复杂度从$O(n^2)$减少至 $O(n)$。
 

content/leetcode-problems/3sum.md

@@ -0,0 +1,138 @@
++++
+title = '18. 四数之和'
+date = 2024-05-01T10:14:47+08:00
+draft = false
+
++++
+
+## [题目](https://leetcode.cn/problems/4sum/)
+
+给你一个由 `n` 个整数组成的数组 `nums` ，和一个目标值 `target` 。请你找出并返回满足下述全部条件且**不重复**的四元组 `[nums[a], nums[b], nums[c], nums[d]]` （若两个四元组元素一一对应，则认为两个四元组重复）：
+
+- `0 <= a, b, c, d < n`
+- `a`、`b`、`c` 和 `d` **互不相同**
+- `nums[a] + nums[b] + nums[c] + nums[d] == target`
+
+你可以按 **任意顺序** 返回答案 。
+
+**示例 1：**
+
+```
+输入：nums = [1,0,-1,0,-2,2], target = 0
+输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
+```
+
+**示例 2：**
+
+```
+输入：nums = [2,2,2,2,2], target = 8
+输出：[[2,2,2,2]] 
+```
+
+**提示：**
+
+- `1 <= nums.length <= 200`
+- `-109 <= nums[i] <= 109`
+- `-109 <= target <= 109`
+
+## 解题思路
+
+方法一：排序+双指针，在[3Sum](/leetcode-problems/3sum)的基础上多套一层循环。第一层循环固定第一个元素，第二层循环固定第二个元素，循环内部用对撞指针找出剩余两个元素。时间复杂度：$O(n^3)$，空间复杂度：$O(logn)$，取决于排序所需的空间。
+
+方法二：分治法，将问题分成若干子问题，对子问题求解后将解合并。4Sum -> n-3个3Sum，3Sum -> n-2个2Sum，2Sum用对撞指针得到解。延展到求kSum。
+
+## 代码
+
+方法一
+
+```go
+func fourSum(nums []int, target int) [][]int {
+    var ans [][]int
+    n := len(nums)
+    sort.Ints(nums)
+    for i := 0; i < n-3; i++ {
+        if i > 0 && nums[i] == nums[i-1] {
+            continue
+        }
+        for j := i+1; j < n-2; j++ {
+            if j > i+1 && nums[j] == nums[j-1] {
+                continue
+            }
+            l, r := j+1, n-1
+            for l < r {
+                s := nums[i] + nums[j] + nums[l] + nums[r]
+                if s == target {
+                    ans = append(ans, []int{nums[i], nums[j], nums[l], nums[r]})
+                    lv, rv := nums[l], nums[r]
+                    for l < r && nums[l] == lv {
+                        l++
+                    }
+                    for l < r && nums[r] == rv {
+                        r--
+                    }
+                } else if s < target {
+                    l++
+                } else {
+                    r--
+                }
+            }
+        }
+    }
+    return ans
+}
+```
+
+方法二
+
+```go
+func fourSum(nums []int, target int) [][]int {
+    sort.Ints(nums)
+    return kSum(nums, target, 4)
+}
+
+func kSum(nums []int, target int, k int) [][]int {
+    // 剪枝
+    if !(nums[0]*k <= target && target <= nums[len(nums)-1]*k) {
+        return [][]int{}
+    }
+    
+    if k == 2 {
+        return twoSum(nums, target)
+    }
+    
+    var ans [][]int
+    for i := 0; i < len(nums)-k+1; i++ {
+        if i > 0 && nums[i] == nums[i-1] {
+            continue
+        }
+        for _, res := range kSum(nums[i+1:], target-nums[i], k-1) {
+            ans = append(ans, append([]int{nums[i]}, res...))
+        }
+    }
+    return ans
+}
+
+func twoSum(nums []int, target int) [][]int {
+    var ans [][]int
+    l, r := 0, len(nums)-1
+    for l < r {
+        s := nums[l] + nums[r]
+        if s == target {
+            ans = append(ans, []int{nums[l], nums[r]})
+            lv, rv := nums[l], nums[r]
+            for l < r && nums[l] == lv {
+                l++
+            }
+            for l < r && nums[r] == rv {
+                r--
+            }
+        } else if s < target {
+            l++
+        } else {
+            r--
+        }
+    }
+    return ans
+}
+```
+

content/leetcode-problems/4sum.md

@@ -38,13 +38,13 @@ draft = false
 
 ## 解题思路
 
-面积S = (j - i) * min(h[i], h[j]), j > i
-在(1, n)中找出使面积S最大的(i, j)，最简单的方法就是遍历(i, j)的所有可能并比较所有面积。
+面积`S = (j - i) * min(h[i], h[j]), j > i`
+在`(1, n)`中找出使面积S最大的`(i, j)`，最简单的方法就是遍历`(i, j)`的所有可能并比较所有面积。
 
 发现以下规律
 
-1. 当h[i] < h[j]时，不需要计算(i, j-1), (i, j-2), ...，因为它们的面积一定小于(i, j)的面积，因为宽度变小，高度一定<=h[i]。所以下一步应该检查(i+1, j)的面积。
-2. 同理h[i] >= h[j]时，不需要计算(i+1, j), (i+2, j), ...， 所以下一步应该检查(i, j-1)的面积。
+1. 当`h[i] < h[j]`时，不需要计算`(i, j-1), (i, j-2), ...`，因为它们的面积一定小于`(i, j)`的面积，因为宽度变小，高度一定<=`h[i]`。所以下一步应该检查`(i+1, j)`的面积。
+2. 同理`h[i] >= h[j]`时，不需要计算`(i+1, j), (i+2, j), ...`， 所以下一步应该检查`(i, j-1)`的面积。
 
 首尾对撞指针，每次高度较低的指针往中间移动，计算面积更新最大面积。
 

content/leetcode-problems/container-with-most-water.md

@@ -0,0 +1,94 @@
++++
+title = '31. 下一个排列'
+date = 2024-05-01T10:55:07+08:00
+draft = false
+
++++
+
+## [题目](https://leetcode.cn/problems/next-permutation/)
+
+整数数组的一个 **排列** 就是将其所有成员以序列或线性顺序排列。
+
+- 例如，`arr = [1,2,3]` ，以下这些都可以视作 `arr` 的排列：`[1,2,3]`、`[1,3,2]`、`[3,1,2]`、`[2,3,1]` 。
+
+整数数组的 **下一个排列** 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 **下一个排列** 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。
+
+- 例如，`arr = [1,2,3]` 的下一个排列是 `[1,3,2]` 。
+- 类似地，`arr = [2,3,1]` 的下一个排列是 `[3,1,2]` 。
+- 而 `arr = [3,2,1]` 的下一个排列是 `[1,2,3]` ，因为 `[3,2,1]` 不存在一个字典序更大的排列。
+
+给你一个整数数组 `nums` ，找出 `nums` 的下一个排列。
+
+必须**原地**修改，只允许使用额外常数空间。
+
+ 
+
+**示例 1：**
+
+```
+输入：nums = [1,2,3]
+输出：[1,3,2]
+```
+
+**示例 2：**
+
+```
+输入：nums = [3,2,1]
+输出：[1,2,3]
+```
+
+**示例 3：**
+
+```
+输入：nums = [1,1,5]
+输出：[1,5,1]
+```
+
+ 
+
+**提示：**
+
+- `1 <= nums.length <= 100`
+- `0 <= nums[i] <= 100`
+
+## 解题思路
+
+如何找到下一个排列。下一个排列是找到一个大于当前排序的字典序，且变大的幅度最小。那么只能将较小的数与较大数做一次原地交换。并且较小数的下标要尽量靠右，较大数也要尽可能小。原地交换以后，还需要将较大数右边的区间按照升序重新排列。这样交换以后，才能生成下一个排列。以排列 [8,9,6,10,7,2] 为例：能找到的符合条件的一对「较小数」与「较大数」的组合为 6 与 7，满足「较小数」尽量靠右，而「较大数」尽可能小。当完成交换后排列变为 [8,9,7,10,6,2]，此时我们可以重排原本「较小数」右边的区间，变为 [8,9,7,2,6,10]。
+
+1. 找出较小数：较小数后面的区间不存在较小数，所以一定是降序区间，所以从后往前找到第一个不满足降序的元素`nums[i]` ，即不满足`nums[i] >= nums[i+1]`。
+
+2. 找出较大数：较大数要尽可能小，因为较小数后面的区间是降序的，所以从后往前找到第一个大于较小数的元素`nums[j]`，交换较小数`nums[i]`和较大数`nums[j]`。
+3. 后面的区间按照升序重新排列：交换后，后面区间依然是降序的，反转数组就变成升序的。
+
+## 代码
+
+```go
+func nextPermutation(nums []int)  {
+    n := len(nums)
+    if n <= 1 {
+        return
+    }
+    i := n - 2
+    for i >= 0 && nums[i] >= nums[i+1] {
+        i--
+    }
+    if i >= 0 {
+        j := n-1
+        for nums[j] <= nums[i] {
+            j--
+        }
+        nums[i], nums[j] = nums[j], nums[i]
+    }
+    reverse(nums[i+1:])
+}
+
+func reverse(nums []int) {
+    l, r := 0, len(nums)-1
+    for l < r {
+        nums[l], nums[r] = nums[r], nums[l]
+        l++
+        r--
+    }
+}
+```
+

content/leetcode-problems/next-permutation.md

@@ -0,0 +1,79 @@
++++
+title = '26. 删除有序数组中的重复项'
+date = 2024-05-01T10:38:09+08:00
+draft = false
+
++++
+
+## [题目](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/)
+
+给你一个 **非严格递增排列** 的数组 `nums` ，请你**[ 原地](http://baike.baidu.com/item/原地算法)** 删除重复出现的元素，使每个元素 **只出现一次** ，返回删除后数组的新长度。元素的 **相对顺序** 应该保持 **一致** 。然后返回 `nums` 中唯一元素的个数。
+
+考虑 `nums` 的唯一元素的数量为 `k` ，你需要做以下事情确保你的题解可以被通过：
+
+- 更改数组 `nums` ，使 `nums` 的前 `k` 个元素包含唯一元素，并按照它们最初在 `nums` 中出现的顺序排列。`nums` 的其余元素与 `nums` 的大小不重要。
+- 返回 `k` 。
+
+**判题标准:**
+
+系统会用下面的代码来测试你的题解:
+
+```
+int[] nums = [...]; // 输入数组
+int[] expectedNums = [...]; // 长度正确的期望答案
+
+int k = removeDuplicates(nums); // 调用
+
+assert k == expectedNums.length;
+for (int i = 0; i < k; i++) {
+    assert nums[i] == expectedNums[i];
+}
+```
+
+如果所有断言都通过，那么您的题解将被 **通过**。
+
+ 
+
+**示例 1：**
+
+```
+输入：nums = [1,1,2]
+输出：2, nums = [1,2,_]
+解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+```
+
+**示例 2：**
+
+```
+输入：nums = [0,0,1,1,1,2,2,3,3,4]
+输出：5, nums = [0,1,2,3,4]
+解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+```
+
+ 
+
+**提示：**
+
+- `1 <= nums.length <= 3 * 104`
+- `-104 <= nums[i] <= 104`
+- `nums` 已按 **非严格递增** 排列
+
+## 解题思路
+
+双指针，指针i指向去重数组插入位置，迭代数组，如果值和去重数组最后一个元素`nums[i-1]`不同或者是一开始，则插入到去重数组`nums[i] = num`，然后`i++`。
+
+## 代码
+
+```go
+func removeDuplicates(nums []int) int {
+    i := 0
+    for _, num := range nums {
+        if i == 0 || num != nums[i-1] {
+            nums[i] = num
+            i++
+        }
+    }
+    return i
+}
+```
+