Hot100算法题61-70解析与面试实战技巧

1. Hot100算法题解析（61-70）实战指南

作为刷过3000+算法题的过来人，我深知Hot100在面试准备中的核心地位。这个系列将带大家深度拆解第61到70题的解题套路，分享我在实际刷题中验证过的优化技巧。不同于普通的题解，这里会重点讲解如何识别题目套路，以及面试官在这些题目上真正想考察的思维逻辑。

2. 高频考题核心解法精讲

2.1 第61题：旋转链表

典型场景：给定链表头节点和旋转位数k，将链表每个节点向右移动k位

python复制def rotateRight(head, k):
    if not head: return None
    
    # 计算链表长度并形成环
    tail, n = head, 1
    while tail.next:
        tail = tail.next
        n += 1
    tail.next = head
    
    # 找到新头节点前驱
    new_tail = head
    for _ in range(n - k%n - 1):
        new_tail = new_tail.next
    
    new_head = new_tail.next
    new_tail.next = None
    return new_head

关键技巧：

1. 先遍历获取链表长度n，此时尾节点自动定位
2. 将尾节点与头节点连接形成环
3. 计算实际需要旋转的步数（k%n处理k>n的情况）
4. 找到新头节点的前驱节点并断开环

注意：当k大于链表长度时，实际旋转次数是k%n，避免无效循环

2.2 第62题：不同路径

动态规划经典问题：m×n网格从左上角到右下角的唯一路径数

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]

优化方案：

• 空间复杂度可优化到O(n)：只用一维数组存储当前行数据
• 数学解法：组合数C(m+n-2, m-1)，适合m,n较小时使用

常见误区：

• 边界条件处理（m或n为1时直接返回1）
• 初始化第一行和第一列都为1（只有一条直线路径）

3. 典型题型解题模板

3.1 第63题：不同路径II（含障碍物）

python复制def uniquePathsWithObstacles(grid):
    m, n = len(grid), len(grid[0])
    dp = [[0]*n for _ in range(m)]
    dp[0][0] = 1 if grid[0][0] == 0 else 0
    
    for i in range(m):
        for j in range(n):
            if grid[i][j] == 1:
                dp[i][j] = 0
                continue
            if i > 0: dp[i][j] += dp[i-1][j]
            if j > 0: dp[i][j] += dp[i][j-1]
    
    return dp[-1][-1]

与62题的区别处理：

1. 初始化时遇到障碍物直接置0
2. 状态转移时跳过障碍物格子
3. 边界条件更复杂（第一行/列中出现障碍物后后续格子都不可达）

3.2 第64题：最小路径和

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

优化技巧：

• 原地修改：直接使用grid矩阵作为dp数组
• 空间优化：用两个一维数组分别保存当前行和上一行数据

4. 高频算法套路解析

4.1 第65题：有效数字（状态机解法）

python复制def isNumber(s):
    # 定义状态转移表
    states = [
        {'blank':0, 'sign':1, 'digit':2, '.':3},   # 0.起始状态
        {'digit':2, '.':3},                        # 1.符号位后
        {'digit':2, '.':4, 'e':5, 'blank':8},      # 2.数字
        {'digit':4},                               # 3.左边无数字的小数点
        {'digit':4, 'e':5, 'blank':8},             # 4.左边有数字的小数点
        {'sign':6, 'digit':7},                     # 5.指数e
        {'digit':7},                               # 6.指数符号位
        {'digit':7, 'blank':8},                    # 7.指数数字
        {'blank':8}                                # 8.结尾空格
    ]
    
    current = 0
    for c in s:
        if c.isdigit():
            typ = 'digit'
        elif c in '+-':
            typ = 'sign'
        elif c == '.':
            typ = '.'
        elif c in 'eE':
            typ = 'e'
        elif c == ' ':
            typ = 'blank'
        else:
            return False
        
        if typ not in states[current]:
            return False
        current = states[current][typ]
    
    return current in {2,4,7,8}

状态机设计要点：

