递归函数一直在无限旋转

Question

我正试图写一些代码来解决这个数学问题：有8支球队，他们都会互相踢足球（所以总共7+6+…+1=28场比赛），他们只有两个结果的机会：赢或输。每支球队至少有1胜1负的比赛。如果你不明白这个问题，请说，让我再解释一遍。问题是我的代码打印无限递增的数字（这是一个无限循环，我在函数中写了print语句来理解问题是什么）这里是我的代码，你认为问题是什么？非常感谢。你知道吗

num = 8
team = [0,0,0,0,0,0,0,0]
order = []
how_many_stats = 0
temp = 0

for i in range(num):
    for t in range(i+1 , num):
        order.append([i,t])
total_matches = len(order) - 1
curr_matches = - 1

def do_match():
    global num
    global team
    global order
    global how_many_stats
    global temp
    global total_matches
    global curr_matches
    print(how_many_stats)
    curr_matches += 1
    team[order[curr_matches][0]] += 1                               # first wins

    if not curr_matches == total_matches:
        do_match()
    else:
        for i in range(num):
            if team[i] > 0 and team[i] < 7:                                            #7/8?
                temp += 1

        if temp == num:
            how_many_stats += 1
        temp = 0


    team[order[curr_matches][0]] -= 1                              # take back the action

    team[order[curr_matches][1]] += 1                              # second wins

    if not curr_matches == total_matches:
        do_match()
    else:
        for i in range(num):
            if team[i] > 0 and team[i] < 7:                                         #7/8?
                temp += 1

        if temp == num:
            how_many_stats += 1
        temp = 0


    team[order[curr_matches][1]] -= 1

    curr_matches -= 1
    return

do_match()
print(how_many_stats)

说明：我为比赛宣布了一条道路，并把他们带进一个阵型（第一队对第二队，第一队对第三队等），然后我把他们按这个阵型的顺序带进行动。如果这条路符合或不符合我们的条件，可能会建立一个关于每一场比赛的胜负的树，并在每个分支的末端建立一个控制结构。如果相遇，则增加1的多少个属性值，然后后退一步尝试另一条路，依此类推；如果不相遇，则后退一步再次查找其他路。如果已经查看了下面的两个节点，请再次后退，依此类推。你知道吗

Answer 1

在第21行添加一些调试逻辑之后：

print("called do_match with num: %d, team: %s, order: %s, how_many_stats: %d, temp: %d, total_matchs: %d, curr_matches: %d" % (
    num, str(team), str(order), how_many_stats, temp, total_matches, curr_matches
))

让它运行一段时间：

called do_match with num: 8, team: [7, 4, 4, 1, 4, 1, 2, 4], order: [[0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7], [4, 5], [4, 6], [4, 7], [5, 6], [5, 7], [6, 7]], how_many_stats: 0, temp: 0, total_matchs: 27, curr_matches: 26
called do_match with num: 8, team: [7, 4, 4, 1, 4, 0, 3, 3], order: [[0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7], [4, 5], [4, 6], [4, 7], [5, 6], [5, 7], [6, 7]], how_many_stats: 0, temp: 0, total_matchs: 27, curr_matches: 25
...
called do_match with num: 8, team: [7, 4, 4, 1, 3, 1, 3, 4], order: [[0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7], [4, 5], [4, 6], [4, 7], [5, 6], [5, 7], [6, 7]], how_many_stats: 0, temp: 0, total_matchs: 27, curr_matches: 26
called do_match with num: 8, team: [7, 4, 4, 1, 3, 0, 4, 3], order: [[0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7], [4, 5], [4, 6], [4, 7], [5, 6], [5, 7], [6, 7]], how_many_stats: 0, temp: 0, total_matchs: 27, curr_matches: 25

我得出的结论是，你的代码确实终止了，你的问题是匹配树中有太多的可能性。你知道吗

例如，通过将团队数量减少到4个并再次运行，它确实终止了：

called do_match with num: 4, team: [0, 0, 0, 0], order: [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]], how_many_stats: 0, temp: 0, total_matchs: 5, curr_matches: -1
....
called do_match with num: 4, team: [0, 1, 2, 2], order: [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]], how_many_stats: 32, temp: 0, total_matchs: 5, curr_matches: 4
32

因此，您需要找出一个更好的算法，它能够计算匹配的数量，而不必强制执行匹配树并计算符合您的需求的结果

at least 1 win and 1 lose

例如，你可以计算出每一个团队只有一次胜利或一次失败的可能性，然后从可能结果的总数中减去这些可能性（只需确保不要将它们计算为这两个部分的两倍，或者可以独立发生）

target=total_number-exactly_one_win-exactly_one_loss+exactly_one_win_and_one_loss