python关于箱子容积的解决办法

峟网友问：

每条线长1500，按着线条分割，
1327+892+471+442+426+352+415+443+438+467+373+441
需要分割成以上段数，每段长不会超过1500
算出一共需要几条线，并且每条线的剩余量最小，

按着要求，则想到了箱子容积的算法问题，

看到网上有的算法是这样：

def get_min_boxes(things,box_weight):
    things=sorted(things,reverse=True)#将数据由大到小排序
    print(things)
    m=len(things)-1;count=0
    for i in range(len(things)):
        sum=0
        print('{',end='')
        sum=things[i]
        print(things[i],' ',end='')
        while m>=0:
            j=m
            sum+=things[j]
            if sum>box_weight:
                count+=1
                break
            print(things[j],'',end='')
            m-=1
        if j==i:
            # count+=1
            print('}')
            break
        print('}')
 
    print('最少需要使用',count,'个容积为',box_weight,'的箱子')
if __name__=='__main__':
    things=[1327,892,434,471,442,426,352,415,443,438,467,373,441]
    box_weight=1500
    # things=[3,15,14,19,13,4,10,4,20,3,1,7,13,8,18,18,20,5,9,8]
    # box_weight=20
    get_min_boxes(things,box_weight)

也能解出一种算法，但在中间增加数值时，出现了一些错误，于是修改了一下，如下：

def list_add(data_a):
     data_a_sum = 0
     for i in range(len(data_a)):
         data_a_sum +=data_a[i]
     return data_a_sum 


def get_min_boxes(things,box_weight):
    
    things=sorted(things,reverse=True)#将数据由大到小排序
    print('物件排序:',things)
    if things[0]>box_weight:
        print ('最大超限，无法容纳')
    else:
        m=len(things)-1;count=0
        all=[]
        surplus=0
        print('m=',m)
        for i in range(len(things)):
            sum=0
            print('第',count+1,'个 {',end='')
            all.append([])
            sum=things[i]
            print(things[i],' ',end='')
            all[count].append(things[i])
            while m>=0:
                
                j=m
                sum+=things[j]
                if sum>box_weight:
                    count+=1
                    sum=0
                    break
                if j<=i:
                    count+=1
                    sum=0
                    break                   
                print(things[j],' ',end='')
                all[count].append(things[j])
                m-=1
                # print('ijm',i,j,m)

            if j==i:
                # count+=1
                print('}')
                print('小计剩余',box_weight-list_add(all[count-1]))
                surplus+=box_weight-list_add(all[count-1])
                # all=all[:-1]
                break
            print('}')
            print('小计剩余',box_weight-list_add(all[count-1]))
            surplus+=box_weight-list_add(all[count-1])
 
        print('最少需要使用',count,'个长度为',box_weight,'的线条')
        print('总剩余量为',surplus)
        # print(all)
if __name__=='__main__':
    things=[1327, 892, 471, 442, 426, 352, 415, 443, 438, 467, 373, 441,112]
    box_weight=1500
    # things=[3,15,14,19,13,4,10,4,20,3,1,7,13,8,18,18,20,5,9,8]
    # box_weight=20
    get_min_boxes(things,box_weight)

解出答案是：

 5 根长 1500 线条
最终剩余量 901

物件排序: [1327, 892, 471, 467, 443, 442, 441, 438, 426, 415, 373, 352, 112]
m= 12
第 1 个 {1327  112  }
小计剩余 61
第 2 个 {892  352  }
小计剩余 256
第 3 个 {471  373  415  }
小计剩余 241
第 4 个 {467  426  438  }
小计剩余 169
第 5 个 {443  441  442  }
小计剩余 174
最少需要使用 5 个长度为 1500 的线条
总剩余量为 901
 

这个算法的理解是这样，先从大到小排列，从最大的线条开始，列第一组，如果有剩余，则从最小的一个开始装载，一直装载到当前最大的线条为止；
不知道这种算法对不对，但我感觉应该是从最大的开始装载，然后依次从次最大的开始，一直到最小的，只要合适，就尽量装大的，但这种有可能到凑到正好是1500的给剔除掉了，所以不一定是最优解，那么什么是最优解，即剩余最小呢，请各位指教。