俄罗斯方块模拟题从40分到高分：核心难点与代码框架

1. 从40分到更高：这道俄罗斯方块题到底卡在哪

如果你在算法竞赛平台上提交过俄罗斯方块相关的模拟题，大概率经历过这样的场景：本地样例全过，提交上去却只有40分，剩下60分的测试点要么超时，要么答案错误，而且错误信息往往只告诉你"Wrong Answer on test 5"，具体错在哪一无所知。这道题我前前后后做了三遍，第一遍40分，第二遍60分，第三遍才勉强拿到比较满意的分数。今天就把这三次迭代中踩过的坑、想明白的关键点，以及最终那份能拿40分起步的代码框架，完整地拆开讲一遍。

俄罗斯方块这道题在算法竞赛里属于典型的"大模拟"类别，它不考察什么高深的算法，考的是你对题意的理解精度、对边界条件的覆盖能力，以及代码组织的清晰度。很多人一上来就急着写消除逻辑，结果发现连方块怎么下落都没搞对。40分代码通常意味着你只处理了最基础的下落和堆叠，但旋转、消行、计分、边界判定这些环节里至少有两三个是错的或者根本没写。

这篇文章适合两类人：一类是刚接触大模拟题、想拿这道题练手的初学者，另一类是已经写了但卡在40分、60分上不去、想找到问题根源的中等水平选手。我会从题目理解开始，一步步拆解每个模块的设计思路，给出可直接参考的代码结构，并且重点讲清楚那些"看起来对但实际会错"的细节。全文的代码以C++为主，C语言的关键差异我也会标注出来。

提示：大模拟题的核心原则是"先想清楚再动手"。俄罗斯方块的状态空间不大，但状态转移的规则很多，建议先在纸上画出所有可能的情况，再开始写代码。

2. 题目到底要求什么：把规则翻译成代码语言

2.1 俄罗斯方块模拟题的常见出题形式

算法竞赛里的俄罗斯方块题，通常不会让你实现一个完整的游戏，而是给定一个初始棋盘状态和一系列操作指令，要求你模拟执行这些指令后输出最终棋盘。操作指令一般包括：方块下落、左右移动、旋转、快速下落到底部。棋盘大小通常是固定的，比如10列×20行或者题目自定义的尺寸。

题目的输入一般分几部分：首先是棋盘尺寸和初始状态，用0和1表示空格和已填充的格子；然后给出当前方块的类型和初始位置；最后是一串操作指令，比如用字符表示左移、右移、旋转、下落。你需要按照指令顺序执行，每次操作后检查是否合法，不合法就忽略该操作，合法就更新状态。当方块无法继续下落时，将它固定到棋盘上，检查是否有满行需要消除，然后生成下一个方块继续。

这里有个关键点很多人一开始会忽略：方块的固定时机。不是所有操作执行完才固定，而是当方块无法向下移动时立即固定。固定之后如果还有剩余指令，是继续用新方块执行还是停止，题目通常会明确说明。我见过有同学因为没注意这个细节，导致后续所有操作都作用在了错误的对象上。

2.2 40分代码通常漏掉了哪些规则

根据我的经验，40分代码一般只实现了"方块能往下掉、掉到底就停"这个最基础的功能。具体来说，可能漏掉了以下几项中的若干项：

• 旋转的边界处理：旋转后方块可能超出左右边界或与已有方块重叠，需要判断旋转是否合法，不合法则保持原状。
• 消行后的下落：消除满行后，上方的方块需要整体下移，这个下移操作如果实现得不对，会导致棋盘状态错乱。
• 计分规则：有些题目要求输出得分，不同消行数对应不同分数，比如消1行得100分，消2行得300分，消3行得500分，消4行得800分。
• 方块类型的多样性：俄罗斯方块有7种基本形状（I、O、T、S、Z、J、L），每种形状的旋转状态不同，如果只处理了一两种，自然拿不到高分。
• 操作指令的优先级：当多个操作同时有效时，执行顺序可能影响结果，题目通常会规定优先级。

