Question

这是针对我尝试的强力算法。尝试各种组合。

代码生成长度为10的每个移动组合，从4个移动（向上，向下，向左，向右）。这就是嵌套for循环深度为10的原因。但是如果需要更少或更多的移动如9或11或12怎么办？如何使嵌套for循环动态化。我在递归方面遇到了麻烦。

int available = new int[] {TILT_MOVE.UP, TILT_MOVE.DOWN, TILT_MOVE.LEFT, TILT_MOVE.RIGHT}.length;

    int n = 10;
    int total = 1;

    for (int i = 0; i < n; i++) {
        total *= available;
    }

    int combinations[][] = new int[total][n];
    int count = 0;

    //My head got burnt up with the implementation of maze tilting logic so this is the best I can do for now.
    for (int a = 0; a < available; a++) {
        for (int b = 0; b < available; b++) {
            for (int c = 0; c < available; c++) {
                for (int d = 0; d < available; d++) {
                    for (int e = 0; e < available; e++) {
                        for (int f = 0; f < available; f++) {
                            for (int g = 0; g < available; g++) {
                                for (int h = 0; h < available; h++) {
                                    for (int i = 0; i < available; i++) {
                                        for (int j = 0; j < available; j++) {   
                                            int[] moves = new int[n];
                                            moves[0] = a;
                                            moves[1] = b;
                                            moves[2] = c;
                                            moves[3] = d;
                                            moves[4] = e;
                                            moves[5] = f;
                                            moves[6] = g;
                                            moves[7] = h;
                                            moves[8] = i;
                                            moves[9] = j;

                                            combinations[count++] = moves;

                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

Answer 1

我相信这应该有效：

for (int i = 0; i < total; i++)
{
    int[] moves = new int[n];
    for (int move = 0; move < n; ++move)
    {
        moves[move] = (i / (int) Math.pow(available, move)) % available;
    }
    combinations[i] = moves;
}

Answer 2

您是否正试图通过迷宫寻找路径？

如果是这样，不要再将迷宫视为人类迷宫了。对于计算机而言，迷宫是一个图形，其中每个节点都是可能的位置。

迷宫的解决方案是一系列移动，将球引导到洞中。这可以被认为是一棵树，其中每个节点代表{tilt-direction，ballA-position，ballB-position}。

在这个更复杂的迷宫版本中，你需要考虑当一个球已经贴在障碍物上时倾斜的能力。只有当两个球的左边都有一面墙时，你才能再左移。

您还需要确保不要继续重复相同的动作。如果ballA和B在同一转弯中同时出现在同一个空间内，请不要继续尝试此移动。

如何在java中动态嵌套for循环？

2 个答案: