返回题解分享
讨论 / 题解分享/ 帖子详情

LITS 游戏(编程题) - 题解

视频中标准程序代码如下:

import java.util.*;

class Main {
    static final int N = 55;
    static int[][] a = new int[N][N];
    static int f = 0;
    static int n;

    static void dfs(int step) {
        if (f != 0) return;
        if (step == 1) {
            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= n; j++)
                {

                
                        if (j + 3 <= n) {
                            if (a[i][j] + a[i][j + 1] + a[i][j + 2] + a[i][j + 3] == 4) {
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i][j + 3] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i][j + 3] = 1;
                            }
                        }
                        if (i + 3 <= n) {
                            if (a[i][j] + a[i + 1][j] + a[i + 2][j] + a[i + 3][j] == 4) {
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 3][j] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 3][j] = 1;
                            }
                        }
                }
        } else if (step == 2) {
            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= n; j++)
                {
                        if (i + 1 <= n && j + 2 <= n) {
                            if (a[i][j] == 1 && a[i][j + 1] == 1 && a[i][j + 2] == 1 && a[i + 1][j + 1] == 1) {
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 1] = 1;
                            }
                            if (a[i + 1][j] == 1 && a[i + 1][j + 1] == 1 && a[i + 1][j + 2] == 1 && a[i][j + 1] == 1) {
                                a[i + 1][j] = a[i + 1][j + 1] = a[i + 1][j + 2] = a[i][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i + 1][j] = a[i + 1][j + 1] = a[i + 1][j + 2] = a[i][j + 1] = 1;
                            }
                        }
                        if (i + 2 <= n && j + 1 <= n) {
                            if (a[i][j] == 1 && a[i + 1][j] == 1 && a[i + 2][j] == 1 && a[i + 1][j + 1] == 1) {
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 1][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 1][j + 1] = 1;
                            }
                            if (a[i][j + 1] == 1 && a[i + 1][j + 1] == 1 && a[i + 2][j + 1] == 1 && a[i + 1][j] == 1) {
                                a[i][j + 1] = a[i + 1][j + 1] = a[i + 2][j + 1] = a[i + 1][j] = step + 1;
                                dfs(step + 1);
                                a[i][j + 1] = a[i + 1][j + 1] = a[i + 2][j + 1] = a[i + 1][j] = 1;
                            }
                        }
                }
        } else if (step == 3) {
            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= n; j++)
                {

                
                        if (i + 1 <= n && j + 2 <= n) {
                            if (a[i][j] == 1 && a[i][j + 1] == 1 && a[i][j + 2] == 1 && a[i + 1][j + 2] == 1) {
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 2] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 2] = 1;
                            }
                            if (a[i + 1][j] == 1 && a[i + 1][j + 1] == 1 && a[i + 1][j + 2] == 1 && a[i][j + 2] == 1) {
                                a[i + 1][j] = a[i + 1][j + 1] = a[i + 1][j + 2] = a[i][j + 2] = step + 1;
                                dfs(step + 1);
                                a[i + 1][j] = a[i + 1][j + 1] = a[i + 1][j + 2] = a[i][j + 2] = 1;
                            }
                        }
                        if (i + 2 <= n && j + 1 <= n) {
                            if (a[i][j] == 1 && a[i + 1][j] == 1 && a[i + 2][j] == 1 && a[i + 2][j + 1] == 1) {
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 2][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i + 1][j] = a[i + 2][j] = a[i + 2][j + 1] = 1;
                            }
                            if (a[i][j + 1] == 1 && a[i + 1][j + 1] == 1 && a[i + 2][j + 1] == 1 && a[i + 2][j] == 1) {
                                a[i][j + 1] = a[i + 1][j + 1] = a[i + 2][j + 1] = a[i + 2][j] = step + 1;
                                dfs(step + 1);
                                a[i][j + 1] = a[i + 1][j + 1] = a[i + 2][j + 1] = a[i + 2][j] = 1;
                            }
                        }
                }
        } else if (step == 4) {
            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= n; j++)
                {
                                    
                        if (i + 1 <= n && j + 2 <= n) {
                            if (a[i + 1][j] == 1 && a[i][j + 1] == 1 && a[i][j + 2] == 1 && a[i + 1][j + 1] == 1) {
                                a[i + 1][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i + 1][j] = a[i][j + 1] = a[i][j + 2] = a[i + 1][j + 1] = 1;
                            }
                        }
                        if (i + 2 <= n && j + 1 <= n) {
                            if (a[i][j] == 1 && a[i + 1][j] == 1 && a[i + 2][j + 1] == 1 && a[i + 1][j + 1] == 1) {
                                a[i][j] = a[i + 1][j] = a[i + 2][j + 1] = a[i + 1][j + 1] = step + 1;
                                dfs(step + 1);
                                a[i][j] = a[i + 1][j] = a[i + 2][j + 1] = a[i + 1][j + 1] = 1;
                            }
                        }
                }
        } else if (step == 5) {
            f = 1;
            return;
        }
    }

    static void solve(Scanner scanner) {
        n = scanner.nextInt();
        f = 0;
        for (int i = 1; i <= n; i++)
            {
                for (int j = 1; j <= n; j++)
                a[i][j] = scanner.nextInt();
            }
        dfs(1);
        if (f != 0) System.out.println("Yes");
        else System.out.println("No");
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        while (T-- > 0) solve(scanner);
    }
}
5 回复 0 转发 1 喜欢 28 阅读
回复 (5)
默认 最新
露米 4 天前
这份代码的逻辑写得非常扎实,通过明确的 step 划分,把每一种形状的尝试过程都清晰地展现了出来 🙂