我第一遍做的时候，就是只处理了I型和O型方块，其他五种完全没写旋转逻辑，结果测试点里只要出现T型或S型就挂。后来补全了所有形状，分数才上去。

2.3 输入输出格式的坑：多组数据与终止条件

很多俄罗斯方块题会包含多组测试数据，每组数据以某个特殊值结束，比如输入0 0表示结束。如果你只处理了一组数据，后面的测试点全部会错。还有一种情况是，题目给出的操作指令字符串可能包含无效字符，你需要跳过它们而不是报错。

输出格式也有讲究。有些题目要求输出最终棋盘的每一行，用空格分隔每个格子；有些要求输出得分和棋盘；还有些要求输出消除的总行数。我建议你在写代码之前，先把题目要求的输出格式用注释写在代码开头，每完成一个模块就对照检查一遍。

注意：多组数据的初始化非常重要。每次处理新一组数据前，必须把棋盘、得分、当前方块位置等所有状态变量重置。我见过太多人因为忘记重置某个计数器，导致第二组数据开始就全错。

3. 核心数据结构：棋盘、方块与状态机

3.1 棋盘表示：二维数组还是位运算

棋盘最直观的表示方式是二维数组，比如int board[20][10]，0表示空，1表示已填充。这种方式的优点是直观、易调试，缺点是每次检查碰撞和消行都需要遍历。对于俄罗斯方块这种规模的数据（通常不超过20×10），二维数组完全够用，不需要考虑位运算优化。

但有一个细节需要注意：棋盘的行列顺序。有些题目给出的输入是第一行在最上面，有些则相反。如果你搞反了，下落方向就会完全错误。我的建议是，在读入数据后，先打印一遍棋盘确认方向，再开始写下落逻辑。

// 棋盘定义示例 const int ROWS = 20; const int COLS = 10; int board[ROWS][COLS]; // 初始化 void initBoard() { memset(board, 0, sizeof(board)); }

如果你用C语言写，把memset换成循环赋值即可，效果一样。C++的memset在这里是安全的，因为棋盘是POD类型。

3.2 方块形状的存储：预计算旋转状态

俄罗斯方块的7种基本形状，每种有4个旋转状态（I型和O型实际只有2个和1个有效状态，但为了统一处理，通常还是存4个）。最推荐的做法是预计算所有形状的所有旋转状态，存成一个三维数组或结构体数组。

// 用4个坐标表示一个方块占据的格子（相对于方块原点） struct Block { int cells[4][2]; // 每个格子的(row, col)偏移 }; // 7种形状 × 4个旋转状态 Block shapes[7][4];

预计算的好处是，旋转操作只需要切换索引，不需要实时计算坐标变换，既快又不容易出错。预计算的过程可以在代码开头用硬编码完成，也可以用旋转公式生成。硬编码更直观，但容易写错；公式生成更简洁，但需要理解旋转的数学原理。

我个人的习惯是硬编码，因为写的时候可以对照着图形一个一个填，不容易出错。填完之后打印出来检查一遍，确认每个形状的4个状态都正确。

3.3 当前方块的状态管理

当前方块需要记录的信息包括：形状类型（0-6）、旋转状态（0-3）、以及它在棋盘上的位置（通常用左上角或某个参考点的坐标表示）。每次移动或旋转时，先计算出新位置的坐标，然后检查是否合法，合法则更新，不合法则保持原状。