1. 定义所有可能的输入字符类型（digit, sign, e, ., blank）
2. 绘制完整状态转移图（共9个状态）
3. 最终有效状态为2/4/7/8

4.2 第66题：加一

python复制def plusOne(digits):
    n = len(digits)
    for i in range(n-1, -1, -1):
        if digits[i] < 9:
            digits[i] += 1
            return digits
        digits[i] = 0
    return [1] + digits

边界情况处理：

• 末位非9时直接加1返回
• 全为9时需要数组扩容（在最前面插入1）

5. 二叉树系列问题

5.1 第67题：二进制求和

python复制def addBinary(a, b):
    res = []
    carry = 0
    i, j = len(a)-1, len(b)-1
    
    while i >=0 or j >=0 or carry:
        sum_ = carry
        if i >=0: sum_ += int(a[i])
        if j >=0: sum_ += int(b[j])
        res.append(str(sum_ %2))
        carry = sum_ //2
        i -=1; j -=1
    
    return ''.join(reversed(res))

优化技巧：

• 使用ASCII码转换：ord(a[i]) - ord('0')比int(a[i])更快
• 预先分配结果数组大小避免频繁扩容

5.2 第68题：文本左右对齐

python复制def fullJustify(words, maxWidth):
    res = []
    line, length = [], 0
    
    for word in words:
        if length + len(word) + len(line) > maxWidth:
            # 分配空格
            spaces = maxWidth - length
            if len(line) == 1:
                res.append(line[0] + ' '*spaces)
            else:
                avg = spaces // (len(line)-1)
                extra = spaces % (len(line)-1)
                for i in range(extra):
                    line[i] += ' '
                res.append((' '*avg).join(line))
            line, length = [], 0
        line.append(word)
        length += len(word)
    
    # 处理最后一行
    res.append(' '.join(line).ljust(maxWidth))
    return res

关键逻辑：

1. 贪心算法收集每行单词
2. 平均分配空格（无法整除时左边多分）
3. 最后一行左对齐特殊处理

6. 动态规划进阶

6.1 第69题：x的平方根

python复制def mySqrt(x):
    if x < 2: return x
    
    left, right = 2, x//2
    while left <= right:
        mid = left + (right-left)//2
        num = mid * mid
        if num > x:
            right = mid -1
        elif num < x:
            left = mid +1
        else:
            return mid
    return right

二分查找要点：

• 初始右边界取x//2（因为sqrt(x) ≤ x/2 when x>2）
• 使用left + (right-left)//2防止溢出
• 返回right而不是left（因为循环结束时right < left）

6.2 第70题：爬楼梯

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

进阶思考：

1. 空间优化到O(1)的滚动数组技巧
2. 矩阵快速幂解法（O(logn)时间复杂度）
3. 通项公式解法（涉及黄金分割比）

7. 面试实战技巧

1. 白板编码规范：

   • 先写测试用例再写代码
   • 变量命名要有意义（避免i,j,k）
   • 适当添加注释解释复杂逻辑

2. 复杂度分析要点：

   • 时间复杂度要说明最坏/平均情况
   • 空间复杂度包括递归栈和辅助空间
   • 能给出多种解法时主动比较优劣

3. 常见follow-up问题：

   • 如何测试你的代码？
   • 如果输入规模非常大怎么办？
   • 如何扩展到分布式环境？

8. 刷题路线建议

1. 第一阶段（1-2周）：

   • 按题目顺序刷Hot100
   • 重点理解基础解法
   • 记录每题的思考过程

2. 第二阶段（3-4周）：

   • 按题型分类刷题
   • 总结同类题目的解题模板
   • 尝试一题多解

3. 第三阶段（持续）：

   • 参加周赛/双周赛
   • 定期复习错题本
   • 尝试用不同语言实现

对于时间紧张的求职者，建议优先掌握这10题中涉及的：

• 链表操作（61）
• 二维DP（62-64）
• 字符串处理（65）
• 数学技巧（69-70）