Python 如何停止递归函数？

我正在研究一个递归函数，这是我第一次不知道如何停止计算

val = [[12, 11, 3, 38], [13, 18, 49, 41], [12, 17, 33, 45], [45, 36, 32, 33]]

def rec(n, o1, o2, o3, o4):
    if n==1: # BECAUSE IN CASE THAT N==1, THERE IS JUST ONE ARGUMENT WITH VALUE 1, OTHER ARGUMENTS SHOULD HAVE VALUE 0
        if o1==1: 
            return val[0][0]
        elif o2==1: 
            return val[0][1]
        elif o3==1:
            return val[0][2]
        else: 
            return val[0][3]

    return max(rec(n - 1, o1 - 1, o2, o3, o4) + val[n][0],
               rec(n - 1, o1, o2 - 1, o3, o4) + val[n][1],
               rec(n - 1, o1, o2, o3 - 1, o4) + val[n][2],
               rec(n - 1, o1, o2, o3, o4 - 1) + val[n][3])

应计算4个孔的最佳分布。因此，每个孔中都有最大值之和。

val

列表告诉我们：对于

val

[0]孔，我可以将价格

val[0][0]

等放在第一项

问题是，

o

值经过几次迭代后具有负数，这是禁止的

例如，

rec（1,0,0,50,0）

应该是50，因为除此之外没有其他选项

编辑：

事实上，我想告诉函数它不应该处理值为0的参数

---

因此

rec（2,0,1,0,1）

应该返回

max（rec（1,0,0,1）+val[2][1]，rec（1,0,1,0,0）+val[2][3]）

您必须确保它在n==1时到达一个点。。。在这里的例子中，如果n是一个浮点数，这可能永远不会发生，您需要测试abs（n-1） 或者，在这种情况下，这可能是最好的解决方案，您可以将

n==1

测试更改为

n<1

；像这样：

val = [[12, 11, 3, 38], [13, 18, 49, 41], [12, 17, 33, 45], [45, 36, 32, 33]]

def rec(n, o1, o2, o3, o4):
    if n < 1:
        if o1 == 1:
            return val[0][0]
        elif o2 == 1:
            return val[0][1]
        elif o3 == 1:
            return val[0][2]
        else:
            return val[0][3]

    return max(rec(n - 1, o1 - 1, o2, o3, o4) + val[n][0],
               rec(n - 1, o1, o2 - 1, o3, o4) + val[n][1],
               rec(n - 1, o1, o2, o3 - 1, o4) + val[n][2],
               rec(n - 1, o1, o2, o3, o4 - 1) + val[n][3])

rec(3, 2, 2, 2, 2)

>>> 164

val=[[12,11,3,38]、[13,18,49,41]、[12,17,33,45]、[45,36,32,33]]
def记录（n、o1、o2、o3、o4）：
如果n<1：
如果o1==1：
返回值[0][0]
elif o2==1：
返回值[0][1]
elif o3==1：
返回值[0][2]
其他：
返回值[0][3]
返回最大值（rec（n-1，o1-1，o2，o3，o4）+val[n][0]，
rec（n-1，o1，o2-1，o3，o4）+val[n][1]，
rec（n-1，o1，o2，o3-1，o4）+val[n][2]，
rec（n-1，o1，o2，o3，o4-1）+val[n][3]）
记录（3,2,2,2,2）
>>> 164

您必须确保它在n==1时到达某个点。。。在这里的例子中，如果n是一个浮点数，这可能永远不会发生，您需要测试abs（n-1） 或者，在这种情况下，这可能是最好的解决方案，您可以将

n==1

测试更改为

n<1

；像这样：

val = [[12, 11, 3, 38], [13, 18, 49, 41], [12, 17, 33, 45], [45, 36, 32, 33]]

def rec(n, o1, o2, o3, o4):
    if n < 1:
        if o1 == 1:
            return val[0][0]
        elif o2 == 1:
            return val[0][1]
        elif o3 == 1:
            return val[0][2]
        else:
            return val[0][3]

    return max(rec(n - 1, o1 - 1, o2, o3, o4) + val[n][0],
               rec(n - 1, o1, o2 - 1, o3, o4) + val[n][1],
               rec(n - 1, o1, o2, o3 - 1, o4) + val[n][2],
               rec(n - 1, o1, o2, o3, o4 - 1) + val[n][3])

rec(3, 2, 2, 2, 2)

>>> 164

