在每个24个阶段中，至少有240种可能性（通常多达480种）。因此，至少有
24**240种可能的路径。这比
10**57条路径还要多。你无法通过蛮力解决这个问题。但是，可以使用
线性规划方法来解决这个问题。
正如BJ Myers建议的那样，您可以使用递归来生成所有可能的路径。
假设您有一个生成器函数，它生成长度为1的所有可能路径。那很容易：
def generate_paths1():
for i in range(600):
yield [i]
你可以使用
generate_paths1生成长度为2的所有可能路径：
def generate_paths2():
for path in generate_paths1():
current = path[-1]
low = max(current-240, 0)
high = min(current+240, 600)
for i in range(low, high):
yield path+[i]
你可以使用generate_paths2生成所有长度为3的路径：
def generate_paths3():
for path in generate_paths2():
current = path[-1]
low = max(current-240, 0)
high = min(current+240, 600)
for i in range(low, high):
yield path+[i]
但是等等！generate_paths3 函数实际上与 generate_paths2 函数几乎相同。肯定有更好的方法。我们可以编写一个递归函数，可以执行 generate_paths1、generate_paths2 和 generate_paths3 能够做到的一切 - 甚至更多：
def generate_paths(N):
moves = range(601)
if N == 1:
for i in moves:
yield [i]
else:
for path in generate_paths(N-1):
current = path[-1]
low = max(current-240, 0)
high = min(current+240, 600)
for i in [i for i in moves if low <= i <= high]:
yield path+[i]
N = 3
for path in generate_paths(N):
...
虽然能够生成所有路径很棒，但是路径太多了。
如果我们将问题识别为线性规划(LP)问题，我们可以做得更好。
你的问题可以像这样表示为LP问题：
Maximize price = sum([a*b for a, b in zip(S, path)])
Subject to:
x[1] - x[0] <= 240
x[0] - x[1] <= 240
x[2] - x[1] <= 240
x[1] - x[2] <= 240
...
线性规划问题的解之一的特性是:
如果存在可行解并且（线性）目标函数有界，则最优值总是在最优水平集的边界上达到。（我强调）
因此，您可以将 moves = range(601) 替换为
moves = range(0, 601, 120)
因为当S为正时，最优解倾向于使用600来最大化价格，并且在S为负时使用0来最小化损失。介于两者之间的其他值是最优解从0到600或从600到0移动所需的最大跳数。
这将减少路径数量至6**24，远远小于240**24，但仍然太大以致于无法进行暴力求解。
使用scipy.optimimize.linprog，您可以像这样解决最优路径问题，即使是完整的24阶段问题:
import numpy as np
import scipy.optimize as optimize
"""
Minimize: np.dot(S, x)
Subject to: np.dot(A, x) <= b
"""
N = 24
K = 10
S = np.random.randint(-K//2, +K//2, size=N)
A = np.zeros((2*(N-1), N), dtype=int)
for i in range(N-1):
A[2*i, i:i+2] = (1, -1)
A[2*i+1, i:i+2] = (-1, 1)
b = np.array([240]*A.shape[0])
bounds = [(0, 600)]*N
result = optimize.linprog(c=-S, A_ub=A, b_ub=b, bounds=bounds)
optimal_path = result.x
max_price = np.dot(S, optimal_path)
print('''S: {}
optimal_path: {}
price: {}'''.format(S, optimal_path, max_price))
产生类似以下结果：
S: [ 0 1 3 4 -5 -1 0 -3 -4 0 3 2 -5 1 -4 -1 -3 2 0 -2 0 4 -2 2]
optimal_path: [ 360. 600. 600. 360. 120. 0. 0. 0. 0. 240. 480. 240.
0. 240. 0. 0. 0. 240. 0. 120. 360. 600. 360. 600.]
price: 8520.0
