10.6.0

Automatically generated by python-semantic-release

Author: semantic-release

README.md

@@ -0,0 +1,87 @@
+# 二分查找
+
+**「二分」的本质是二段性，并非单调性。只要一段满足某个性质，另外一段不满足某个性质，就可以用「二分」。**
+
+```python3
+# bisect.bisect_left
+def binary_search(arr, target):
+    left, right = 0, len(arr) - 1
+    while left <= right:
+        mid = left + (right - left) // 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+    return -1
+```
+
+```go
+package main
+
+func BinarySearch(arr []int, target int) int {
+    left, right := 0, len(arr)-1
+    for left <= right {
+        mid := left + (right-left)/2
+        if arr[mid] == target {
+            return mid
+        } else if arr[mid] < target {
+            left = mid + 1
+        } else {
+            right = mid - 1
+        }
+    }
+    return -1
+}
+```
+
+## 带重复元素的旋转数组
+
+```go
+package main
+
+// 这里的二段性是一段满足<target，另一段不满足
+func binarySearch(nums []int, left, right, target int) int {
+	l, r := left, right
+	for l < r {
+		mid := l + (r-l)/2
+		if nums[mid] < target {
+			l = mid + 1
+		} else {
+			r = mid
+		}
+	}
+	if nums[r] == target {
+		return r
+	}
+	return -1
+}
+
+func search(nums []int, target int) bool {
+	n := len(nums)
+	left, right := 0, n-1
+	// 恢复二段性
+	for left < right && nums[right] == nums[left] {
+		right--
+	}
+	// 这里的二段性是一段满足>=nums[0]，另一段不满足
+	for left < right {
+		mid := left + (right-left+1)/2
+		if nums[mid] >= nums[0] {
+			left = mid
+		} else {
+			right = mid - 1
+		}
+	}
+	idx := n
+	if nums[right] >= nums[0] && right < n-1 {
+		idx = right + 1
+	}
+	if target >= nums[0] {
+		return binarySearch(nums, 0, idx-1, target) != -1
+	} else {
+		return binarySearch(nums, idx, n-1, target) != -1
+	}
+}
+```

array/binary_search.md

@@ -0,0 +1,2 @@
+# 差分数组
+

array/differential.md

@@ -0,0 +1,65 @@
+# 双指针
+
+- 双指针技巧通常用于处理数组或链表问题，如**快慢指针**检测循环、**左右指针**解决有序数组问题等。
+
+## 示例：移除元素（原地删除）
+
+```python
+def remove_element(nums, val):
+    slow = 0
+    for fast in range(len(nums)):
+        if nums[fast] != val:
+            nums[slow] = nums[fast]
+            slow += 1
+    return slow
+```
+
+```go
+package main
+
+func removeElement(nums []int, val int) int {
+    slow := 0
+    for fast := 0; fast < len(nums); fast++ {
+        if nums[fast] != val {
+            nums[slow] = nums[fast]
+            slow++
+        }
+    }
+    return slow
+}
+```
+
+## 示例：有序数组两数之和
+
+```python
+def two_sum(nums, target):
+    left, right = 0, len(nums) - 1
+    while left < right:
+        s = nums[left] + nums[right]
+        if s == target:
+            return [left + 1, right + 1]
+        elif s < target:
+            left += 1
+        else:
+            right -= 1
+    return []
+```
+
+```go
+package main
+
+func twoSum(nums []int, target int) []int {
+    left, right := 0, len(nums)-1
+    for left < right {
+        sum := nums[left] + nums[right]
+        if sum == target {
+            return []int{left+1, right+1}
+        } else if sum < target {
+            left++
+        } else {
+            right--
+        }
+    }
+    return []int{}
+}
+```

array/double_pointer.md

@@ -0,0 +1,53 @@
+# 单调栈
+
+## 单调栈适用场景
+
+单调栈可以在时间复杂度为$`O(n)`$，求解出某个元素左边或者右边第一个比它大或者小的元素。
+
+单调栈一般用于解决一下几种问题：
+
+- 寻找左侧第一个比当前元素大的元素。
+- 寻找左侧第一个比当前元素小的元素。
+- 寻找右侧第一个比当前元素大的元素。
+- 寻找右侧第一个比当前元素小的元素。
+
+```python3
+def solve(nums):
+    max_stack = []
+    for i, num in enumerate(nums):
+        while max_stack and num > nums[max_stack[-1]]:
+            max_stack.pop()
+        max_stack.append(i)
+```
+
+```go
+package main
+
+func subArrayRanges(nums []int) (ans int64) {
+	n := len(nums)
+	minStack, maxStack := make([]int, 0, n), make([]int, 0, n)
+	for i := 0; i <= n; i++ {
+		for len(maxStack) > 0 && (i == n || nums[i] > nums[maxStack[len(maxStack)-1]]) {
+			j := maxStack[len(maxStack)-1]
+			maxStack = maxStack[:len(maxStack)-1]
+			left := -1
+			if len(maxStack) > 0 {
+				left = maxStack[len(maxStack)-1]
+			}
+			ans += int64(nums[j]) * int64(j-left) * int64(i-j)
+		}
+		maxStack = append(maxStack, i)
+		for len(minStack) > 0 && (i == n || nums[i] < nums[minStack[len(minStack)-1]]) {
+			j := minStack[len(minStack)-1]
+			minStack = minStack[:len(minStack)-1]
+			left := -1
+			if len(minStack) > 0 {
+				left = minStack[len(minStack)-1]
+			}
+			ans -= int64(nums[j]) * int64(j-left) * int64(i-j)
+		}
+		minStack = append(minStack, i)
+	}
+	return
+}
+```

