Question

我正在处理一些Project Euler问题，并希望测试我的解决方案。即使有可达的基本情况，我的递归函数也永远不会结束。

在20x20网格中我使用x和y坐标向上和向左导航以找到从（19,19）到（0,0）的路径数。我的基本情况是当我们达到（0,0）时返回1。否则，我将当前计数添加到递归调用。

功能：

private static int numPaths(int x, int y, int pathsFound)
{
    if(x == 0 && y == 0)
        return 1;
    else
    {
        if(x > 0)
        {
            pathsFound += numPaths(x - 1, y, pathsFound);
        }
        if(y > 0)
        {
            pathsFound += numPaths(x, y - 1, pathsFound);
        }
    }
    return pathsFound;
}

主：

int x = 19;
int y = 19;
System.out.println("Answer: " + numPaths(x, y, 0));

我的递归逻辑中存在缺陷，还是只需要很长时间才能计算出来？如果你知道这个欧拉问题的解决方案，请不要发布它。

https://projecteuler.net/problem=15

Answer 1

所以，如果有人感兴趣的话，我会查看memoization并提出一个没有递归的优雅解决方案。

功能：

private static BigInteger numberPaths(ArrayList<ArrayList<BigInteger>> grid)
{
    for(int i = 0; i <= 20; ++i)
    {
        for(int j = 0; j <= 20; ++j)
        {
            int x = j;
            int y = i;
            if(x - 1 < 0 || y - 1 < 0)
            {
                grid.get(x).set(y, BigInteger.ONE);
            }
            else
            {
                BigInteger topVal = grid.get(x - 1).get(y);
                BigInteger leftVal = grid.get(x).get(y - 1);
                grid.get(x).set(y, topVal.add(leftVal));
            }

        }
    }
    return grid.get(20).get(20); //the solution
}

主：

ArrayList<ArrayList<BigInteger>> grid = new ArrayList<>();
for(int i = 0; i <= 20; ++i)
{
    ArrayList<BigInteger> column = new ArrayList<>();
    for(int j = 0; j <= 20; ++j)
    {
        column.add(BigInteger.valueOf(0));
    }
    grid.add(column);
 }
System.out.println("Answer: " + numberPaths(grid));

用于查找网格中路径数量的递归函数无限运行

1 个答案: