3个细节搞定老版连连看算法，面试高频考点不再慌

上周刚帮一个后端同事复盘面试，他在二面挂了。面试官只问了一句：“如果让你实现老版连连看里的路径查找逻辑，怎么保证性能？”他愣了足足十秒，脑子里全是死循环的 BFS 代码，完全没想过边界情况。这其实是典型的面试被问原理答不上来。

别觉得连连看是玩具游戏。在掘金技术社区的很多前端面试帖子里，这块逻辑常被用来考察候选人对图论基础、队列操作以及边界处理的真实功底。它不仅是高频面试题，更是检验你能否把简单逻辑写出健壮代码的试金石。很多新手死记硬背 BFS 模板，一遇到“障碍物”或“连通性”变体就懵圈。

今天这篇文章，我不讲虚的，直接拆解老版连连看的核心算法。我们聚焦于最经典的“两点一线”和“两点折线”判定，通过 Python 实现一个可运行的核心模块。你会看到，真正坑人的不是算法复杂度，而是那些隐藏在角落里的逻辑漏洞。

概念速懂：为什么连连看是图论微缩版

很多初学者以为连连看就是简单的“找路”。错了。老版连连看的判定逻辑，本质上是带约束的最短路径搜索。

在标准的连连看规则中，两个方块能被消除，必须满足三个条件之一：

直线相连：两点之间没有障碍物。
一次折线：中间经过一个转折点，且两段直线均无障碍。
两次折线：中间经过两个转折点，形成 U 型或 Z 型路径，且所有线段均无障碍。

这里有一个极易被忽略的细节：棋盘边缘是虚拟的空位。很多新手写代码时，只遍历棋盘内部的格子，导致靠边的方块无法通过“绕外圈”的方式消除。在真实的老版连连看引擎中，棋盘通常被处理为比可视区域大一圈的矩阵，外围一圈填充空值，这样所有方块都能利用“空气”进行路径连接。

从图论角度看，每个方块是一个节点，相邻的空位是边。我们要找的不是任意路径，而是转弯次数不超过 2 次的路径。这个约束条件，直接决定了我们不能用普通的 Dijkstra 或 A*，而必须使用带有状态压缩的 BFS 或专门设计的几何判定算法。

环境准备：极简依赖与数据结构选择

为了让大家能最快跑通代码，我们选择 Python 3.8+ 环境。不需要安装任何第三方库，标准库 collections 中的 deque 足以应对 BFS 的性能需求。

我们需要定义两个核心数据结构：

棋盘矩阵 (board)：一个二维列表，board[r][c] 存储方块的值。0 表示空位，非 0 表示方块 ID。注意，为了处理边缘逻辑，我们的矩阵维度应该是 (rows + 2) x (cols + 2)，可视区域在中间。
方向向量 (directions)：上下左右四个方向的偏移量 [(-1, 0), (1, 0), (0, -1), (0, 1)]。

避坑提示：千万不要用递归 DFS 来实现路径查找。在 15x15 的棋盘上，虽然规模不大，但递归的深度可能接近方块总数，且回溯逻辑复杂，极易出现栈溢出或重复计算。BFS 天然适合这种“层序”搜索，且一旦找到路径即可返回，效率远高于 DFS。

核心语法：BFS 状态压缩的关键

实现老版连连看路径判定的核心难点在于：如何记录当前的转弯次数。

普通的 BFS 队列只存坐标 (r, c)。但在这里，同一个坐标，如果是“直行”到达和“转弯”到达，其后续扩展能力是不同的。因此，我们的队列节点必须包含状态：(row, col, turns, last_dir)。

turns: 当前已经转弯的次数。
last_dir: 上一个移动的方向（0:上, 1:下, 2:左, 3:右，-1:起点）。

关键逻辑：当从上一个节点移动到当前节点时：

如果当前移动方向与 last_dir 相同，turns 不变。
如果不同，turns 加 1。
剪枝条件：如果 turns > 2，直接丢弃该节点。因为题目要求最多两次折线，超过两次就无法消除。

此外，我们需要一个 visited 数组来记录访问状态。但普通的 visited[r][c] = True 是不够的。我们需要记录到达该位置时的最小转弯次数。如果当前路径的转弯次数大于等于之前到达该位置的最少转弯次数，则无需继续扩展。即：visited[r][c][last_dir] 存储的是到达该点且最后方向为 last_dir 时的最小转弯数。

完整代码示例：可运行的核心判定模块

下面是一段完整的、可直接运行的 Python 代码，实现了老版连连看中“两个方块是否可连通”的核心判定逻辑。

