在 n x n 网格中获取所有可能的下边缘和右边缘路径

Question

问题 15：
从 2×2 网格的左上角开始，有 6 条路线（没有回溯）到右下角。
通过 20×20 的网格有多少条路线？

所以我在Problem 15 的尝试有点暴力，因为我尝试通过从右到左并更改第一次方向改变的前身来获得所有可能有效路径的排列。例如，当我有一个 2x2 网格时（查看问题 15 链接图形），我将采用的第一条路径是右 - 右 - 下 - 下，我将采用的最后一条路径是 down - down - right - right，这也是我的终止条件。我将可能的有效路径添加到一个列表中，并使用该列表来确定是否已经添加了有效路径。为了置换路径，我将执行前面提到的操作：我在数组中从右到左（图中箭头指向的右下角）并更改第一个元素下一个元素与自身不同。所以right - right - down - down会变成right - right - right - down，这显然是无效的，因为你必须拥有相同数量的rights和downs能够到达终点角。所以我的想法是制作另一个从左到右的循环，并根据需要更改尽可能多的元素以获得有效路径。所以在这个例子中 right - right - right - down 变成 down - right - right - down。

另外，我忘了我不是在计算点数，我是在计算从左上角到右下角的边缘。

所以我已经写了一些代码，但它根本不起作用。

package projecteuler;

import java.util.ArrayList;

public class Projecteuler {
    public static final int GRIDSIZE = 2;

    public static void main(String[] args) {
        ArrayList<boolean[]> paths = new ArrayList<>();

        paths.add(new boolean[GRIDSIZE * 2]);
        for(int i = 0; i < GRIDSIZE; i++) {
            paths.get(0)[i] = true;
            paths.get(0)[GRIDSIZE * 2 - 1 - i] = false;
        }

        boolean[] buf = paths.get(0).clone();
        printArr(buf);
        boolean tmp;
        while(!checkTerminate(paths)) {
            while(paths.contains(buf)) {
                tmp = buf[buf.length - 1];
                for(int i = buf.length - 1; buf[i - 1] != tmp && 0 < i; i--) {
                    buf[i] = !buf[i];
                    for(int j = 0; checkValid(buf) && j < i; j++)
                        buf[j] = !buf[j];
                }
            }
            paths.add(buf.clone());
            printArr(buf);
        }
        System.out.println(paths.size());
    }

    public static boolean checkTerminate(ArrayList<boolean[]> paths) {
        boolean[] endPath = new boolean[GRIDSIZE * 2];
        for(int i = 0; i < GRIDSIZE; i++) {
            endPath[i] = false;
            endPath[GRIDSIZE * 2 - 1 - i] = true;
        }
        return paths.contains(endPath);
    }

    public static boolean checkValid(boolean[] arr) {
        int countR = 0,
            countL = 0;
        for(int i = 0; i < arr.length; i++) 
            if(arr[i])
                countR++;
            else
                countL++;

        return countR == countL;
    }

    public static void printArr(boolean[] arr) {
        for(int i = 0; i < arr.length; i++)
            System.out.print(arr[i] ? "right " : "down ");
        System.out.println();
    }
}

不知何故，它不会改变任何地方。

right right down down 
right right down down 
right right down down 
right right down down ...

等等就是它的全部输出。似乎代码根本不会改变我的路径，但也不会卡在任何 for 循环中。我最好的猜测是我的函数标准放置在错误的顺序中

我也想过一个回溯的解决方案，就像我们两年前在学校为迷宫做的那样，但我想在重做所有事情之前看看这种方法是否可行。

编辑：
我会尽快实现 2 x 2 网格示例的图像，但 ProjectEuler 网站目前正在维护中。

Answer 1

解决方案由我们可以拥有的“向下”和“向右”运动组合的数量给出。由于没有回溯，总共有N 向下和N 向右移动（在任何路线中，对于NxN 网格）。总共有2N个动作。

我们可以使用二项式系数得到这个，ⁿC_r（读作“n choose r”），即从n 对象中选择r 对象的方法（每个对象可以是两件事）。在我们的例子中，“对象”是向下或向右运动。这是由

给出的

因此我们想要的数字是：

对于N = 2，这给出了6。对于N = 20，这给出了137846528820。

Answer 2

设向右的一步称为R，向下的一步称为D。

为了在 n 行 m 列的网格上从左上角到达右下角，您必须向右走 m 次并向下走 n 次。

基本上，你必须得到 m R 和 n D 的所有可能排列。

---

示例：对于 2 x 2 网格，单词 RRDD 的唯一排列数将是您可以走的路数，即。

• RRDD
• RDRD
• DRDR
• DDRR

---

谷歌计算字母重复排列的公式，公式如下：

n！ / ( r₁! * r₂! ... )，其中所有 r 的总和为 n。

Math SE 上的This question 在查找重复字母排列计数时首先弹出，我认为second answer 解释得更好。

---

因此，要返回计数甚至返回路径，您根本不需要遍历迷宫。只需对第一个问题进行公式计算，然后打印第二个问题的排列即可。

当某些步骤偏离网格时给出路径将是唯一需要您实际穿越迷宫的情况。

---

更新：

它有助于可视化重复字母排列的公式。

这是演示该案例的幻灯片。看看 2 E 在生成排列时如何最终复制排列。一般来说，任何重复r次的字母都会导致r！重复，因为无论该字母放在何处，都可以替换为另一个相同的字母，而无需给出新的排列。

这样，如果我们除以总n！ r! 的排列，我们得到实际的唯一排列。

_{Image Source}