Python 找到8个元素的最佳组合，8个列表中各一个

我的问题是我有8个大小的列表（分别是10、10、10、10、50、50、50）。每个列表中的每个元素都有一个必需的成本和一个值。我想做的是找到8个元素的组合（每个列表中1个元素），它们的组合值最高，但不会超过成本上限。我想到的是尽可能的暴力，我估计在它结束前1小时内存就用完了。是否值得尝试实现类似apriori算法的东西，或者是否有更好的方法。到目前为止，我所拥有的：

import itertools

foo = open("test.txt", "r")

L1 = []
L2 = []
L3 = []
L4 = []
L5 = []
L6 = []
L7 = []
L8 = []

costCap = 10000 #max cost allowed
perfValue = 0 #
final = []

for line in foo:
    line = ','.join(line.split())
    line2 = line.split(",")[1] #values

    if(line2 == "A1"):
        L3.append(line)
    elif(line2 == "A2"):
        L2.append(line)
    elif(line2 == "A3"):
        L5.append(line)
    elif(line2 == "A4"):
        L1.append(line)
    elif(line2 == "A5"):
        L4.append(line)

    L6.append(line)
    L7.append(line)
    L8.append(line)


l1 = list(itertools.product(L1, L2, L5, L4, L3, L6, L7, L8))
for k in range(len(l1)):
    s1 = l1[k][0].split(",")[5]
    s2 = l1[k][1].split(",")[5]
    s3 = l1[k][2].split(",")[5]
    s4 = l1[k][3].split(",")[5]
    s5 = l1[k][4].split(",")[5]
    s6 = l1[k][5].split(",")[5]
    s7 = l1[k][6].split(",")[5]
    s8 = l1[k][7].split(",")[5]
    temp = int(s1[1:]) + int(s2[1:]) + int(s3[1:]) + int(s4[1:]) + int(s5[1:]) + int(s6[1:]) + int(s7[1:]) + int(s8[1:])
    if ((temp > perfValue) and (temp < costCap)):
        perfRating = temp
        final = l1[k]

print(final)

导入itertools
foo=open（“test.txt”、“r”）
L1=[]
L2=[]
L3=[]
L4=[]
L5=[]
L6=[]
L7=[]
L8=[]
成本上限=10000#允许的最大成本
perfValue=0#
最终=[]
对于foo中的行：
line='，'.join（line.split（））
line2=line.split（“，”[1]#值
如果（第2行=“A1”）：
L3.追加（行）
elif（第2行==“A2”）：
L2.追加（行）
elif（第2行==“A3”）：
L5.追加（行）
elif（第2行==“A4”）：
L1.追加（行）
elif（第2行==“A5”）：
L4.追加（行）
L6.追加（行）
L7.追加（行）
L8.追加（行）
l1=列表（itertools.product（l1、L2、L5、L4、L3、L6、L7、L8））
对于范围内的k（len（l1））：
s1=l1[k][0]。拆分（“，”[5]
s2=l1[k][1]。拆分（“，”[5]
s3=l1[k][2]。拆分（“，”[5]
s4=l1[k][3]。拆分（“，”[5]
s5=l1[k][4]。拆分（“，”[5]
s6=l1[k][5]。拆分（“，”[5]
s7=l1[k][6]。拆分（“，”[5]
s8=l1[k][7]。拆分（“，”[5]
temp=int（s1[1:]）+int（s2[1:]）+int（s3[1:]）+int（s4[1:]）+int（s5[1:]）+int（s6[1:]）+int（s7[1:]）+int（s8[1:]）
如果（（温度>性能值）和（温度<成本上限））：
性能=温度
最终=l1[k]
打印（最终版）

---

Edit1：很抱歉，很多都是文本文件解析。真正发生的事情是

l1=list（itertools.product（l1、L2、L5、L4、L3、L6、L7、L8））

找到所有可能的组合，然后for循环只检查哪些组合在处于上限下时具有最高值。

您正在尝试解决这个问题，例如，看看可能的方法（动态规划算法）

您正在尝试解决问题，例如，查看可能的方法（动态规划算法）

