1
# 手动双指针写法
2
l, r = 0, 1
3
while r < len(nums):
4
    # ...
5
    r += 1  # 手动移动
6

7
# for 循环写法（等价）
8
for r in range(1, len(nums)):
9
    # r 自动 +1

1
class Solution:
2
    def removeDuplicates(self, nums: List[int]) -> int:
3
        l = 1  # 第一个元素永远保留，从第二个位置开始填
4

5
        for r in range(1, len(nums)):
6
            if nums[r] != nums[r - 1]:  # 遇到新元素
7
                nums[l] = nums[r]        # 放到 l 的位置
8
                l += 1
9
        return l  # l 本身就是不重复元素的数量

1
class Solution:
2
    def moveZeroes(self, nums: List[int]) -> None:
3
        l, r = 0, 0
4

5
        while r < len(nums):
6
            if nums[r] != 0:
7
                nums[l], nums[r] = nums[r], nums[l]  # 交换
8
                l += 1  # l 右移，等待下一个非零数字
9
            r += 1      # r 每轮都右移探测

1
class Solution:
2
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
3
        left = 0
4
        right = len(numbers) - 1
5

6
        while left < right:
7
            if numbers[left] + numbers[right] > target:
8
                right -= 1
9
            elif numbers[left] + numbers[right] < target:
10
                left += 1
11
            else:
12
                return [left + 1, right + 1]  # 下标从 1 开始，所以 +1
13

14
        return []  # 题目保证有解，这行可写可不写

1
class Solution:
2
    def threeSum(self, nums: list[int]) -> list[list[int]]:
3
        # 先升序排序，让双指针可以有方向地移动
4
        res = []
5
        nums.sort()
6

7
        # enumerate 同时拿到锚点的索引和值
8
        for i, number in enumerate(nums):
9

10
            # 锚点去重：如果当前锚点和上一个相同，跳过
11
            # 因为结果会完全重复，没有意义
12
            if i > 0 and number == nums[i - 1]:
13
                continue
14

15
            # 初始化左右指针，在锚点右边的范围内找两数之和
16
            l = i + 1
17
            r = len(nums) - 1
18

19
            # 只要左右指针没相遇就继续
20
            while l < r:
21
                temp_three_sum = number + nums[l] + nums[r]
22
                # 和太大，右指针左移（让和变小）
23
                if temp_three_sum > 0:
24
                    r -= 1
25
                # 和太小，左指针右移（让和变大）
26
                elif temp_three_sum < 0:
27
                    l += 1
28
                else:
29
                    # 找到和为 0 的三个数，加入结果列表
30
                    res.append([number, nums[l], nums[r]])
31
                    l += 1
32
                    # 左指针去重：跳过和上一个相同的数字
33
                    # 注意 l < r 要放前面，防止越界后再访问 nums[l]
34
                    while l < r and nums[l] == nums[l - 1]:
35
                        l += 1
36
        return res

1
class Solution:
2
    def lengthOfLIS(self, nums: List[int]) -> int:
3
        # 初始化 LIS 列表，每个数字的 LIS 初始值为 1（自己本身）
4
        LIS = [1] * len(nums)
5

6
        for i in range(len(nums) - 1, -1, -1):  # 从右往左遍历（锚点）
7
            for j in range(i + 1, len(nums)):    # j 从 i 右边一位遍历到末尾
8
                # 只有右边数字更大时，才能形成递增子序列，才更新 LIS[i]
9
                if nums[j] > nums[i]:
10
                    LIS[i] = max(LIS[i], 1 + LIS[j])
11

12
        # LIS 的起点可以是任意一个数字，所以返回 LIS 中的最大值
13
        return max(LIS)

1
nums = [1, 2, 4, 3]
2
LIS  = [1, 1, 1, 1]  # 初始
3

4
i=3(3): 右边没有数，LIS 不变
5
i=2(4): 右边没有比 4 大的，LIS 不变
6
i=1(2): nums[2]=4>2，LIS[1]=max(1,1+1)=2
7
        nums[3]=3>2，LIS[1]=max(2,1+1)=2
8
        LIS=[1,2,1,1]
9
i=0(1): nums[1]=2>1，LIS[0]=max(1,1+2)=3
10
        LIS=[3,2,1,1]
11

12
返回 max(LIS) = 3  ✓  （子序列是 [1,2,4] 或 [1,2,3]）

1
class Solution:
2
    def solve(self, arr):
3
        n = len(arr)
4

5
        # 第一步：定义状态并初始化
6
        dp = [初始值] * n  # 或者 dp = {状态: 值}
7

8
        # 可能需要 base case
9
        dp[边界位置] = 边界值
10

11
        # 第二步：确定遍历顺序和递推关系
12
        # 方案A：从左往右（依赖左边）
13
        for i in range(1, n):
14
            # 根据 dp[i-1] 等推导 dp[i]
15
            dp[i] = f(dp[i-1], arr[i])
16

17
        # 方案B：从右往左（依赖右边）
18
        for i in range(n-2, -1, -1):
19
            # 根据 dp[i+1] 等推导 dp[i]
20
            dp[i] = f(dp[i+1], arr[i])
21

22
        # 第三步：返回答案
23
        return max(dp) / min(dp) / dp[n-1] / ...