val=[[12,11,3,38]、[13,18,49,41]、[12,17,33,45]、[45,36,32,33]]
def记录（n、o1、o2、o3、o4）：
如果n<1：
如果o1==1：
返回值[0][0]
elif o2==1：
返回值[0][1]
elif o3==1：
返回值[0][2]
其他：
返回值[0][3]
返回最大值（rec（n-1，o1-1，o2，o3，o4）+val[n][0]，
rec（n-1，o1，o2-1，o3，o4）+val[n][1]，
rec（n-1，o1，o2，o3-1，o4）+val[n][2]，
rec（n-1，o1，o2，o3，o4-1）+val[n][3]）
记录（3,2,2,2,2）
>>> 164

如果希望它不处理带有参数0的递归，只需为其添加一个基本情况即可。我所做的是确保返回的值将在上面的修订级别中取消为0

def rec(n, o1, o2, o3, o4):
    if o1 <= 0:
        return -val[n+1 if n<len(val)-1 else n][0] 
        # checks for out of bounds with inline if,
        # return negative value so compared value in upper level will be 0, 
        # and it will never be chosen
    if o2 <= 0:
        return -val[n+1 if n<len(val)-1 else n][1]
    if o3 <= 0:
        return -val[n+1 if n<len(val)-1 else n][2] 
    if o4 <= 0:
        return -val[n+1 if n<len(val)-1 else n][3] 
    if n<=1: # like Reblochon said, n might be float if you are unlucky
        if o1==1: 
            return val[0][0]
        elif o2==1: 
            return val[0][1]
        elif o3==1:
            return val[0][2]
        else: 
            return val[0][3]

    return max(rec(n - 1, o1 - 1, o2, o3, o4) + val[n][0], \ # you will need these for line continuations
           rec(n - 1, o1, o2 - 1, o3, o4) + val[n][1], \
           rec(n - 1, o1, o2, o3 - 1, o4) + val[n][2], \
           rec(n - 1, o1, o2, o3, o4 - 1) + val[n][3])

def rec（n，o1，o2，o3，o4）：
如果o1如果希望它不处理参数为0的递归，只需添加一个基本情况即可。我所做的是确保返回的值将在上面的修订级别中取消为0

def rec(n, o1, o2, o3, o4):
    if o1 <= 0:
        return -val[n+1 if n<len(val)-1 else n][0] 
        # checks for out of bounds with inline if,
        # return negative value so compared value in upper level will be 0, 
        # and it will never be chosen
    if o2 <= 0:
        return -val[n+1 if n<len(val)-1 else n][1]
    if o3 <= 0:
        return -val[n+1 if n<len(val)-1 else n][2] 
    if o4 <= 0:
        return -val[n+1 if n<len(val)-1 else n][3] 
    if n<=1: # like Reblochon said, n might be float if you are unlucky
        if o1==1: 
            return val[0][0]
        elif o2==1: 
            return val[0][1]
        elif o3==1:
            return val[0][2]
        else: 
            return val[0][3]

    return max(rec(n - 1, o1 - 1, o2, o3, o4) + val[n][0], \ # you will need these for line continuations
           rec(n - 1, o1, o2 - 1, o3, o4) + val[n][1], \
           rec(n - 1, o1, o2, o3 - 1, o4) + val[n][2], \
           rec(n - 1, o1, o2, o3, o4 - 1) + val[n][3])

def rec（n，o1，o2，o3，o4）：
如果o1，那就是我不明白的。如果n不是1，我调用rec（n-1…），因此它应该在每次迭代中减小。是的，但这并不意味着它将永远等于1--->将该测试更改为
n<1
，以查看问题在于它在我的测试中是整数。请参见下面的我的答案，它在编辑后会执行您想要的操作。当n小于1时，它退出。（它永远不会达到0）让我们，这就是我不明白的。如果n不是1，我调用rec（n-1…），因此它应该在每次迭代中减小。是的，但这并不意味着它将永远等于1--->将该测试更改为
n<1
，以查看问题在于它在我的测试中是整数。请参见下面的我的答案，它在编辑后会执行您想要的操作。当n小于1时，它退出。（它永远不会达到0）让我们来看看。o1-o4参数在开始时是相等的。不变量是n=sum（o1，o2，o3，o4）。是的，它仍然适用于不断增加的条件。。。你想让你的递归停止。。。现在有了！o1-o4参数在开始时相等。不变量是n=sum（o1，o2，o3，o4）。是的，它仍然适用于不断增加的条件。。。你想让你的递归停止。。。现在有了！