您遇到的内存限制取决于循环的编写方式。它应该在产品生成器上迭代，而不是从该生成器创建列表：

for k in itertools.product(L1, L2, L5, L4, L3, L6, L7, L8):
    s1 = k[0].split(",")[5]
    s2 = k[1].split(",")[5]
    s3 = k[2].split(",")[5]
    s4 = k[3].split(",")[5]
    s5 = k[4].split(",")[5]
    s6 = k[5].split(",")[5]
    s7 = k[6].split(",")[5]
    s8 = k[7].split(",")[5]
    temp = int(s1[1:]) + int(s2[1:]) + int(s3[1:]) + int(s4[1:]) + int(s5[1:]) + int(s6[1:]) + int(s7[1:]) + int(s8[1:])
    if ((temp > perfValue) and (temp < costCap)):
        perfRating = temp
        final = k

itertools.product（L1、L2、L5、L4、L3、L6、L7、L8）中的k的

：
s1=k[0]。拆分（“，”[5]
s2=k[1]。拆分（“，”[5]
s3=k[2]。拆分（“，”[5]
s4=k[3]。拆分（“，”[5]
s5=k[4]。拆分（“，”[5]
s6=k[5]。拆分（“，”[5]
s7=k[6]。拆分（“，”[5]
s8=k[7]。拆分（“，”[5]
temp=int（s1[1:]）+int（s2[1:]）+int（s3[1:]）+int（s4[1:]）+int（s5[1:]）+int（s6[1:]）+int（s7[1:]）+int（s8[1:]）
如果（（温度>性能值）和（温度<成本上限））：
性能=温度
最终=k

您遇到的内存限制取决于循环的编写方式。它应该在产品生成器上迭代，而不是从该生成器创建列表：

for k in itertools.product(L1, L2, L5, L4, L3, L6, L7, L8):
    s1 = k[0].split(",")[5]
    s2 = k[1].split(",")[5]
    s3 = k[2].split(",")[5]
    s4 = k[3].split(",")[5]
    s5 = k[4].split(",")[5]
    s6 = k[5].split(",")[5]
    s7 = k[6].split(",")[5]
    s8 = k[7].split(",")[5]
    temp = int(s1[1:]) + int(s2[1:]) + int(s3[1:]) + int(s4[1:]) + int(s5[1:]) + int(s6[1:]) + int(s7[1:]) + int(s8[1:])
    if ((temp > perfValue) and (temp < costCap)):
        perfRating = temp
        final = k

itertools.product（L1、L2、L5、L4、L3、L6、L7、L8）中的k的

：
s1=k[0]。拆分（“，”[5]
s2=k[1]。拆分（“，”[5]
s3=k[2]。拆分（“，”[5]
s4=k[3]。拆分（“，”[5]
s5=k[4]。拆分（“，”[5]
s6=k[5]。拆分（“，”[5]
s7=k[6]。拆分（“，”[5]
s8=k[7]。拆分（“，”[5]
temp=int（s1[1:]）+int（s2[1:]）+int（s3[1:]）+int（s4[1:]）+int（s5[1:]）+int（s6[1:]）+int（s7[1:]）+int（s8[1:]）
如果（（温度>性能值）和（温度<成本上限））：
性能=温度
最终=k

kk我来看看。kk我来看看。你知道运行时是什么样子吗？时间至少是列表长度的乘积。乘积生成器可以在常量空间中运行。因此此代码也使用常量空间。你知道运行时是什么样子吗？时间至少是相同的列表长度的乘积。乘积生成器可以在常量空间中运行。因此此代码也使用常量空间。当然，您的内存不足，因为您首先创建了一个包含1250000000个元素的列表，在这种情况下，您不需要创建如此庞大的列表，而是直接在该乘积上进行迭代（和内存）你失去了制作列表用于计算的功能。当然，你的内存不足，因为你首先制作了一个包含1250000000个元素的列表，在这种情况下，你不需要制作如此庞大的列表，直接在产品上迭代，你失去制作列表的所有时间（和内存）都用于计算。