from collections import deque
from typing import List, Tupleclass LinkLinkGame:def __init__(self, rows: int, cols: int):self.rows = rowsself.cols = cols# 初始化棋盘，外围一圈为0（虚拟空位）# 实际可视区域从 (1, 1) 到 (rows, cols)self.board = [[0] * (cols + 2) for _ in range(rows + 2)]def is_empty(self, r: int, c: int) -> bool:"""判断坐标是否为空位"""if r < 0 or r >= self.rows + 2 or c < 0 or c >= self.cols + 2:return Falsereturn self.board[r][c] == 0def can_connect(self, r1: int, c1: int, r2: int, c2: int) -> bool:"""判断 (r1, c1) 和 (r2, c2) 是否可以连通注意：输入的 r, c 是可视区域坐标 (1-based)，内部自动转换"""if r1 == r2 and c1 == c2:return False# 起点和终点必须是有效的方块if self.board[r1][c1] == 0 or self.board[r2][c2] == 0:return False# BFS 初始化# 队列元素: (row, col, turns, last_dir)# last_dir: -1 表示起点，0:上, 1:下, 2:左, 3:右queue = deque([(r1, c1, 0, -1)])# visited[r][c][dir] 存储到达该点且最后方向为 dir 时的最小转弯数# 初始化为无穷大INF = float('inf')visited = [[[INF] * 4 for _ in range(self.cols + 2)] for _ in range(self.rows + 2)]# 方向向量: 上, 下, 左, 右directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]while queue:curr_r, curr_c, curr_turns, last_dir = queue.popleft()# 如果到达终点，检查转弯次数是否合法if curr_r == r2 and curr_c == c2:return curr_turns <= 2# 优化：如果当前转弯数已经 >= 之前记录的最小值，跳过# 这里其实需要在出队时检查，但为了逻辑清晰，我们在入队前控制# 更严谨的做法是：在扩展邻居时检查for i, (dr, dc) in enumerate(directions):next_r = curr_r + drnext_c = curr_c + dc# 计算新的转弯次数if last_dir == -1:# 起点，第一个方向不算转弯new_turns = 0elif last_dir == i:# 方向相同，不增加转弯new_turns = curr_turnselse:# 方向改变，增加转弯new_turns = curr_turns + 1# 剪枝：转弯超过2次，直接跳过if new_turns > 2:continue# 检查下一步是否越界（其实 board 已经处理了边界，但保险起见）if next_r < 0 or next_r >= self.rows + 2 or next_c < 0 or next_c >= self.cols + 2:continue# 情况1：下一步是终点if next_r == r2 and next_c == c2:return new_turns <= 2# 情况2：下一步是空位，可以继续扩展if self.board[next_r][next_c] == 0:# 检查是否以更优（更少转弯）的状态访问过if new_turns < visited[next_r][next_c][i]:visited[next_r][next_c][i] = new_turnsqueue.append((next_r, next_c, new_turns, i))# 情况3：下一步是障碍物，停止该方向扩展else:continuereturn False# --- 测试用例 ---
if __name__ == "__main__":# 创建一个 3x3 的棋盘game = LinkLinkGame(3, 3)# 初始化棋盘数据 (1-based 坐标)# 1  2  0# 0  0  0# 0  3  0# 注意：board 内部索引从 1 开始对应可视区域game.board[1][1] = 1game.board[1][2] = 2game.board[3][2] = 3# 测试1: (1,1) 和 (3,2) 能否连通?# 路径: (1,1) -> (2,1) -> (3,1) -> (3,2)  转弯2次，合法print(f"Test 1 (1,1) to (3,2): {game.can_connect(1, 1, 3, 2)}") # Expected: True# 测试2: 添加障碍物game.board[2][1] = 5  # 在 (2,1) 放置障碍物# 路径: (1,1) -> (1,2) 是方块，不通# 路径: (1,1) -> (2,1) 是障碍，不通# 路径: (1,1) -> (1,0) -> (2,0) -> (3,0) -> (3,1) -> (3,2) 转弯3次，非法print(f"Test 2 (1,1) to (3,2) with obstacle: {game.can_connect(1, 1, 3, 2)}") # Expected: False# 测试3: 直线连通game.board[2][1] = 0  # 移除障碍物game.board[1][1] = 0  # 移除起点方块以测试逻辑？不，can_connect 要求起点非空# 重新设置game.board[1][1] = 1game.board[1][3] = 1  # 在 (1,3) 放一个相同的# (1,1) 到 (1,3): (1,1) -> (1,2) -> (1,3). (1,2)是方块2，不通# 修正：把 (1,2) 设为空game.board[1][2] = 0print(f"Test 3 (1,1) to (1,3) straight: {game.can_connect(1, 1, 1, 3)}") # Expected: True

代码逐行解析：

visited 数组的设计：这是本例最精妙的地方。我们不仅记录“来过”，还记录“以什么方向、最少几次转弯来过”。这避免了 BFS 在网格图中常见的重复遍历问题，将时间复杂度从指数级降低到多项式级。
last_dir == -1 的处理：起点的第一个移动方向不消耗转弯次数。很多新手在这里会多算一次，导致直线相连的方块被误判为“一次折线”。
终点判定前置：在扩展邻居时，先判断是否为终点。如果 next_r, next_c 是终点，直接返回。这比出队后判断更高效，因为 BFS 是按层扩展的，第一次触达终点必然是最优解（转弯最少）。

常见报错与调试技巧

在实际项目中，这段代码可能会遇到两类典型 Bug：

1. 边缘方块无法消除

现象：位于棋盘最外圈的方块，明明旁边是空的，却提示无法连通。
原因：board 矩阵初始化时，忘记在四周填充 0。导致 BFS 在尝试向棋盘外扩展时，被 is_empty 或边界检查拦截。
对策：确保 board 的维度是 rows+2 和 cols+2，且初始全为 0。在代码中，我们使用了 self.rows + 2 作为边界判断，这是为了容纳虚拟的外圈。

2. 死循环或内存溢出

现象：程序卡死，CPU 占用率 100%。
原因：visited 数组更新逻辑错误，导致同一个状态被多次入队。例如，忘记检查 new_turns < visited[next_r][next_c][i]。
对策：BFS 中，入队前必须做剪枝判断。对于带权（这里是转弯数）的 BFS，只有当新状态严格优于旧状态时才入队。

调试建议：在开发阶段，建议在 queue.append 之前打印 curr_r, curr_c, new_turns。如果看到同一坐标反复出现且转弯数没有递减，说明 visited 逻辑失效。可以使用 logging 模块替代 print，方便后续关闭日志。