<p>很快,这里有一个实施方案</p>
<pre><code>class Node(object):
def __init__(self, children={}, integer=0):
self.dictionary = children
self.integer = integer
@property
def children(self):
return self.dictionary
class Tree(object):
def __init__(self):
self.root = Node()
def compute_your_thing(self, FF, indeces):
"""
Assuming FF is a list of lists such that
FF[0] = [f_00, f_01, f_02, ...]
FF[1] = [f_10, f_11, f_12, ...]
FF[2] = [f_20, f_21, f_22, ...]
...
FF[len(indeces)]
"""
# Generalize for any indeces length
indeces_level = len(indeces)
level = 0
fac = []
sol = 0
def lookup(node, F):
for f in F:
if f in node.children:
new_node = node.children[f]
level += 1
if level == indeces_level:
# We have reached the depth defined by the length of indeces
sol += float(new_node.integer/node.integer) * times(fac) * foo(indeces[-1], f)
else :
fac.append(foo(f, indeces[level]))
return lookup(new_node, FF[indeces_level - level])
# Use the nested loop to compute your thing recursively
lookup(root, FF[indeces_level])
return sol
# Utilities
def times(fac):
result = 1
for f in fac:
result *= fac
return result
def foo(ind, f):
# I don't know what you do with this function
pass
</code></pre>
<p>希望这有帮助。你知道吗</p>