我能'；我无法在java中修改我的静态变量

你给一个网格（这里是4x4）。您需要找出从（0,0）到（4,4）的唯一路径的总数。main（）为此调用函数pathify。它找到可能的“下一步”并再次调用。当达到（4,4）时，noOfPaths++；应该执行。这没有发生，我也找不到问题所在

import java.util.ArrayList;

    public class NoOfPaths {
        static int xRows = 4; 
        static int yColumns = 4;
        static int noOfPaths = 0;

        /*A robot is located in the upper-left corner of a 4×4 grid. 
         * The robot can move either up, down, left, or right, 
         * but cannot go to the same location twice. 
         * The robot is trying to reach the lower-right corner of the grid. 
         * Your task is to find out the number of unique ways to reach the destination.
         **/

        static ArrayList validNeighbours (int x,int y, ArrayList visited) {
            ArrayList valid = new ArrayList();

            if((x+1 <= xRows) && !visited.contains(((x+1)*10)+y) ) {
                valid.add(((x+1)*10)+y);
            }
            if((x-1 >= 0) && !visited.contains(((x-1)*10)+y) ) {
                valid.add(((x-1)*10)+y);
            }
            if((y+1 <= yColumns) && !visited.contains(x*10+y+1) ) {
                valid.add(x*10+y+1);
            }
            if((y-1 >= 0) && !visited.contains(x*10+y-1) ) {
                valid.add(x*10+y-1);
            }

            return valid;
        }

        static void pathify(int x,int y,  ArrayList alreadyVisited) {
            if(x == xRows && y == yColumns) {
                noOfPaths++;
            } else {
                alreadyVisited.add(x*10+y);
                ArrayList callAgain = new ArrayList();
                callAgain = validNeighbours(x,y,alreadyVisited);
                for (int t=0,temp; t<callAgain.size(); t++) {
                    temp=(int) callAgain.get(t);
                    pathify(temp/10, temp%10, alreadyVisited);
                }

            }
        }

        public static void main(String[] args) {


            ArrayList alreadyVisited = new ArrayList();

            pathify(0, 0, alreadyVisited);

            System.out.println(noOfPaths);
        }

    }

import java.util.ArrayList；
公共类无门小径{
静态int xRows=4；
静态int y列=4；
静态int noOfPaths=0；
/*机器人位于4×4网格的左上角。
*机器人可以上下左右移动，
*但不能两次前往同一位置。
*机器人正试图到达网格的右下角。
*你的任务是找出到达目的地的独特方式的数量。
**/
静态ArrayList validNeighbours（int x、int y、ArrayList已访问）{
ArrayList valid=新的ArrayList（）；
如果（（x+1=0）和（（x-1）*10）+y）包含{
有效。添加（（（x-1）*10）+y）；
}
如果（（y+1=0）和&！访问包含（x*10+y-1））{
有效。添加（x*10+y-1）；
}
返回有效；
}
静态无效路径化（int x、int y、ArrayList已显示）{
if（x==xRows&&y==yColumns）{
noOfPaths++；
}否则{
添加（x*10+y）；
ArrayList callreach=新的ArrayList（）；
CallReach=validNeighbours（x，y，已访问）；
对于（int t=0，temp；t而言，错误在于如何处理
alreadyVisited
。第一次调用
pathify
时，此列表将仅包含初始平方（0,0），这很好。下面是代码的重要部分：

            for (int t=0,temp; t<callAgain.size(); t++) {
                temp=(int) callAgain.get(t);
                pathify(temp/10, temp%10, alreadyVisited);
            }

写

add
将修改一个新列表，而不是其他调用正在使用的列表。（就我个人而言，我会声明一个新变量，例如
newAlreadyVisited
，因为出于可读性原因，我不太喜欢修改参数。）

这可能看起来效率很低。它肯定会占用更多内存（尽管内存应该可以很快被垃圾回收）。但是尝试在递归调用之间共享数据结构是非常非常困难的。如果您非常小心地清理更改并将结构恢复到方法开始时的状态，则可以做到这一点。如果结构类似于一棵大树，因此无法复制，则可能需要这样做每一次调用都是如此，但要让事情顺利进行需要很多技巧

编辑：我对它进行了测试，它似乎可以工作：12如果
xRows
=
yColumns
=28512如果两者都是4（正确吗？）。另一种方法：我尝试了复制列表，而不是复制列表

alreadyVisited.remove((Object)(x*10+y));

在方法的末尾（
（Object）
，这样Java就不会认为您正在删除索引），这给了我相同的结果。如果您这样做，您将确保
alreadyVisited
在
pathify
返回时与启动时相同。但我想强调的是，我不建议这样做“清理"除非你真的知道你在做什么，否则你就要去做。
一个小插曲，如果你把泛型用作
List
你就不需要整天把它输入到
int
了，你的代码越来越安全了。你只需要修改数组列表的一个副本，而不是实际的数组列表。我得到
3
作为输出，代码是eems对我来说工作正常…假设这是您期望的结果…1x1网格的答案是2。2x2网格的答案是12。所以有一个错误。我调试了它，发现“noOfPaths”静态变量没有修改hanks。我将坚持使用内存密集型变量，并尝试解决它，感谢您，您的知识
alreadyVisited = [make a copy of alreadyVisited];
alreadyVisited.add(x*10+y);

alreadyVisited.remove((Object)(x*10+y));