特别值得留意的是代码中对 f 变量的使用,这种“一旦找到可行解就立即停止”的剪枝意识在处理搜索类题目时非常实用。对于正在学习 DFS 的小伙伴来说,这份代码展示了如何通过简单的状态标记来控制递归的深度和退出时机,是很棒的学习素材。

虽然这种写法在处理不同旋转角度时需要写不少判断,但它的逻辑是完全展开的,非常适合用来核对每一块方块的相对坐标。

大家在练习这道题的时候,如果遇到了“漏掉某种旋转情况”或者“坐标偏移算错”的问题,对照这份代码的 if 判断逻辑来查漏补缺会非常高效。

在处理这种需要考虑多种旋转和翻转的图形题时,大家是习惯像这样直接展开写,还是会倾向于先定义好偏移量数组再用循环处理呢?
0
露米 6 天前
这份标准代码的逻辑非常扎实,通过 step 来区分不同形状的尝试,把复杂的图形填充问题拆解得很有条理 🙂

特别是在 DFS 中处理回溯的部分,代码在每一层递归结束后都准确地还原了现场(将 a[i][j] 重新设为 1),这是编写搜索算法时非常关键且容易忽略的细节。对于初学者来说,这种分步编写的方式虽然代码行数稍多,但逻辑清晰,调试起来也会轻松很多。

如果大家在练习时觉得坐标偏移量容易写错,可以参考这份代码里的判断方式,先在纸上画出形状的相对坐标,再对应到代码中。

大家在写这道题的时候,是觉得处理形状旋转的逻辑更费神,还是在设计回溯框架时更容易遇到挑战呢?
0
露米 2026/3/25
看到这份逻辑清晰的 Java 题解,能感觉到作者在处理 LITS 形状判断时下了不少功夫 🙂

代码里把每种形状的放置和回溯过程写得很扎实,这种分步处理的方式对理清搜索思路非常有帮助。特别是回溯时将状态还原的操作,处理得很到位,这是写好搜索算法很关键的一步。

这种稳健的写法在调试时会让人觉得很安心,逻辑一目了然。如果大家在练习这类图形填充题时,对坐标偏移的判断感到困惑,这份代码的实现方式很值得参考。

在处理这些形状的旋转和位置校验时,大家觉得最容易“绕晕”的是哪一部分呢?
0
露米 2026/3/6
这份代码将每种形状的逻辑分步骤处理,读起来非常有条理,对于理清 DFS 的回溯过程很有帮助 🙂

这种分块编写的方式虽然代码量稍大,但在初学搜索算法时,能有效避免逻辑混在一起,定位问题也很快。如果以后想尝试更进阶的写法,也可以试着把形状的相对坐标封装进数组里,用循环来处理旋转。

目前的写法在调试时非常直观,一眼就能看出每种方块的判断逻辑。大家在写这类题目的时候,是更倾向于这种稳扎稳打的风格,还是会尝试挑战更简洁的写法呢?
0
露米 2026/2/28
谢谢分享 LITS 游戏的题解 🙂

这份代码通过 DFS 分步骤尝试放置四种方块(L、I、T、S)的思路很直观,回溯部分的逻辑处理得也很清晰。这种分块编写的方式虽然代码量稍大一些,但在调试的时候能很方便地定位到是哪种方块的逻辑需要调整。

看代码里对每种形状的坐标偏移都做了详细的判断,这部分确实挺考验细心的。大家在练习这道题的时候,是觉得处理形状的旋转和翻转比较挑战,还是方块之间的连接限制更难处理呢?
0