华为OD机考：开心消消乐算法实现与优化

1. 项目背景与核心需求

华为OD机考中的双机位编程题"开心消消乐"是一个典型的算法模拟题，主要考察候选人在限定条件下的编码实现能力。题目基于经典消除游戏机制，要求用Java实现特定规则下的方块消除逻辑。

这类题目在技术面试中具有多重考察价值：

• 基础数据结构应用（二维数组、栈等）
• 边界条件处理能力
• 递归/循环结构的合理使用
• 代码可读性与模块化设计

注意：双机位考试模式下，系统会同步监控考生的编码过程和屏幕内容，任何非常规操作都可能触发异常判定。

2. 题目解析与算法设计

2.1 题目规则拆解

典型题目描述示例：

code复制给定M×N的方块矩阵，当三个或更多相同方块水平/垂直相邻时触发消除。消除后上方方块下落填补空缺，空缺位置由随机生成的新方块补充。重复此过程直到无更多可消除块。

输入：初始矩阵
输出：最终矩阵和消除总次数

关键判定条件：

1. 消除优先级：同时满足多个消除条件时，按从左到右、从上到下的顺序处理
2. 下落规则：消除列中所有上方方块整体下落
3. 补充规则：空缺处填充1-9的随机数

2.2 核心算法选择

推荐采用深度优先搜索(DFS)实现消除检测：

java复制// 示例DFS检测代码段
void dfs(int[][] grid, int i, int j, int target, boolean[][] visited, List<int[]> toRemove) {
    if(i<0 || i>=grid.length || j<0 || j>=grid[0].length 
       || visited[i][j] || grid[i][j] != target) {
        return;
    }
    visited[i][j] = true;
    toRemove.add(new int[]{i,j});
    // 四方向搜索
    dfs(grid,i+1,j,target,visited,toRemove);
    dfs(grid,i-1,j,target,visited,toRemove);
    dfs(grid,i,j+1,target,visited,toRemove);
    dfs(grid,i,j-1,target,visited,toRemove);
}

2.3 数据结构设计

建议使用组合数据结构：

• 主矩阵：int[][] 存储当前方块状态
• 消除标记：boolean[][] 记录待消除位置
• 下落缓存：Stack 辅助处理列下落

3. 完整实现方案

3.1 主流程实现

java复制public class HappyElimination {
    private static final int[] DX = {0,0,1,-1};
    private static final int[] DY = {1,-1,0,0};
    
    public static void main(String[] args) {
        int[][] matrix = generateMatrix(8, 8); // 示例初始化
        playGame(matrix);
    }
    
    static void playGame(int[][] grid) {
        int steps = 0;
        while(true) {
            boolean changed = false;
            boolean[][] marked = new boolean[grid.length][grid[0].length];
            
            // 检测阶段
            for(int i=0; i<grid.length; i++) {
                for(int j=0; j<grid[0].length; j++) {
                    if(!marked[i][j] && grid[i][j] != 0) {
                        List<int[]> group = new ArrayList<>();
                        dfsFind(grid, i, j, grid[i][j], 
                               new boolean[grid.length][grid[0].length], group);
                        if(group.size() >= 3) {
                            changed = true;
                            for(int[] pos : group) {
                                marked[pos[0]][pos[1]] = true;
                            }
                        }
                    }
                }
            }
            
            if(!changed) break;
            
            // 消除阶段
            steps++;
            eliminateAndFill(grid, marked);
        }
        System.out.println("Total steps: " + steps);
        printMatrix(grid);
    }
}

3.2 关键操作实现

下落填充算法示例：

java复制static void eliminateAndFill(int[][] grid, boolean[][] marked) {
    // 列处理
    for(int j=0; j<grid[0].length; j++) {
        Stack<Integer> stack = new Stack<>();
        // 收集未消除元素
        for(int i=0; i<grid.length; i++) {
            if(!marked[i][j]) {
                stack.push(grid[i][j]);
            }
        }
        // 重新填充列
        int empty = grid.length - stack.size();
        for(int i=0; i<empty; i++) {
            grid[i][j] = (int)(Math.random()*9)+1;
        }
        for(int i=empty; i<grid.length; i++) {
            grid[i][j] = stack.pop();
        }
    }
}

4. 优化策略与考试技巧

4.1 性能优化要点

1. 增量检测：只在发生变化的行列周围进行消除检测
2. 记忆化搜索：缓存已检测过的无效位置
3. 批量处理：合并连续的消除操作

优化后的检测逻辑：

java复制boolean checkElimination(int[][] grid, int i, int j) {
    // 水平检测
    int left = j, right = j;
    while(left>0 && grid[i][left-1]==grid[i][j]) left--;
    while(right<grid[0].length-1 && grid[i][right+1]==grid[i][j]) right++;
    
    // 垂直检测
    int up = i, down = i;
    while(up>0 && grid[up-1][j]==grid[i][j]) up--;
    while(down<grid.length-1 && grid[down+1][j]==grid[i][j]) down++;
    
    return (right-left>=2) || (down-up>=2);
}

4.2 机考实战技巧

1. 代码结构规划（建议时间分配）：

   • 前5分钟：明确输入输出格式
   • 10分钟：设计核心数据结构
   • 25分钟：实现主逻辑
   • 最后5分钟：边界测试

2. 调试建议：

   • 优先处理单列消除的情况
   • 添加临时打印语句验证中间状态

   java复制void debugPrint(int[][] grid) {
       for(int[] row : grid) {
           System.out.println(Arrays.toString(row));
       }
       System.out.println("-----");
   }
   

3. 异常处理：

   • 显式处理空矩阵输入
   • 验证随机数生成范围
   • 添加数组越界保护

5. 常见问题与解决方案

5.1 消除顺序问题

现象：同一轮次中多个消除组处理顺序影响最终结果

解决方案：

java复制// 使用优先队列确保处理顺序
PriorityQueue<int[]> queue = new PriorityQueue<>((a,b)->{
    if(a[0] != b[0]) return a[0]-b[0];
    return a[1]-b[1];
});

// 将待消除位置按行列排序后处理
while(!queue.isEmpty()) {
    int[] pos = queue.poll();
    grid[pos[0]][pos[1]] = 0; 
}

5.2 无限循环问题

触发条件：新生成的方块恰好形成可消除组合

解决方法：

java复制// 在填充新方块后立即检查
for(int j=0; j<grid[0].length; j++) {
    for(int i=0; i<emptyCount; i++) {
        int newVal;
        do {
            newVal = (int)(Math.random()*9)+1;
        } while(i>0 && newVal==grid[i-1][j]); // 避免垂直相同
        grid[i][j] = newVal;
    }
}

5.3 性能优化对比

测试数据：8x8矩阵连续消除100次

6. 扩展思考

6.1 变体题型可能性

1. 限制步数模式：在指定步数内达到目标分数
2. 特殊方块设计：加入炸弹、彩虹方块等特殊元素
3. 连锁反应计分：根据连锁次数加权计分

6.2 高级算法应用

对于更大规模的矩阵（如100x100），可以考虑：

• 并查集(Union-Find)快速分组
• 多线程并行处理列操作
• GPU加速的矩阵运算

java复制// 并行下落处理示例
IntStream.range(0, grid[0].length).parallel().forEach(j -> {
    processColumn(grid, j);
});

在华为OD的实际编码考察中，建议先确保基础功能的正确实现，再根据剩余时间考虑性能优化。我个人的经验是，在双机位监控环境下，保持代码结构清晰比追求极致优化更重要，因为阅卷时会重点考察代码的可读性和逻辑完备性。