LeetCode热题100解析：链表、动态规划与回溯算法实战

1. 题目概览与解题思路

最近在刷LeetCode热题100的第61-70题，发现这几道题涵盖了链表操作、动态规划、回溯算法等经典题型。作为算法练习的重要资源，Hot 100系列题目确实能帮助我们快速掌握面试中的高频考点。

这10道题中，有几道特别值得深入探讨：

• 第61题旋转链表考察链表操作基本功
• 第62题不同路径是经典的动态规划入门题
• 第70题爬楼梯则是更简单的DP问题

2. 链表操作精讲：旋转链表（第61题）

2.1 问题分析与解法思路

旋转链表的要求是将链表每个节点向右移动k个位置。看似简单，但有几个关键点需要注意：

1. 当k大于链表长度时，实际只需要移动k%length次
2. 需要找到新的尾节点（原尾节点前第k%length个节点）
3. 将原尾节点指向原头节点形成环，再断开新尾节点后的连接

python复制def rotateRight(head, k):
    if not head or not head.next or k == 0:
        return head
    
    # 计算链表长度并找到尾节点
    length = 1
    tail = head
    while tail.next:
        tail = tail.next
        length += 1
    
    # 计算实际需要旋转的次数
    k = k % length
    if k == 0:
        return head
    
    # 找到新的尾节点
    new_tail = head
    for _ in range(length - k - 1):
        new_tail = new_tail.next
    
    # 旋转链表
    new_head = new_tail.next
    new_tail.next = None
    tail.next = head
    
    return new_head

2.2 常见错误与调试技巧

在实际编码中，容易犯的几个错误：

1. 忘记处理k为0或k是链表长度整数倍的情况
2. 没有正确计算链表长度导致指针越界
3. 新尾节点定位错误

调试时可以：

1. 先画出链表示意图
2. 打印关键节点的值验证
3. 使用小样例手动模拟

3. 动态规划专题：不同路径（第62题）

3.1 基础DP解法

这是一个典型的二维动态规划问题。我们可以定义dp[i][j]表示到达(i,j)格子的不同路径数。

状态转移方程：
dp[i][j] = dp[i-1][j] + dp[i][j-1]

边界条件：
第一行和第一列的所有格子都只有1种走法

python复制def uniquePaths(m, n):
    dp = [[1]*n for _ in range(m)]
    
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i-1][j] + dp[i][j-1]
    
    return dp[-1][-1]

3.2 空间优化技巧

观察状态转移方程可以发现，当前状态只依赖于上一行和左边的状态，因此可以将空间复杂度从O(mn)优化到O(n)：

python复制def uniquePaths(m, n):
    dp = [1] * n
    
    for _ in range(1, m):
        for j in range(1, n):
            dp[j] += dp[j-1]
    
    return dp[-1]

4. 回溯算法实践：子集（第78题）

4.1 递归回溯解法

子集问题要求返回数组的所有可能子集。典型的回溯算法应用场景。

python复制def subsets(nums):
    res = []
    
    def backtrack(start, path):
        res.append(path.copy())
        for i in range(start, len(nums)):
            path.append(nums[i])
            backtrack(i+1, path)
            path.pop()
    
    backtrack(0, [])
    return res

4.2 位运算解法

对于小规模数据（n<=32），还可以使用位运算来枚举所有子集：

python复制def subsets(nums):
    n = len(nums)
    res = []
    
    for mask in range(1 << n):
        subset = []
        for i in range(n):
            if mask & (1 << i):
                subset.append(nums[i])
        res.append(subset)
    
    return res

5. 高频考点：爬楼梯（第70题）

5.1 基础递归与记忆化

爬楼梯问题看似简单，但能考察对递归和动态规划的理解。

递归解法（会超时）：

python复制def climbStairs(n):
    if n <= 2:
        return n
    return climbStairs(n-1) + climbStairs(n-2)

记忆化递归：

python复制def climbStairs(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 2:
        return n
    memo[n] = climbStairs(n-1) + climbStairs(n-2)
    return memo[n]

5.2 动态规划优化

最优解法是使用动态规划，将空间复杂度降到O(1)：

python复制def climbStairs(n):
    if n <= 2:
        return n
    a, b = 1, 2
    for _ in range(3, n+1):
        a, b = b, a + b
    return b

6. 解题技巧总结

在刷这10道题的过程中，我总结了几个重要经验：

1. 链表问题一定要先画图，理清指针关系
2. 动态规划问题要明确状态定义和转移方程
3. 回溯问题要掌握模板，注意递归终止条件和选择列表
4. 简单问题也要考虑优化空间，体现算法思维
5. 多写测试用例，特别是边界情况

提示：在实际面试中，即使遇到做过的题目，也要从头开始分析，向面试官展示思考过程，而不是直接写答案。