struct CurrentPiece { int type; // 形状类型 0-6 int rotation; // 旋转状态 0-3 int row, col; // 参考点位置 };

这里有个容易混淆的地方：参考点的选择。如果你用方块的左上角作为参考点，那么不同旋转状态下，方块的形状不同，参考点对应的实际格子也不同。更稳妥的做法是，用方块的"包围盒"左上角作为参考点，这样所有旋转状态下的参考点含义一致。

3.4 状态转移的完整流程

整个模拟过程可以看作一个状态机：读入指令 → 解析指令 → 尝试执行 → 检查合法性 → 更新状态 → 检查是否需要固定 → 固定后消行 → 生成新方块。这个流程需要循环执行，直到所有指令处理完毕。

while (cin >> cmd) { if (cmd == 'a') tryMove(-1, 0); // 左移 else if (cmd == 'd') tryMove(1, 0); // 右移 else if (cmd == 's') tryMove(0, 1); // 下移 else if (cmd == 'w') tryRotate(); // 旋转 // ... 其他指令 }

每次tryMove或tryRotate之后，都要检查方块是否还能继续下落。如果不能，就立即固定并消行。这个检查的时机很关键，放错了位置会导致方块"悬空"或者"穿透"。

4. 下落、旋转与碰撞检测：三个最容易写错的模块

4.1 下落逻辑：为什么你的方块会穿透

下落逻辑看起来最简单，但恰恰是40分代码最容易出问题的地方。核心问题是：什么时候检查碰撞？正确的做法是，每次尝试下移一格时，先计算新位置，检查新位置是否与棋盘边界或已有方块重叠，如果重叠则不下移，并触发固定流程。

bool canPlace(int type, int rot, int row, int col) { for (int i = 0; i < 4; i++) { int r = row + shapes[type][rot].cells[i][0]; int c = col + shapes[type][rot].cells[i][1]; if (r < 0 || r >= ROWS || c < 0 || c >= COLS) return false; if (board[r][c] != 0) return false; } return true; }

这段代码看起来没问题，但有一个隐藏的坑：如果方块的一部分在棋盘上方（row < 0），是否算合法？在标准俄罗斯方块中，方块生成时可能有一部分在可见区域上方，这是允许的。但有些题目会规定方块必须完全在棋盘内。你需要仔细阅读题目，确认这一点。

我第一遍做的时候，就是没有处理row < 0的情况，导致方块生成时就被判定为非法，直接卡死。后来加上了对负行号的特殊处理，才恢复正常。

4.2 旋转的合法性判断：墙踢与踢墙

旋转是俄罗斯方块中最复杂的操作。当你旋转一个方块时，它可能因为靠近边界或靠近其他方块而无法旋转。标准俄罗斯方块有一套"墙踢"（Wall Kick）规则，允许方块在旋转时自动偏移位置以使其合法。但算法竞赛题目通常会简化这个规则，只要求判断旋转后是否合法，不合法就忽略。

void tryRotate() { int newRot = (current.rotation + 1) % 4; if (canPlace(current.type, newRot, current.row, current.col)) { current.rotation = newRot; } // 否则忽略旋转 }

但这里有个细节：旋转的参考点是否变化？如果你用包围盒左上角作为参考点，旋转后包围盒的尺寸可能变化（比如I型横竖切换），参考点需要相应调整。我的做法是，预计算每个旋转状态的包围盒尺寸，旋转时根据新旧尺寸调整参考点位置。

还有一种情况是，题目可能要求实现"踢墙"逻辑，即旋转不合法时尝试左右偏移。如果题目没有明确要求，就不要自作主张加上，否则可能导致与标准答案不一致。

4.3 碰撞检测的边界条件：负坐标与越界

碰撞检测需要覆盖所有边界情况：左边界、右边界、下边界、上边界（如果题目允许方块部分在棋盘外）。最容易漏掉的是负坐标的情况。比如方块左移时，如果参考点的列坐标变成负数，但方块的实际格子可能还在棋盘内（因为参考点不一定是方块的最左列）。

bool canPlace(int type, int rot, int row, int col) { for (int i = 0; i < 4; i++) { int r = row + shapes[type][rot].cells[i][0]; int c = col + shapes[type][rot].cells[i][1]; // 注意：r 可能为负，c 可能为负 if (r >= ROWS || c < 0 || c >= COLS) return false; if (r >= 0 && board[r][c] != 0) return false; } return true; }

注意上面代码中，r < 0时我们不检查棋盘，因为棋盘上方是空的。但c < 0或c >= COLS时必须返回false，因为左右边界是硬性的。

4.4 固定与消行的衔接：顺序错了全盘皆输

当方块无法下落时，需要将它固定到棋盘上，然后检查是否有满行需要消除。这个顺序不能错：先固定，再消行。如果先消行再固定，可能会导致方块被错误地消除。

void fixPiece() { // 1. 将方块写入棋盘 for (int i = 0; i < 4; i++) { int r = current.row + shapes[current.type][current.rotation].cells[i][0]; int c = current.col + shapes[current.type][current.rotation].cells[i][1]; if (r >= 0) board[r][c] = current.type + 1; // 用非零值标记 } // 2. 检查并消除满行 clearFullRows(); // 3. 生成新方块 spawnNewPiece(); }

消行的实现也有讲究。不能直接遍历删除，因为删除一行后，上面的行需要下移。正确的做法是：从下往上遍历，遇到满行就将其删除（将上面的行整体下移），然后继续检查同一位置（因为下移后可能又出现满行）。

void clearFullRows() { for (int r = ROWS - 1; r >= 0; r--) { bool full = true; for (int c = 0; c < COLS; c++) { if (board[r][c] == 0) { full = false; break; } } if (full) { // 将 r 以上的所有行下移一行 for (int i = r; i > 0; i--) { for (int c = 0; c < COLS; c++) { board[i][c] = board[i-1][c]; } } // 最上面一行清空 for (int c = 0; c < COLS; c++) board[0][c] = 0; // 继续检查同一行（因为下移后可能又是满行） r++; } } }

这段代码里r++然后循环的r--会抵消，使得下一次循环仍然检查同一行。这是一个常用技巧，但要注意循环变量的作用域。

5. 消行、计分与多组数据的处理细节

5.1 消行的连锁反应：一次消除多行

俄罗斯方块中，一次固定可能同时消除多行（最多4行）。上面的代码已经处理了这种情况，因为每次消除一行后，上面的行会下移，可能形成新的满行，循环会继续检查。但计分时需要注意：同时消除的行数不同，得分不同。通常是1行100分，2行300分，3行500分，4行800分。

int clearFullRows() { int cleared = 0; for (int r = ROWS - 1; r >= 0; r--) { bool full = true; for (int c = 0; c < COLS; c++) { if (board[r][c] == 0) { full = false; break; } } if (full) { cleared++; for (int i = r; i > 0; i--) { for (int c = 0; c < COLS; c++) { board[i][c] = board[i-1][c]; } } for (int c = 0; c < COLS; c++) board[0][c] = 0; r++; } } return cleared; }

然后在固定方块后调用这个函数，根据返回值累加得分。

5.2 计分规则的常见变体

不同题目的计分规则可能不同，常见的有：

你需要仔细阅读题目，确认使用的是哪种规则。如果题目没有明确说明，通常默认使用第一种。我见过有同学因为计分规则搞错，明明消行逻辑对了，但输出得分不对，导致整道题扣分。

5.3 多组数据的初始化陷阱

如果题目包含多组测试数据，每组数据之间必须完全重置状态。需要重置的变量包括：棋盘数组、当前方块的所有属性、得分、消除行数、以及任何用于临时计算的变量。

void resetAll() { memset(board, 0, sizeof(board)); current.type = 0; current.rotation = 0; current.row = 0; current.col = 0; score = 0; totalCleared = 0; }

我建议把重置逻辑封装成一个函数，在每组数据开始时调用。这样比手动逐个重置更可靠，不容易遗漏。

5.4 输出格式的精确匹配

输出格式是很多人最后丢分的地方。题目要求输出棋盘时，可能要求用空格分隔、可能要求用特定字符表示不同方块、可能要求输出得分和棋盘之间用空行分隔。这些细节必须严格匹配。

// 输出棋盘示例 for (int r = 0; r < ROWS; r++) { for (int c = 0; c < COLS; c++) { if (c > 0) cout << " "; cout << (board[r][c] ? 1 : 0); } cout << endl; }

如果题目要求输出得分，通常在棋盘之前或之后单独一行输出。注意不要多输出空行或少输出空行，这些都会导致格式错误。

6. 从40分到更高：调试与优化的实战经验

6.1 如何定位错误测试点

当你提交后只拿到40分，最直接的方法是构造边界测试数据。俄罗斯方块的边界情况包括：方块在左边界旋转、方块在右边界旋转、方块在底部固定、一次消除多行、连续消除、方块生成时与已有方块重叠等。

我通常会写一个小型的测试数据生成器，随机生成棋盘和操作序列，然后用我的代码和一个已知正确的参考实现（如果有的话）对比输出。如果没有参考实现，就手动构造几个典型场景，逐步验证。

// 手动构造测试数据示例 // 棋盘：底部两行满，中间有空隙 // 操作：让一个I型方块竖着落下，看是否能正确消除

6.2 打印中间状态辅助调试

在关键步骤后打印棋盘和当前方块状态，是定位问题的最有效手段。但要注意，提交代码时一定要把这些调试输出删掉或注释掉，否则会导致输出格式错误。

void debugPrint() { #ifdef DEBUG cout << "Current piece: type=" << current.type << " rot=" << current.rotation << " row=" << current.row << " col=" << current.col << endl; for (int r = 0; r < ROWS; r++) { for (int c = 0; c < COLS; c++) { cout << board[r][c] << " "; } cout << endl; } cout << "---" << endl; #endif }

用#ifdef DEBUG包裹调试代码，这样在提交时只需要不定义DEBUG宏即可，不需要手动删除代码。

6.3 性能优化：大模拟题也会超时

虽然俄罗斯方块的状态空间不大，但如果操作指令非常多（比如10万条），而你的碰撞检测或消行逻辑写得很低效，仍然可能超时。优化的方向包括：

• 碰撞检测提前终止：一旦发现某个格子不合法，立即返回false，不要继续检查。
• 消行时避免不必要的遍历：如果当前行不是满行，直接跳过，不要每次都遍历整行。
• 使用更紧凑的数据结构：比如用char代替int存储棋盘，减少内存访问开销。

// 优化后的碰撞检测 bool canPlace(int type, int rot, int row, int col) { for (int i = 0; i < 4; i++) { int r = row + shapes[type][rot].cells[i][0]; int c = col + shapes[type][rot].cells[i][1]; if (r >= ROWS || c < 0 || c >= COLS) return false; if (r >= 0 && board[r][c]) return false; } return true; }

6.4 代码组织建议：模块化与可读性

大模拟题最怕的就是代码写成一大坨，出了问题根本找不到在哪。我的建议是，把每个功能封装成独立的函数：initBoard、spawnNewPiece、canPlace、tryMove、tryRotate、fixPiece、clearFullRows、outputBoard。每个函数只做一件事，函数之间通过全局状态变量通信。

// 函数声明 void initBoard(); void spawnNewPiece(); bool canPlace(int type, int rot, int row, int col); bool tryMove(int dr, int dc); bool tryRotate(); void fixPiece(); int clearFullRows(); void outputBoard();

这样组织的好处是，当你发现某个测试点错误时，可以快速定位到可能出问题的函数，然后单独测试那个函数。比如如果消行后棋盘状态不对，就重点检查clearFullRows；如果方块旋转后位置不对，就重点检查tryRotate。

6.5 常见错误对照表

这张表是我自己踩坑后总结的，基本上覆盖了90%的常见问题。每次提交前对照检查一遍，能省下大量调试时间。

7. 一份可参考的40分起步代码框架

7.1 完整代码结构

下面这份代码框架实现了基础的下落、左右移动、旋转和消行，能拿到40分左右。你可以在此基础上逐步补全其他功能。

#include <iostream> #include <cstring> using namespace std; const int ROWS = 20; const int COLS = 10; int board[ROWS][COLS]; // 7种形状，每种4个旋转状态，每个状态4个格子 // 这里只展示部分，实际需要补全所有形状 int shapes[7][4][4][2] = { // I型 {{{0,0},{0,1},{0,2},{0,3}}, {{0,0},{1,0},{2,0},{3,0}}, {{0,0},{0,1},{0,2},{0,3}}, {{0,0},{1,0},{2,0},{3,0}}}, // O型 {{{0,0},{0,1},{1,0},{1,1}}, {{0,0},{0,1},{1,0},{1,1}}, {{0,0},{0,1},{1,0},{1,1}}, {{0,0},{0,1},{1,0},{1,1}}}, // 其他形状省略... }; struct Piece { int type, rot, row, col; } cur; void initBoard() { memset(board, 0, sizeof(board)); } bool canPlace(int type, int rot, int row, int col) { for (int i = 0; i < 4; i++) { int r = row + shapes[type][rot][i][0]; int c = col + shapes[type][rot][i][1]; if (r >= ROWS || c < 0 || c >= COLS) return false; if (r >= 0 && board[r][c]) return false; } return true; } bool tryMove(int dr, int dc) { int nr = cur.row + dr; int nc = cur.col + dc; if (canPlace(cur.type, cur.rot, nr, nc)) { cur.row = nr; cur.col = nc; return true; } return false; } bool tryRotate() { int nr = (cur.rot + 1) % 4; if (canPlace(cur.type, nr, cur.row, cur.col)) { cur.rot = nr; return true; } return false; } void fixPiece() { for (int i = 0; i < 4; i++) { int r = cur.row + shapes[cur.type][cur.rot][i][0]; int c = cur.col + shapes[cur.type][cur.rot][i][1]; if (r >= 0) board[r][c] = 1; } } int clearFullRows() { int cleared = 0; for (int r = ROWS - 1; r >= 0; r--) { bool full = true; for (int c = 0; c < COLS; c++) { if (!board[r][c]) { full = false; break; } } if (full) { cleared++; for (int i = r; i > 0; i--) { for (int c = 0; c < COLS; c++) { board[i][c] = board[i-1][c]; } } for (int c = 0; c < COLS; c++) board[0][c] = 0; r++; } } return cleared; } void outputBoard() { for (int r = 0; r < ROWS; r++) { for (int c = 0; c < COLS; c++) { if (c > 0) cout << " "; cout << board[r][c]; } cout << endl; } } int main() { // 读入棋盘初始状态 // 读入方块类型和初始位置 // 读入操作指令并模拟 // 输出最终棋盘 return 0; }

7.2 从40分继续提升的方向

拿到40分之后，你可以按以下顺序逐步补全功能：

1. 补全所有7种形状的旋转状态：这是最基础的，缺一种形状就会丢分。
2. 实现计分逻辑：根据题目要求累加得分。
3. 处理多组数据：确保每组数据之间状态完全重置。
4. 实现墙踢逻辑（如果题目要求）：旋转不合法时尝试左右偏移。
5. 优化性能：如果操作指令很多，检查是否有不必要的遍历。

每补全一个功能，就构造对应的测试数据验证一遍。不要一次性全写完再测，那样出了问题很难定位。

7.3 我个人的调试习惯

我调试大模拟题的习惯是：先写一个最简版本，只处理一种方块、一种操作，确保能跑通；然后逐步增加方块类型和操作类型，每增加一种就测试一次。这样虽然前期慢，但后期几乎不会出现"改了一个地方导致另一个地方出错"的情况。

另外，我会在代码里保留一个debugPrint函数，用宏控制是否启用。每次怀疑某个环节有问题，就打开调试输出，看一眼中间状态，往往能立刻发现问题。

提示：如果你用的是C语言，把memset换成循环赋值，把cout/cin换成printf/scanf，结构完全一样。C语言没有引用和结构体构造函数，但用指针或全局变量也能实现同样的效果。

最后再分享一个小技巧：俄罗斯方块题的测试数据往往包含一些极端情况，比如空棋盘、满棋盘、方块刚好卡在边界、连续消行等。你可以在本地手动构造这些数据，用你的代码跑一遍，看看输出是否合理。如果本地都能过，提交后大概率也能过。如果本地就挂了，那就老老实实调试，别急着提交。