Question

我正在尝试解决这个problem on topcoder作为一种做法，我尝试为它实现DFS解决方案，除了一个bug之外它运行良好：即使它到达死胡同，它仍然遍历每个未访问的单元格，初始代码是：

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();
}

所以我尝试通过添加布尔标志和初始位置（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

Answer 2

我认为最简单的解决方案是创建一组包含i和j的对象。在func的每次调用中，如果此set包含具有i和j的目标对象，则不应调用func函数。这种方法都包括后退和循环。

停止简单DFS遍历的条件

2 个答案: