如何计算递归函数中的案例数？答案

【问题标题】：How can I count the number of cases in recursive functions?如何计算递归函数中的案例数？
【发布时间】：2021-02-24 10:57:52
【问题描述】：

def calcPath(trace_map, x, y):
    n = len(trace_map)
    count = 0
    if x > n - 1 or y > n - 1:
        pass
    elif x < n and y < n:
        if x + trace_map[x][y] == (n - 1) and y == (n - 1):
            count += 1
        elif x == (n - 1) and y + trace_map[x][y] == (n - 1):
            count += 1
        else:
            calcPath(trace_map, x + trace_map[x][y], y)
            calcPath(trace_map, x, y + trace_map[x][y])
    return count


if __name__ == "__main__":
    trace_map = [
        [1, 2, 9, 4, 9],
        [9, 9, 9, 9, 9],
        [9, 3, 9, 9, 2],
        [9, 9, 9, 9, 9],
        [9, 9, 9, 1, 0],
    ]
    print(calcPath(trace_map, 0, 0))

    trace_map = [[1, 1, 1], [1, 1, 2], [1, 2, 0]]
    print(calcPath(trace_map, 0, 0))

我想计算给定迷宫的现有路线。（反正问题本身没那么重要）问题是，我试图计算符合递归函数条件的案例数量。

这是必须计算的两个条件。

if x + trace_map[x][y] == (n - 1) and y == (n - 1):
if x == (n - 1) and y + trace_map[x][y] == (n - 1):

我试着像这样计算条件

count = 0 
if condition = True: 
count +=1

但由于我使用的是递归函数，如果我在函数中声明 count = 0，则计数值保持为 0。

简而言之，我只想保持计数器不受递归函数的影响。

【问题讨论】：

为什么不在函数外部声明为全局变量呢？您还可以创建一个变量calcPath.counter 并在函数外部对其进行初始化。
这能回答你的问题吗？ Debugging recursive function to se how many times it repeats a certain calculation
@mkrieger1 哎呀，对不起。这是我第一次使用堆栈？？？？必须改变它。
你可以写 count += calcPath(...) 这样的东西而不是丢弃返回的计数
@user14625681 我添加了一个更容易实现的答案

标签： python if-statement recursion counter counting

【解决方案1】：

解决此问题的方法之一是添加从每个递归函数的返回中获得的计数。当您调用递归函数时，获取返回的计数并将其添加到当前范围内的count 变量中。例如：

def calcPath(trace_map, x, y):
    n = len(trace_map)
    count = 0
    if x > n - 1 or y > n - 1:
        pass
    elif x < n and y < n:
        if x + trace_map[x][y] == (n - 1) and y == (n - 1):
            count += 1
        elif x == (n - 1) and y + trace_map[x][y] == (n - 1):
            count += 1
        else:
            count += calcPath(trace_map, x + trace_map[x][y], y)
            count += calcPath(trace_map, x, y + trace_map[x][y])
    return count

另一种解决方案是创建一个全局变量，并在每次调用函数时将其重置为 0（尽管我不建议这样做，因为每次调用函数时都需要仪式）。

可能看起来像这样：

count = 0 # Global variable

def calcPath(trace_map, x, y):
    global count
    n = len(trace_map)
    if x > n - 1 or y > n - 1:
        pass
    elif x < n and y < n:
        if x + trace_map[x][y] == (n - 1) and y == (n - 1):
            count += 1
        elif x == (n - 1) and y + trace_map[x][y] == (n - 1):
            count += 1
        else:
            calcPath(trace_map, x + trace_map[x][y], y)
            calcPath(trace_map, x, y + trace_map[x][y])


if __name__ == "__main__":
    trace_map = [
        [1, 2, 9, 4, 9],
        [9, 9, 9, 9, 9],
        [9, 3, 9, 9, 2],
        [9, 9, 9, 9, 9],
        [9, 9, 9, 1, 0],
    ]
    print(calcPath(trace_map, 0, 0))

    # Use count in some way

    count = 0 # Reset the count

    trace_map = [[1, 1, 1], [1, 1, 2], [1, 2, 0]]
    print(calcPath(trace_map, 0, 0))

【讨论】：

哇，我尝试使用全局变量，但为什么我没有重置计数？哈哈。 ? 我太傻了。感谢帮助！堆满了善意。印象深刻。?
@user14625681 请注意，count += calcPath 的第一种方法是最好的，并且在处理递归函数时适用于许多情况。至少它不需要你记住重置全局变量。

【解决方案2】：

我认为您可以使用nested scope 的概念，或者将其简单地放在另一个函数中。例如：

def fuc(args):
    if not args:
        return 0
    else:
        fuc.count += 1
        return args[0] + fuc(args[1:])

def fac(fuc, args):
    fuc.count = 0
    return fuc(args), fuc.count

print(fac(fuc, [1, 2, 3]))
print(fac(fuc, [4, 5, 6, 7]))

(6, 3)
(22, 4)
[Finished in 0.1s]

【讨论】：