一、游戏介绍与问题建模
俄罗斯方块（Tetris）是由俄罗斯程序员阿列克谢·帕基特诺夫于 1984 年发明的经典益智游戏。游戏的核心玩法是操控不断下落的各种形状方块，通过旋转和移动将它们整齐地堆叠，当一整行被填满时该行消除并得分。
1.1 游戏规则
俄罗斯方块的基本规则：
- 方块类型：共有 7 种标准方块（I、O、T、S、Z、J、L），每种由 4 个小方格组成
- 下落机制：方块从棋盘顶部自动下落，玩家可以左右移动、旋转、加速下落
- 消行规则：当某一行被方块完全填满时，该行消除，上方方块下落填补空缺
- 游戏结束：当新方块无法放入棋盘（顶部被堵住）时游戏结束
- 得分规则：消除行数越多得分越高，单次消除四行（称为”Tetris”）得分最高
1.2 AI 问题建模
将俄罗斯方块 AI 抽象为序列决策问题：
- 状态（State）：当前棋盘布局 + 当前下落方块 + 下一个方块
- 动作（Action）：将当前方块放置到某个位置和旋转角度
- 状态转移：方块落下后，消除满行，生成新的方块
- 目标：尽可能长时间生存（消除尽可能多的行，获得尽可能高的分数）
俄罗斯方块 AI 的核心挑战在于：
- 状态空间巨大：标准 10×20 棋盘的状态空间是天文数字，无法穷举
- 即时奖励稀疏：只有消行时才有明确的奖励，大部分动作没有直接反馈
- 长期依赖：当前的放置决策会影响未来几十步甚至上百步的局面
1.3 算法选择思路
常见的俄罗斯方块 AI 方案：
| 算法类型 | 代表方法 | 优点 | 缺点 |
|---|---|---|---|
| 规则驱动 | 人工编写的启发式规则 | 简单直观 | 效果依赖人工经验，难以优化 |
| 评估函数 | 贪心 + 加权评分 | 效率高，效果好 | 需要调优权重参数 |
| 强化学习 | Q-learning、DQN | 可自动学习最优策略 | 训练周期长，样本效率低 |
| 进化算法 | 遗传算法优化权重 | 自动寻优，效果优秀 | 需要大量模拟评估 |
本文采用贪心评估函数 + 遗传算法的方案：用多维度特征评估每个落子位置的优劣，用遗传算法自动进化出最优的权重组合。
二、状态表示与编码
高效的状态表示是算法性能的基础。俄罗斯方块的状态包括棋盘、当前方块和下一个方块，我们需要设计紧凑且便于操作的数据结构。
2.1 棋盘表示
使用二维布尔数组表示棋盘，true 表示该位置有方块：
/**
* 棋盘类：封装俄罗斯方块棋盘状态
* 标准棋盘大小：10列 × 20行
*/
class Board {
public static final int WIDTH = 10;
public static final int HEIGHT = 20;
private boolean[][] grid; // grid[y][x]，y=0 是顶部
public Board() {
grid = new boolean[HEIGHT][WIDTH];
}
/**
* 复制棋盘
*/
public Board copy() {
Board newBoard = new Board();
for (int y = 0; y < HEIGHT; y++) {
System.arraycopy(grid[y], 0, newBoard.grid[y], 0, WIDTH);
}
return newBoard;
}
/**
* 检查指定位置是否为空
*/
public boolean isEmpty(int x, int y) {
if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) {
return false; // 边界外视为非空
}
return !grid[y][x];
}
}
2.2 方块表示与旋转
7 种标准方块及其旋转状态。每种方块用一个坐标集合表示：
/**
* 方块类型枚举
*/
enum TetrominoType {
I, O, T, S, Z, J, L
}
/**
* 方块类：封装方块的形状、位置和旋转状态
*/
class Tetromino {
private TetrominoType type;
private int rotation; // 旋转状态：0, 1, 2, 3
private int x, y; // 方块锚点位置
// 每种方块的所有旋转状态（相对坐标）
private static final int[][][][] SHAPES = {
// I 型
{
{{0,1},{1,1},{2,1},{3,1}}, // 横向
{{2,0},{2,1},{2,2},{2,3}}, // 纵向
{{0,2},{1,2},{2,2},{3,2}}, // 横向（翻转）
{{1,0},{1,1},{1,2},{1,3}} // 纵向（翻转）
},
// O 型（旋转不变化）
{
{{1,0},{2,0},{1,1},{2,1}},
{{1,0},{2,0},{1,1},{2,1}},
{{1,0},{2,0},{1,1},{2,1}},
{{1,0},{2,0},{1,1},{2,1}}
},
// T 型
{
{{1,0},{0,1},{1,1},{2,1}}, // T 朝上
{{1,0},{1,1},{2,1},{1,2}}, // T 朝右
{{0,1},{1,1},{2,1},{1,2}}, // T 朝下
{{1,0},{0,1},{1,1},{1,2}} // T 朝左
},
// S 型
{
{{1,0},{2,0},{0,1},{1,1}},
{{1,0},{1,1},{2,1},{2,2}},
{{1,1},{2,1},{0,2},{1,2}},
{{0,0},{0,1},{1,1},{1,2}}
},
// Z 型
{
{{0,0},{1,0},{1,1},{2,1}},
{{2,0},{1,1},{2,1},{1,2}},
{{0,1},{1,1},{1,2},{2,2}},
{{1,0},{0,1},{1,1},{0,2}}
},
// J 型
{
{{0,0},{0,1},{1,1},{2,1}},
{{1,0},{2,0},{1,1},{1,2}},
{{0,1},{1,1},{2,1},{2,2}},
{{1,0},{1,1},{0,2},{1,2}}
},
// L 型
{
{{2,0},{0,1},{1,1},{2,1}},
{{1,0},{1,1},{1,2},{2,2}},
{{0,1},{1,1},{2,1},{0,2}},
{{0,0},{1,0},{1,1},{1,2}}
}
};
public Tetromino(TetrominoType type) {
this.type = type;
this.rotation = 0;
this.x = WIDTH / 2 - 2; // 初始居中
this.y = 0;
}
/**
* 获取当前旋转状态下的方块格子坐标（绝对坐标）
*/
public int[][] getCells() {
int[][] shape = SHAPES[type.ordinal()][rotation];
int[][] cells = new int[4][2];
for (int i = 0; i < 4; i++) {
cells[i][0] = x + shape[i][0];
cells[i][1] = y + shape[i][1];
}
return cells;
}
/**
* 旋转（顺时针）
*/
public void rotate() {
rotation = (rotation + 1) % 4;
}
/**
* 获取旋转后的方块（不修改当前对象）
*/
public Tetromino rotated() {
Tetromino t = new Tetromino(type);
t.rotation = (this.rotation + 1) % 4;
t.x = this.x;
t.y = this.y;
return t;
}
}
2.3 落子位置枚举
AI 的核心是枚举所有可能的落子位置，然后评估每个位置的优劣。对于每种方块，可能的落子位置数量是有限的：
/**
* 枚举当前方块在棋盘上所有可能的落子位置
* @return 所有合法的终态棋盘（方块已落下，消行后）
*/
public List<Board> enumerateAllPlacements(Board board, Tetromino piece) {
List<Board> result = new ArrayList<>();
Set<Integer> visited = new HashSet<>(); // 避免重复的终态
// 枚举所有旋转状态
for (int rot = 0; rot < 4; rot++) {
Tetromino rotatedPiece = new Tetromino(piece.getType());
for (int r = 0; r < rot; r++) {
rotatedPiece.rotate();
}
// 枚举所有水平位置
for (int x = -2; x < WIDTH + 2; x++) {
rotatedPiece.setX(x);
rotatedPiece.setY(0);
// 检查初始位置是否合法
if (!isValidPosition(board, rotatedPiece)) {
continue;
}
// 让方块下落到最底部
Tetromino dropped = dropPiece(board, rotatedPiece);
// 生成落子后的棋盘
Board newBoard = placePiece(board, dropped);
// 消行
int linesCleared = clearLines(newBoard);
// 用棋盘哈希去重（不同的旋转/路径可能得到相同结果）
int hash = boardHash(newBoard);
if (!visited.contains(hash)) {
visited.add(hash);
result.add(newBoard);
}
}
}
return result;
}
/**
* 将方块下落到最底部
*/
private Tetromino dropPiece(Board board, Tetromino piece) {
Tetromino result = piece.copy();
while (canMoveDown(board, result)) {
result.moveDown();
}
return result;
}
/**
* 检查方块位置是否合法
*/
private boolean isValidPosition(Board board, Tetromino piece) {
for (int[] cell : piece.getCells()) {
int x = cell[0];
int y = cell[1];
if (x < 0 || x >= WIDTH || y >= HEIGHT) {
return false;
}
if (y >= 0 && !board.isEmpty(x, y)) {
return false;
}
}
return true;
}
三、贪心评估函数设计
贪心评估函数是 AI 的”大脑”，它为每个可能的落子位置打分，AI 选择分数最高的位置落子。评估函数的质量直接决定了 AI 的水平。
3.1 核心特征提取
一个好的评估函数需要从多个维度衡量棋盘状态的优劣。经典的评估特征包括：
1. 消行数（Lines Cleared）
落子后消除的行数，这是最直接的奖励。
/**
* 特征1：消行数
*/
public int featureLinesCleared(Board board) {
int lines = 0;
for (int y = 0; y < HEIGHT; y++) {
boolean full = true;
for (int x = 0; x < WIDTH; x++) {
if (board.isEmpty(x, y)) {
full = false;
break;
}
}
if (full) lines++;
}
return lines;
}
2. 总高度（Aggregate Height）
每一列高度的总和。总高度越高，游戏越危险。
/**
* 特征2：总高度（所有列高度之和）
*/
public int featureAggregateHeight(Board board) {
int total = 0;
for (int x = 0; x < WIDTH; x++) {
total += getColumnHeight(board, x);
}
return total;
}
/**
* 获取某一列的高度
*/
private int getColumnHeight(Board board, int x) {
for (int y = 0; y < HEIGHT; y++) {
if (!board.isEmpty(x, y)) {
return HEIGHT - y; // 从底部算起
}
}
return 0;
}
3. 空洞数（Number of Holes）
空洞是指被方块堵住、无法从顶部填充的空格。空洞越多越难消除。
/**
* 特征3：空洞数
* 空洞定义：某列中，在最高方块下方的空格数量
*/
public int featureHoles(Board board) {
int holes = 0;
for (int x = 0; x < WIDTH; x++) {
boolean foundBlock = false;
for (int y = 0; y < HEIGHT; y++) {
if (!board.isEmpty(x, y)) {
foundBlock = true;
} else if (foundBlock) {
holes++;
}
}
}
return holes;
}
4. 平整度（Bumpiness）
各列高度之间的差异总和。平整度差意味着有很多”台阶”，不利于方块放置。
/**
* 特征4：平整度（各列高度差的绝对值之和）
*/
public int featureBumpiness(Board board) {
int bumpiness = 0;
int prevHeight = getColumnHeight(board, 0);
for (int x = 1; x < WIDTH; x++) {
int currHeight = getColumnHeight(board, x);
bumpiness += Math.abs(currHeight - prevHeight);
prevHeight = currHeight;
}
return bumpiness;
}
5. 最大高度（Max Height）
最高一列的高度，反映当前的危险程度。
/**
* 特征5：最大高度
*/
public int featureMaxHeight(Board board) {
int maxH = 0;
for (int x = 0; x < WIDTH; x++) {
maxH = Math.max(maxH, getColumnHeight(board, x));
}
return maxH;
}
3.2 加权评估函数
将上述特征乘以各自的权重，求和得到最终评分：
/**
* 评估函数权重类
*/
class Weights {
double linesCleared; // 消行数权重（正）
double aggregateHeight; // 总高度权重（负）
double holes; // 空洞数权重（负）
double bumpiness; // 平整度权重（负）
double maxHeight; // 最大高度权重（负）
public Weights(double lines, double aggHeight, double holes,
double bumpiness, double maxHeight) {
this.linesCleared = lines;
this.aggregateHeight = aggHeight;
this.holes = holes;
this.bumpiness = bumpiness;
this.maxHeight = maxHeight;
}
}
/**
* 贪心评估函数
* 分数越高表示状态越好
*/
public double evaluate(Board board, Weights weights) {
int lines = featureLinesCleared(board);
int aggHeight = featureAggregateHeight(board);
int holes = featureHoles(board);
int bumpiness = featureBumpiness(board);
int maxHeight = featureMaxHeight(board);
return weights.linesCleared * lines
+ weights.aggregateHeight * aggHeight
+ weights.holes * holes
+ weights.bumpiness * bumpiness
+ weights.maxHeight * maxHeight;
}
3.3 贪心 AI 实现
有了评估函数，贪心 AI 的实现就非常简单了：枚举所有落子位置，选择评分最高的那个。
/**
* 贪心俄罗斯方块 AI
*/
class GreedyTetrisAI {
private Weights weights;
public GreedyTetrisAI(Weights weights) {
this.weights = weights;
}
/**
* 选择最优落子位置
* @param board 当前棋盘
* @param current 当前方块
* @param next 下一个方块（可选，用于前瞻）
* @return 最优落子后的棋盘
*/
public Board chooseBestMove(Board board, Tetromino current, Tetromino next) {
List<Board> placements = enumerateAllPlacements(board, current);
if (placements.isEmpty()) {
return null; // 游戏结束
}
Board bestBoard = null;
double bestScore = Double.NEGATIVE_INFINITY;
for (Board placement : placements) {
double score;
if (next != null) {
// 一步前瞻：考虑下一个方块的最优情况
score = evaluateWithNext(placement, next);
} else {
// 纯贪心：只评估当前落子
score = evaluate(placement, weights);
}
if (score > bestScore) {
bestScore = score;
bestBoard = placement;
}
}
return bestBoard;
}
/**
* 一步前瞻评估：当前落子后，下一个方块的最优评分
*/
private double evaluateWithNext(Board board, Tetromino nextPiece) {
List<Board> nextPlacements = enumerateAllPlacements(board, nextPiece);
if (nextPlacements.isEmpty()) {
return Double.NEGATIVE_INFINITY; // 死局
}
double bestScore = Double.NEGATIVE_INFINITY;
for (Board nextBoard : nextPlacements) {
double score = evaluate(nextBoard, weights);
bestScore = Math.max(bestScore, score);
}
return bestScore;
}
}
四、遗传算法进化最优权重
评估函数的效果高度依赖于权重参数的选择。人工调参不仅费时费力，而且很难找到最优组合。遗传算法（Genetic Algorithm）可以自动进化出优秀的权重参数。
4.1 遗传算法原理
遗传算法是一种模拟自然选择和生物进化的优化算法：
- 种群初始化：随机生成一组候选解（个体）
- 适应度评估：评估每个个体的优劣（适应度）
- 选择：根据适应度选择优秀个体进行繁殖
- 交叉：将两个父代的基因组合产生后代
- 变异：随机改变后代的某些基因，增加多样性
- 迭代：重复步骤 2-5，直到满足终止条件
4.2 个体编码与适应度函数
在我们的问题中，每个个体就是一组权重参数：
/**
* 遗传算法中的个体（一组权重参数）
*/
class Individual {
Weights weights;
double fitness; // 适应度
public Individual(Weights weights) {
this.weights = weights;
this.fitness = 0;
}
/**
* 随机生成个体
*/
public static Individual random() {
// 各权重在合理范围内随机初始化
double lines = 0.5 + Math.random() * 2.0; // 0.5 ~ 2.5
double aggHeight = -2.0 - Math.random() * 2.0; // -4.0 ~ -2.0
double holes = -3.0 - Math.random() * 4.0; // -7.0 ~ -3.0
double bumpiness = -0.5 - Math.random() * 1.5; // -2.0 ~ -0.5
double maxHeight = -1.0 - Math.random() * 2.0; // -3.0 ~ -1.0
return new Individual(new Weights(lines, aggHeight, holes, bumpiness, maxHeight));
}
}
适应度函数：用 AI 玩若干局游戏，取平均消行数作为适应度。
/**
* 评估个体适应度
* 玩 numGames 局游戏，取平均消行数
*/
public double evaluateFitness(Individual individual, int numGames) {
int totalLines = 0;
for (int i = 0; i < numGames; i++) {
totalLines += playGame(individual.weights);
}
return (double) totalLines / numGames;
}
/**
* 用指定权重玩一局游戏，返回消行数
*/
private int playGame(Weights weights) {
Board board = new Board();
GreedyTetrisAI ai = new GreedyTetrisAI(weights);
int linesCleared = 0;
Tetromino current = randomPiece();
Tetromino next = randomPiece();
while (true) {
Board nextBoard = ai.chooseBestMove(board, current, next);
if (nextBoard == null) {
break; // 游戏结束
}
// 统计消行数
int lines = countLinesCleared(board, nextBoard);
linesCleared += lines;
board = nextBoard;
current = next;
next = randomPiece();
}
return linesCleared;
}
4.3 选择、交叉与变异
/**
* 遗传算法核心类
*/
class GeneticAlgorithm {
private int populationSize;
private double mutationRate;
private double crossoverRate;
private int eliteCount; // 精英保留数量
private List<Individual> population;
public GeneticAlgorithm(int popSize, double mutRate, double crossRate, int elite) {
this.populationSize = popSize;
this.mutationRate = mutRate;
this.crossoverRate = crossRate;
this.eliteCount = elite;
}
/**
* 初始化种群
*/
public void initPopulation() {
population = new ArrayList<>();
for (int i = 0; i < populationSize; i++) {
population.add(Individual.random());
}
}
/**
* 选择：锦标赛选择法
* 随机选取 tournamentSize 个个体，返回其中最好的
*/
private Individual tournamentSelect(int tournamentSize) {
Individual best = null;
double bestFitness = Double.NEGATIVE_INFINITY;
for (int i = 0; i < tournamentSize; i++) {
int idx = (int)(Math.random() * population.size());
Individual ind = population.get(idx);
if (ind.fitness > bestFitness) {
bestFitness = ind.fitness;
best = ind;
}
}
return best;
}
/**
* 交叉：均匀交叉
* 每个基因位随机选择父代1或父代2的值
*/
public Individual crossover(Individual parent1, Individual parent2) {
if (Math.random() > crossoverRate) {
return parent1; // 不交叉，直接返回父代1
}
Weights w1 = parent1.weights;
Weights w2 = parent2.weights;
double lines = Math.random() < 0.5 ? w1.linesCleared : w2.linesCleared;
double aggH = Math.random() < 0.5 ? w1.aggregateHeight : w2.aggregateHeight;
double holes = Math.random() < 0.5 ? w1.holes : w2.holes;
double bump = Math.random() < 0.5 ? w1.bumpiness : w2.bumpiness;
double maxH = Math.random() < 0.5 ? w1.maxHeight : w2.maxHeight;
return new Individual(new Weights(lines, aggH, holes, bump, maxH));
}
/**
* 变异：高斯扰动
* 对每个权重添加一个小的随机扰动
*/
public void mutate(Individual individual) {
Weights w = individual.weights;
w.linesCleared += mutateGene(w.linesCleared);
w.aggregateHeight += mutateGene(w.aggregateHeight);
w.holes += mutateGene(w.holes);
w.bumpiness += mutateGene(w.bumpiness);
w.maxHeight += mutateGene(w.maxHeight);
}
/**
* 单个基因的变异量
*/
private double mutateGene(double value) {
if (Math.random() > mutationRate) {
return 0; // 不变异
}
// 高斯扰动，标准差为原值绝对值的 10%
double std = Math.abs(value) * 0.1;
return new Random().nextGaussian() * std;
}
}
4.4 完整进化流程
/**
* 运行遗传算法
*/
public Individual run(int generations, int gamesPerEval) {
// 初始化种群
initPopulation();
// 评估初始种群
evaluatePopulation(gamesPerEval);
for (int gen = 0; gen < generations; gen++) {
// 按适应度排序
Collections.sort(population, (a, b) -> Double.compare(b.fitness, a.fitness));
System.out.printf("第 %d 代 | 最佳适应度: %.1f | 平均适应度: %.1f%n",
gen + 1, population.get(0).fitness, getAverageFitness());
List<Individual> newPopulation = new ArrayList<>();
// 精英保留：直接复制最好的个体
for (int i = 0; i < eliteCount; i++) {
newPopulation.add(population.get(i));
}
// 繁殖剩余个体
while (newPopulation.size() < populationSize) {
Individual parent1 = tournamentSelect(5);
Individual parent2 = tournamentSelect(5);
Individual child = crossover(parent1, parent2);
mutate(child);
newPopulation.add(child);
}
population = newPopulation;
// 评估新一代
evaluatePopulation(gamesPerEval);
}
// 返回最佳个体
Collections.sort(population, (a, b) -> Double.compare(b.fitness, a.fitness));
return population.get(0);
}
/**
* 评估整个种群的适应度
*/
private void evaluatePopulation(int gamesPerEval) {
for (Individual ind : population) {
ind.fitness = evaluateFitness(ind, gamesPerEval);
}
}
4.5 进化结果示例
经过约 50 代进化后，典型的优秀权重参数如下：
| 特征 | 典型权重 | 说明 |
|---|---|---|
| 消行数 | +0.76 | 消行是正奖励 |
| 总高度 | -0.51 | 高度越高越危险 |
| 空洞数 | -3.58 | 空洞是最大的敌人 |
| 平整度 | -0.18 | 平整度差有负面影响 |
| 最大高度 | -0.70 | 最高列是危险信号 |
可以看到，空洞数的权重绝对值最大，这符合直觉——空洞是俄罗斯方块中最难处理的问题，AI 学会了极力避免产生空洞。
五、复杂度分析与实战效果对比
5.1 时间复杂度分析
| 模块 | 时间复杂度 | 说明 |
|---|---|---|
| 落子枚举 | O(R × W) | R 为旋转状态数（最多4），W 为棋盘宽度（10） |
| 特征计算 | O(W × H) | 每个特征都需要遍历棋盘 |
| 单步决策 | O(R × W × W × H) | 每个落子位置都需要评估 |
| 一局游戏 | O(N × R × W × W × H) | N 为游戏步数（通常几百到几千） |
| 遗传算法 | O(G × P × N × …) | G为代数，P为种群大小 |
对于标准 10×20 棋盘：
– 单步决策：约 4 × 10 × 10 × 20 = 8,000 次操作，非常快
– 一局游戏：约 1,000 步 × 8,000 = 800 万次操作，毫秒级完成
– 遗传算法（50代，50个个体，每局5局）：50 × 50 × 5 × 800万 = 1,000 亿次操作，需要数分钟到数十分钟
5.2 空间复杂度分析
| 模块 | 空间复杂度 | 说明 |
|---|---|---|
| 棋盘状态 | O(W × H) | 10×20 = 200 个布尔值 |
| 落子枚举 | O(R × W × W × H) | 存储所有可能的终态棋盘 |
| 遗传算法种群 | O(P × F) | P为种群大小，F为特征数（5个权重） |
空间复杂度很低，完全不是瓶颈。
5.3 实战效果对比
我们对比几种不同策略的 AI 表现：
| 策略 | 平均消行数 | 说明 |
|---|---|---|
| 随机落子 | ~5 行 | 纯随机，很快就死 |
| 只看消行数 | ~30 行 | 只追求消行，很快堆到顶部 |
| 人工调参 | ~500 行 | 有经验的玩家手动调参 |
| 遗传算法（10代） | ~2,000 行 | 初步进化 |
| 遗传算法（50代） | ~10,000+ 行 | 深度进化，非常强 |
注意：实际数值受随机种子、评估局数等因素影响，以上仅为大致数量级参考。
遗传算法进化出的 AI 水平远超人类玩家，可以稳定消除上万行。这是因为 AI 每一步都在全局最优地权衡各种因素，而人类很难做到如此精确的量化判断。
5.4 影响性能的关键因素
1. 特征选择
特征的质量比数量更重要。空洞数、总高度、平整度这三个特征是核心，缺少任何一个性能都会大幅下降。
2. 前瞻深度
一步前瞻（考虑下一个方块）比纯贪心效果好很多，但两步前瞻的收益递减，且计算量增加一个数量级。
3. 种群大小与进化代数
– 种群太小：容易陷入局部最优
– 种群太大：计算量增加，进化变慢
– 推荐：种群 30-50，进化 30-50 代
六、适用场景与扩展思路
6.1 适用场景
俄罗斯方块 AI 的算法思路可以推广到以下场景：
- 益智游戏 AI：各类消除类游戏、堆叠类游戏的自动玩家
- 装箱问题：集装箱装载、仓储货架规划等二维/三维装箱问题
- 资源调度：云计算中的资源分配、任务调度（类似方块填充）
- 生产排程：流水线作业调度、工序安排
- 组合优化：许多 NP 难的组合优化问题都可以用”评估函数 + 进化算法”的思路求解
6.2 扩展思路
1. 深度学习替代遗传算法
用深度强化学习（如 DQN、PPO）替代遗传算法，让 AI 端到端地学习策略：
思路：
- 状态：棋盘图像（10×20 的二值图像）
- 动作：所有可能的落子位置
- 奖励：消行数、生存时间
- 算法：DQN / PPO / A2C
深度学习的优势是可以自动学习特征，不需要人工设计评估函数。但缺点是训练周期长、样本效率低。
2. 混合方法：深度学习 + 评估函数
将深度学习和传统方法结合：
– 用评估函数做快速决策（每秒几千步）
– 用深度学习在关键局面做更深入的分析
– 类似国际象棋中的”评估函数 + 搜索”模式
3. 多目标优化
不只是追求消行数，同时优化多个目标：
– 消行数（得分）
– 游戏速度（效率）
– 连击数（Tetris 连击）
– 难度曲线（给人类玩家设计对手）
使用多目标遗传算法（如 NSGA-II），得到一组 Pareto 最优解。
4. 不规则方块 / 自定义棋盘
将算法扩展到非标准的俄罗斯方块变体：
– 自定义方块形状
– 不同大小的棋盘
– 增加障碍物的棋盘
– 多人对战模式
6.3 总结
俄罗斯方块是一个看似简单实则深邃的经典问题。从人工规则到贪心评估，从遗传算法到深度学习，俄罗斯方块 AI 的演进史几乎就是人工智能算法发展的缩影。
本文介绍的”贪心评估函数 + 遗传算法”方案，是经典与现代的完美结合：贪心评估保证了决策效率，遗传算法自动寻优避免了人工调参的困难。这种思路在工程实践中非常实用——当你遇到一个难以精确求解的优化问题时，不妨试试”设计评估函数 + 进化算法调参”的组合拳。
思考练习：如果俄罗斯方块的方块数量从 7 种增加到 20 种，评估函数需要增加哪些新特征？遗传算法的收敛速度会受到怎样的影响？
