Question

我正在研究骰子概率程序，并且当数字变大时，在置换部分遇到了一些效率问题。例如，我需要运行的周长是10个骰子，带有10个边，结果为50。

在给定骰子数量和边数的情况下，我需要排列的总数来计算指定结果的概率。通过final_count(total, dice, faces)函数，可以在进入perms(x)函数之前从生成器传递最少数量的组合。

以下代码可以工作，但是对于前面提到的边界，它需要花费很长时间。

perms(x)是@Ashish Datta在此主题中发布的： permutations with unique values 我认为这是我需要帮助的地方。

import itertools as it

total = 50
dice = 10
faces = 10

#-------------functions---------------------

# Checks for lists of ALL the same items
def same(lst):
   return lst[1:] == lst[:-1]

# Generates the number of original permutations (10 digits takes 1.65s)
def perms(x):
    uniq_set = set()
    for out in it.permutations(x, len(x)):
        if out not in uniq_set:
            uniq_set.update([out])
    return len(uniq_set)


# Finds total original dice rolls.  "combinations" = (10d, 10f, 50t, takes 0.42s)
def final_count(total, dice, faces):
    combinations = (it.combinations_with_replacement(range(1, faces+1), dice))
    count = 0
    for i in combinations:
        if sum(i) == total and same(i) == True:
            count += 1
        elif sum(i) == total and same(i) != True:
            count += perms(i)
        else:
            pass
    return count

# --------------functions-------------------

answer = final_count(total, dice, faces) / float(faces**dice)

print(round(answer,4))

我已阅读线程How to improve permutation algorithm efficiency with python。我相信我的问题有所不同，尽管更智能的算法是我的最终目标。

我最初在CodeReview中发布了该程序的初稿。 https://codereview.stackexchange.com/questions/212930/calculate-probability-of-dice-total。我意识到我在问题和代码审查之间走了一条很好的路线，但是我认为在这种情况下，我更多地是在问题方面：）

Answer 1

您可以使用一个从递归调用总数中扣除当前骰子掷骰的函数，如果总数小于1或大于骰子数乘以面孔数，则可以缩短搜索范围。使用缓存来避免重复计算相同的参数：

from functools import lru_cache
@lru_cache(maxsize=None)
def final_count(total, dice, faces):
    if total < 1 or total > dice * faces:
        return 0
    if dice == 1:
        return 1
    return sum(final_count(total - n, dice - 1, faces) for n in range(1, faces + 1))

这样：

final_count(50, 10, 10)

在一秒钟内返回：374894389

Answer 2

我有类似的blhsing解决方案，但是他击败了我，说实话，我没想到要使用lru_cache（不错！+1）。无论如何，我都将其发布，只是为了说明如何存储先前计算的计数如何减少递归。

def permutationsTo(target, dices, faces, computed=dict()):
    if target > dices*faces or target < 1: return 0 
    if dices == 1 :                        return 1
    if (target,dices) in computed: return computed[(target,dices)]
    result = 0 
    for face in range(1,min(target,faces+1)):
         result += permutationsTo(target-face,dices-1,faces,computed)
    computed[(target,dices)] = result
    return result

Answer 3

一种大大减少时间的方法是用数学方法计算combinations中每个唯一数字组的组合数量，并将count增加该数量。如果您有n个对象的列表，其中x1都相似，x2都相似，依此类推，那么布置它们的方式总数为n！/（x1！x2！x3！...）。例如，排列“田纳西”字母的不同方式的数目是9！/（1！4！2！2！）。因此，您可以为此设置一个单独的功能：

import math
import itertools as it
import time

# Count the number of ways to arrange a list of items where
# some of the items may be identical.
def indiv_combos(thelist):
    prod = math.factorial(len(thelist))
    for i in set(thelist):
        icount = thelist.count(i)
        prod /= math.factorial(icount)
    return prod

def final_count2(total, dice, faces):
    combinations = it.combinations_with_replacement(range(1, faces + 1), dice)
    count = 0
    for i in combinations:
        if sum(i) == total:
            count += indiv_combos(i)
    return count

我不知道是否已经有一些内置函数可以完成我写为indiv_combos2的工作，但是您也可以使用Counter进行计数和{ {1}}获取列表的结果：

mul

在尝试使用两种方法from operator import mul from collections import Counter def indiv_combos(thelist): return math.factorial(len(thelist)) / reduce(mul, [math.factorial(i) for i in Counter(thelist).values()],1)作为输入时，我得到的结果参差不齐，但是每次都在不到0.038秒的时间内给了我答案。

如何优化数字排列以提高效率

3 个答案: