java - 简单 DFS 遍历的停止条件

Question

我正在尝试解决此问题 problem on topcoder作为一种实践，我尝试为它实现 DFS 解决方案，它运行良好，除了一个错误:即使到达死胡同，它也会继续遍历每个未访问的单元格，初始代码是:

public void func(int[][] x, StringBuilder s, int i, int j, int n) {
    if (i < 0 || j < 0 || i > n || j > n || x[i][j] == 1) {
        return;
    }
    s.append((char) (97 + j));
    s.append(n - i + 1 + "-");
    x[i][j] = 1;
    func(x, s, i, j + 1, n);
    func(x, s, i - 1, j, n);
    func(x, s, i + 1, j, n);
    func(x, s, i, j - 1, n);
    return;
}

public String dukePath(int n, String initPosition) {
    String p = initPosition;
    int x[][] = new int[n][n];
    StringBuilder s = new StringBuilder("");
    func(x, s, n - Integer.parseInt(p.charAt(1) + ""), (int) p.charAt(0) - 97, n - 1);
    s.replace(s.length() - 1, s.length(), "");
    if (s.length() > 40) {
        s.replace(20, s.length() - 20, "...");
    }
    return s.toString();
}

所以我尝试通过添加 boolean 标志和初始位置 (z,y) 来修改函数“func()”的签名，以将当前单元格与 进行比较；如果代码试图重新访问初始位置，那么它应该返回，但它也没有工作..

如何在到达死胡同或再次到达初始位置时停止遍历？

Answer 1

您错误地解决了这个问题，您需要做的就是在每一步都移动到字典序上最大的邻居，直到您到达访问所有相邻单元格的点。这是简单的迭代，不需要 DFS:

public static String dukePath(int n, String initPosition) {
    int x = initPosition.charAt(0) - 'a';
    int y = n - (initPosition.charAt(1) - '0');
    boolean grid[][] = new boolean[n][n];
    StringBuilder s = new StringBuilder(initPosition);

    while (true) {
        grid[x][y] = true;

        if (x < (n - 1) && !grid[x + 1][y])
            x++; // Right
        else if (y > 0 && !grid[x][y - 1])
            y--; // Up
        else if (y < (n - 1) && !grid[x][y + 1])
            y++; // Down
        else if (x > 0 && !grid[x - 1][y])
            x--; // Left
        else
            break; // Nowhere left to go!

        s.append("-" + (char)('a' + x) + (char)('0' + n - y));
    }

    if (s.length() > 40) {
        s.replace(20, s.length() - 20, "...");
    }

    return s.toString();
}

public static void main(String args[])
{
    System.out.println(dukePath(3, "b2"));
    System.out.println(dukePath(4, "d4"));
    System.out.println(dukePath(3, "a2"));
    System.out.println(dukePath(4, "d3"));
    System.out.println(dukePath(8, "a8"));
}

给出预期的结果:

b2-c2-c3-b3-a3-a2-a1-b1-c1
d4-d3-d2-d1-c1-c2-c3...b3-b2-b1-a1-a2-a3-a4
a2-b2-c2-c3-b3-a3
d3-d4-c4-c3-c2-d2-d1...b2-b3-b4-a4-a3-a2-a1
a8-b8-c8-d8-e8-f8-g8...a1-a2-a3-a4-a5-a6-a7