Java 从原点到点的路径数

我需要计算从原点到一个点（n，0）的路径数，其中n>0，移动次数必须正好是2*n。 我只能移动

（x+1，y）[→], （x，y+1）[↑],（x-1，y+1）[-]，（x+1，y-1）[&]，或（x+1，y+1）[%]

限制包括:

[-]和[&]从未以任何顺序直接相邻

[↑] 及[→] 不以任何顺序直接相邻

[↑] 和[%]从未以任何顺序直接相邻

程序需要显示所有移动（x>0&y>0）。 示例：对于n=7，（7）=416449 我无法让它显示正确的答案

    package algo;

public class Test {
static int k = 0;

public static int calcul(int x, int y, int n, int pasi, int p, int[] num) {
    if (x ==n && y == 0 && pasi == 2 * n ) {
        {
            for(int i=1;i<=2*n;i++)
                System.out.print(num[i]);
            System.out.println(" ");
            k = k + 1;

        }
    } else if (pasi < 2 * n && x >= 0 && y >= 0) {

        if (num[pasi] != 2) {
            num[pasi + 1] = 1;

            calcul(x + 1, y, n, pasi + 1, 1, num);

        }
        if (num[pasi] != 1 && num[pasi] != 6) {
            num[pasi + 1] = 2;
            calcul(x, y + 1, n, pasi + 1, 2, num);

        }

        if (num[pasi] != 5) {
            num[pasi + 1] = 4;

            calcul(x - 1, y + 1, n, pasi + 1, 4, num);

        }
        if (num[pasi] != 4) {
            num[pasi + 1] = 5;

            calcul(x + 1, y - 1, n, pasi + 1, 5, num);

        }
        if (num[pasi] != 2) {
            num[pasi + 1] = 6;

            calcul(x + 1, y + 1, n, pasi + 1, 6, num);

        }

    }
    return k;
}

public static void main(String[] args) {
    int n = 3;
    int[] num = new int[n * 2 + 1];
    int q = calcul(0, 0, 2, 0, 0, num);
    System.out.println("paths:" + q);

}

package算法；
公开课考试{
静态int k=0；
公共静态整数计算（整数x，整数y，整数n，整数pasi，整数p，整数[]num）{
如果（x==n&&y==0&&pasi==2*n）{
{
对于（int i=1；i=0&&y>=0）{
如果（num[pasi]！=2）{
num[pasi+1]=1；
计算（x+1，y，n，pasi+1，1，num）；
}
如果（num[pasi]！=1&&num[pasi]！=6）{
num[pasi+1]=2；
计算（x，y+1，n，pasi+1，2，num）；
}
如果（num[pasi]！=5）{
num[pasi+1]=4；
计算（x-1，y+1，n，pasi+1，4，num）；
}
如果（num[pasi]！=4）{
num[pasi+1]=5；
计算（x+1，y-1，n，pasi+1，5，num）；
}
如果（num[pasi]！=2）{
num[pasi+1]=6；
计算（x+1，y+1，n，pasi+1，6，num）；
}
}
返回k；
}
公共静态void main（字符串[]args）{
int n=3；
int[]num=新的int[n*2+1]；
int q=计算（0,0,2,0,0,num）；
System.out.println（“路径：+q”）；
}

---

}

一般来说，这些问题可以通过纯递归解决，而不需要

静态变量。只需计算每个可能的延续的路径数。一旦在给定约束下到达所需的目标，将完整路径数增加1（
返回1；
），否则通过返回0来中断递归

private static boolean isPossibleOrigin(int x, int y, int n, int pasi) {
    return x >= 0 && y >= 0 && pasi < 2 * n && ?;
}

public static int calcul(int x, int y, int n) {
    if (x == n && y == 0 && n == 0) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, 0)) {
        return
              right(x, y, n, 1)
            + up(x, y, n, 1)
            + leftup(x, y, n, 1)
            + rightdown(x, y, n, 1)
            + rightup(x, y, n, 1);
    }
    return 0;
}

最后，考虑到访问一个节点到目的地的距离大于剩余移动次数时，不会产生完整的路径，您可以显著提高性能。我在该点留下了一个问号，您可以在此处添加适当的条件来检查此问题。
private静态布尔值isPossibleOrigin（int x，int y，int n，int pasi）{
private static boolean isPossibleOrigin(int x, int y, int n, int pasi) {
    return x >= 0 && y >= 0 && pasi < 2 * n && (x+y)/2<2*n-pasi;
}

public static int calcul(int x, int y, int n) {
    if (x == n && y == 0 ) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, 0)) {
        return
              right(x+1, y, n,1)
            + up(x, y+1, n, 1)
            + leftup(x-1, y+1, n, 1)
            + rightdown(x+1, y-1, n, 1)
            + rightup(x+1, y+1, n, 1);
    }
    return 0;
}
public static int right(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
                + leftup(x-1, y+1, n, pasi+1)
                + rightdown(x+1, y-1, n, pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int leftup(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
                + leftup(x-1, y+1, n, pasi + 1)
                + up(x,y+1,n,pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int rightup(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
            + leftup(x-1, y+1, n, pasi + 1)
                +rightdown(x+1, y-1, n, pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int up(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            +up(x, y+1, n, pasi+1)
                + leftup(x-1, y+1, n, pasi + 1)
               +rightdown(x+1, y-1, n, pasi+1)
                ;
    }
    return 0;
}
public static int rightdown(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
           +rightdown(x+1, y-1, n, pasi+1)
                + up(x,y+1,n,pasi+1)
                + rightup(x+1, y+1, n, pasi + 1);
    }
    return 0;
}
public static void main(String[] args) {
System.out.println("Paths:"+calcul(0, 0, 1));
}

返回x>=0&&y>=0&&pasi<2*n&&（x+y）/2你是在要求这里的人做你的工作吗？在提问之前，你应该尝试一些方法来实现这一点。请务必阅读我如何提出一个好的问题？编写代码，我们将帮助你！我忘记输入我的代码，我的错。我确实尝试过这样做，但我找不到在适当的时间（1-10秒）内完成它的方法另外，你确定n＝7存在416449条路径吗？我快速计算了它，我认为有超过1.5米（我不告诉你确切的数字，因为我认为这是某种作业：-）：提示：你的公式没有考虑到点的距离（n，0）。但同时它也取决于剩余的移动次数。那么你想在这里检查什么呢？
private static boolean isPossibleOrigin(int x, int y, int n, int pasi) {
    return x >= 0 && y >= 0 && pasi < 2 * n && (x+y)/2<2*n-pasi;
}

public static int calcul(int x, int y, int n) {
    if (x == n && y == 0 ) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, 0)) {
        return
              right(x+1, y, n,1)
            + up(x, y+1, n, 1)
            + leftup(x-1, y+1, n, 1)
            + rightdown(x+1, y-1, n, 1)
            + rightup(x+1, y+1, n, 1);
    }
    return 0;
}
public static int right(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
                + leftup(x-1, y+1, n, pasi+1)
                + rightdown(x+1, y-1, n, pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int leftup(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
                + leftup(x-1, y+1, n, pasi + 1)
                + up(x,y+1,n,pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int rightup(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
            + leftup(x-1, y+1, n, pasi + 1)
                +rightdown(x+1, y-1, n, pasi+1)
                + rightup(x+1, y+1, n,pasi+ 1);
    }
    return 0;
}
public static int up(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            +up(x, y+1, n, pasi+1)
                + leftup(x-1, y+1, n, pasi + 1)
               +rightdown(x+1, y-1, n, pasi+1)
                ;
    }
    return 0;
}
public static int rightdown(int x, int y, int n, int pasi) {


    if (x == n && y == 0 && pasi == 2 * n) {
        return 1;
    } else if (isPossibleOrigin(x, y, n, pasi)) {
        return
            right(x+1, y, n, pasi + 1)
           +rightdown(x+1, y-1, n, pasi+1)
                + up(x,y+1,n,pasi+1)
                + rightup(x+1, y+1, n, pasi + 1);
    }
    return 0;
}
public static void main(String[] args) {
System.out.println("Paths:"+calcul(0, 0, 1));
}