无聊的逗 蓝桥杯 python

 我首先想到的是，先从小到大排序一遍。

给定2个栈盒子：

开始先给2个盒子分别放入最后2个最大值，同时从数据中取出这2个值，

如果哪个盒子小，就从数据中取出最大值加上去，直到数据为空。

如果盒子最后大小不相等的话：

就从最大的盒子取出值，直到相等。

很显然有情况是2个盒子取完都不能相等

40分

n = int(input())
d = input()
data = list(map(int,d.split()))
data.sort()
L1 = 0
L2 = 0
print(data)
for i in range(n):
    if L1>=L2:
        L2 += data.pop(-1)
    else:
        L1 += data.pop(-1)
    print(L1,L2)
if L1 == L2:
    pass
    print("第一次确认", L1)
else:
    print("第一次失败", L1,L2)
    data = list(map(int, d.split()))
    data.sort()
    for i in range(n):
        if L1 == L2:
            print("第二次确认",L1)
            break
        elif L1 > L2:
            L1 -= data.pop(0)
        else:
            L2 -= data.pop(0)
        print(L1, L2)

print(L1)

---

后面我百度，发现可以把取了和没取设为0，1，枚举全部可能性

再把这些数据一一比对

枚举：我是用递归把所有可能性列完，当然如果不减枝的话，后面对比的数据量很大

于是我把大于全部和的一半剪掉，来进行优化

global allcount
global posSum
global maxposSum
allcount = 0
posSum = 0
maxposSum = sum(data)/2
# print(maxposSum)
out = [0]*n
alldata = list()
def sdf(t=0):
    global posSum
    global allcount
    global maxposSum
    if maxposSum < posSum:
        pass
        return
    if t==n:
        #print(out)
        alldata.append((posSum,out.copy()))
        allcount += 1
        # print((posSum,out))
        pass
        return
    for i in (0,1):
        posSum += i*data[t]
        out[t] = i
        sdf(t+1)
        posSum -= i*data[t]
sdf()

对比：

检查是否用了同一个树枝的函数

def eh(l1,l2,n):
    for i in range(n):
        if l1[i] == 1 and l2[i] == 1:
            return False
    return True

 从大到小，遍历所以枚举出来的可能性，

while：如果在不越界的情况下，对比i与i+t的大小是否相同，

如果相同就进入eh函数对比是否符合条件，符合就退出，输出答案

newAllData = sorted(alldata,reverse=True)
# print(newAllData)
lenall = len(newAllData)
isfind = False
for i in range(lenall):
    t = 1
    while i+t<lenall and newAllData[i][0]==newAllData[i+t][0]:
        # print(newAllData[-i][1],newAllData[-i-t][1],newAllData[i][0])
        if eh(newAllData[i][1],newAllData[i+t][1],n):
            # print(newAllData[i][1],newAllData[i+t][1],newAllData[i+t][0])
            print(newAllData[i+t][0])
            isfind = True
            break
        t+=1
    if isfind:
        break

---

完整代码 

n = int(input())
d = input()
# d = "1 4 7 9 3 4 7 9 2 4 6 7 28 34 29"

import time
staTime = time.perf_counter()
data = list(map(int,d.split()))
n = len(data)
data.sort()
# print(data)


global allcount
global posSum
global maxposSum
allcount = 0
posSum = 0
maxposSum = sum(data)/2
# print(maxposSum)
out = [0]*n
alldata = list()
def sdf(t=0):
    global posSum
    global allcount
    global maxposSum
    if maxposSum < posSum:
        pass
        return
    if t==n:
        #print(out)
        alldata.append((posSum,out.copy()))
        allcount += 1
        # print((posSum,out))
        pass
        return
    for i in (0,1):
        posSum += i*data[t]
        out[t] = i
        sdf(t+1)
        posSum -= i*data[t]
sdf()
# print(allcount)


def eh(l1,l2,n):
    for i in range(n):
        if l1[i] == 1 and l2[i] == 1:
            return False
    return True

newAllData = sorted(alldata,reverse=True)
# print(newAllData)
lenall = len(newAllData)
isfind = False
for i in range(lenall):
    t = 1
    while i+t<lenall and newAllData[i][0]==newAllData[i+t][0]:
        # print(newAllData[-i][1],newAllData[-i-t][1],newAllData[i][0])
        if eh(newAllData[i][1],newAllData[i+t][1],n):
            # print(newAllData[i][1],newAllData[i+t][1],newAllData[i+t][0])
            print(newAllData[i+t][0])
            isfind = True
            break
        t+=1
    if isfind:
        break