array/monotonic_stack.md

@@ -0,0 +1,86 @@
+# 前缀和
+
+$`prefix\_sum[i] = \sum_{k=0}^{i-1} nums[k]`$
+
+$`prefix\_sum[i] - prefix\_sum[j] = \sum_{k=j}^{i-1} nums[k]`$
+
+```python
+from itertools import accumulate
+
+
+def pivot_index(nums) -> int:
+    pre_sum = [0] + list(accumulate(nums))
+    for i, num in enumerate(nums):
+        if pre_sum[i] == pre_sum[-1] - pre_sum[i + 1]:
+            return i
+    return -1
+```
+
+```go
+package main
+
+func pivotIndex(nums []int) int {
+	n := len(nums)
+	prefixSum := make([]int, n+1)
+	for i := 0; i < n; i++ {
+		prefixSum[i+1] = prefixSum[i] + nums[i]
+	}
+	for i := 0; i < n; i++ {
+		if prefixSum[i] == prefixSum[n]-prefixSum[i+1] {
+			return i
+		}
+	}
+	return -1
+}
+```
+
+## 二维前缀和
+
+$`prefix\_sum[i][j] = \sum_{k=0}^{i-1} \sum_{l=0}^{j-1} matrix[k][l]`$
+
+$
+`prefix\_sum[i][j] - prefix\_sum[i][l] - prefix\_sum[k][j] + prefix\_sum[k][l] = \sum_{x=k}^{i-1} \sum_{y=l}^{j-1} matrix[x][y]`$
+
+```python
+def sum_region(matrix, row1, col1, row2, col2):
+    m = len(matrix)
+    if m == 0:
+        return 0
+    n = len(matrix[0])
+    pre_sum = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            pre_sum[i][j] = pre_sum[i - 1][j] + pre_sum[i][j - 1] - pre_sum[i - 1][j - 1] + matrix[i - 1][j - 1]
+    return pre_sum[row2 + 1][col2 + 1] - pre_sum[row1][col2 + 1] - pre_sum[row2 + 1][col1] + pre_sum[row1][col1]
+```
+
+```go
+package main
+
+type NumMatrix struct {
+    preSum [][]int
+}
+
+func Constructor(matrix [][]int) NumMatrix {
+    m := len(matrix)
+    if m == 0 {
+        return NumMatrix{}
+    }
+    n := len(matrix[0])
+    preSum := make([][]int, m+1)
+    for i := range preSum {
+        preSum[i] = make([]int, n+1)
+    }
+    
+    for i := 1; i <= m; i++ {
+        for j := 1; j <= n; j++ {
+            preSum[i][j] = preSum[i-1][j] + preSum[i][j-1] - preSum[i-1][j-1] + matrix[i-1][j-1]
+        }
+    }
+    return NumMatrix{preSum: preSum}
+}
+
+func (this *NumMatrix) SumRegion(row1 int, col1 int, row2 int, col2 int) int {
+    return this.preSum[row2+1][col2+1] - this.preSum[row1][col2+1] - this.preSum[row2+1][col1] + this.preSum[row1][col1]
+}
+```

array/prefix_sum.md

@@ -0,0 +1,38 @@
+# 滑动窗口
+
+```python3
+def max_sliding_window(nums, k):
+    from collections import deque
+    q = deque()
+    res = []
+    for i in range(len(nums)):
+        if q and q[0] < i - k + 1:
+            q.popleft()
+        while q and nums[q[-1]] < nums[i]:
+            q.pop()
+        q.append(i)
+        if i >= k - 1:
+            res.append(nums[q[0]])
+    return res
+```
+
+```go
+package main
+
+func maxSlidingWindow(nums []int, k int) (ans []int) {
+    q := make([]int, 0)
+    for i := range nums {
+        if len(q) > 0 && q[0] < i-k+1 {
+            q = q[1:]
+        }
+        for len(q) > 0 && nums[q[len(q)-1]] < nums[i] {
+            q = q[:len(q)-1]
+        }
+        q = append(q, i)
+        if i >= k-1 {
+            ans = append(ans, nums[q[0]])
+        }
+    }
+    return
+}
+```