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

这是我正在尝试的暴力算法。尝试各种组合

该代码从4个移动（上、下、左、右）生成长度为10的每个移动组合。这就是为什么嵌套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;

                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

int available=newint[]{TILT_MOVE.UP，TILT_MOVE.DOWN，TILT_MOVE.LEFT，TILT_MOVE.RIGHT}.length；
int n=10；
整数合计=1；
对于（int i=0；i

我认为这应该有效：

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

for（int i=0；i

我认为这应该有效：

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

for（int i=0；i

你想在迷宫中找到一条路

如果是这样的话，就不要把迷宫想象成人类的迷宫。对于计算机来说，迷宫是一个图形，其中每个节点都是可能的位置

迷宫的解决方案是一系列移动，将球引到洞中。这可以看作是一棵树，其中每个节点表示{倾斜方向、巴拉位置、鲍尔位置}

在这个更复杂的迷宫中，你需要考虑到当一个球已经碰到障碍物时的倾斜能力。只有当两个球的左边都有一堵墙时，你才不再有可能向左移动

---

你还需要确保你不会在相同的动作中反复出现。如果巴拉和B在同一个回合中都在同一个位置，不要继续尝试这个动作。

你想在迷宫中找到一条路吗

如果是这样的话，就不要把迷宫想象成人类的迷宫。对于计算机来说，迷宫是一个图形，其中每个节点都是可能的位置

迷宫的解决方案是一系列移动，将球引到洞中。这可以看作是一棵树，其中每个节点表示{倾斜方向、巴拉位置、鲍尔位置}

在这个更复杂的迷宫中，你需要考虑到当一个球已经碰到障碍物时的倾斜能力。只有当两个球的左边都有一堵墙时，你才不再有可能向左移动

---

你还需要确保你不会在相同的动作中反复出现。如果巴拉和B在同一个回合中都在同一个空格上，不要继续尝试这个动作。

“但是如果需要更少或更多的动作，如9、11或12，该怎么办？”-然后使用递归。--“我在递归方面遇到了麻烦。”-一开始，每个人都有。回避它不会让事情变得更好。练习一下！你很可能最终会明白的？这将需要超过12个级别…@ShmoselYa，我不知道为什么我写得很有可能。如果您可以保证最多12个级别，那就不太可能了。

TILT\u MOVE.UP、TILT\u MOVE.DOWN、TILT\u MOVE.LEFT、TILT\u MOVE.RIGHT的值是多少？

一般来说，如果您有4个或更多嵌套循环，您可能需要重新考虑您的逻辑，“但是如果需要的移动更少或更多，例如9、11或12，该怎么办？”-然后使用递归。--“我在递归方面遇到了麻烦。”-一开始，每个人都有。回避它不会让事情变得更好。练习一下！你很可能最终会明白的？这将需要超过12个级别…@ShmoselYa，我不知道为什么我写得很有可能。如果你能保证最多12个级别，那就不太可能了。

TILT\u MOVE.UP、TILT\u MOVE.DOWN、TILT\u MOVE.LEFT、TILT\u MOVE.RIGHT的值是多少？

通常，如果你有4个或更多的嵌套循环，你可能需要重新考虑你的逻辑。相反，迷宫是一个图形。特别是，您必须记住已经访问了哪些节点（以避免无限递归），这比简单的tre更复杂