背包||硬币||组队-python求解

1.寻找硬币（组合最小）：
硬币找零1和硬币找零2及硬币找零3

#动态规划描述就是：初始状态就是有d[i]=j表示i元至少需要j个硬币找零，
#d[0]=0,d[1]=d[1-1]+1=1,d[2]=min(d[2-1]+1,d[2-2]+1)=1;
#即硬币的组合为c[b,k,m,....,n],如果i>=c[nn],
#d[i]=min(d[i],d[i-b]+1,d[i-k]+1,...,d[i-nn]+1)
#即代转移状态方程为d[i]=min(d[i],d[i-c[kk]]),kk=0,1,...,nn,d[i]初始设置为inf
# import math
# def findCoins(money,coins):#自底向上寻找#递推
#     dp=[math.inf]*(money+1)
#     coins.sort()
#     dp[0]=0#
#     for i in range(money+1):
#         for j in coins:
#             if i>=j:
#                 dp[i]=min(dp[i],dp[i-j]+1)
#     return dp
# print(findCoins(27,[3,2,5]))

#暴力求解就是：
SS=[]
for i in range(27//2):
    for j in range(27//3):
        for k in range(27//5):
            if 2*k+3*j+5*k==27:
               SS.append(i+j+k)
print(min(SS))

2.背包问题：

#暴力求解#
import itertools
# weight=10
# W=[3,4,5]
# V=[4,5,6]
# AA=[]
# VAL=[]#价值和
# for i in range(len(W)+1):
#     for num in itertools.combinations(W,i):
#         if sum(num)<=10:
#             AA.append(num)
#             ss=0
#             for j in num:
#                 ss+=V[W.index(j)]
#             VAL.append(ss)
# print(AA)
# print(VAL)
# print(max(VAL))

#动态规划#背包问题
'''找状态：d[i,j]表示当前背包重量为j时是否选择第i个商品的最大价值。
和转移状态：1)d[i,j]=d[i-1,j]表示第j个商品不放入背包中
2）d[i,j]=d[i-1,j-w[i]]+v[i]表示第j个商品放入背包中
两者结合求最大，即d[i,j]=max(d[i-1,j],d[i-1,j-w[i]]+v[i])'''
# def bag(W,V,weight):
#     dp=[[0]*(weight+1) for i in range(len(V)+1)]
#     for i in range(len(V)+1):
#         for j in range(weight+1):
#             if i==0 or j==0:
#                 dp[i][j]=0
#             elif j>=W[i-1]:
#                 dp[i][j]=max(dp[i-1][j-W[i-1]]+V[i-1],dp[i-1][j])
#             else:
#                 dp[i][j]=dp[i-1][j]
#     return dp
# if __name__=='__main__':
#     weight=10
#     W=[3,4,5]
#     V=[4,5,6]
#     print(bag(W,V,weight))

#回溯法解背包问题
W=[10,8,5]#重量
V=[5,4,1]#价值
X=[0,0,0]#背包当前的价值
N=3#物品的数量
C=16#背包的容量
CurWeight=0#每个物品的重量
CurValue=0 #每个物品的价值
BestValue=0 #x[i]=1代表物品i放入背包，0代表不放入
BestX=[0]*N

def backtrack(t):
    global BestValue
    global CurValue
    global CurWeight
    if t>N-1:#叶子节点，输出结果#结束条件
        if CurValue>BestValue:#如果找到一个更优解
            BestValue=CurValue#保存更优解和值
            for i in range(N):
                BestX[i]=X[i]
    else:
        for j in range(2):#判断准则
            X[t]=j
            if j==0:#不放入背包
                backtrack(t+1)
            else:
                if CurValue+W[t]<=C:
                    CurValue+=W[t]
                    CurValue+=V[t]
                    backtrack(t+1)
                    CurWeight-=W[t]
                    CurValue-=V[t]

if __name__=='__main__':
    backtrack(0)
    print(CurValue)
    print(BestX)

3.组队：

#回溯算法#组队#一个岗位只需要一人，一人只能胜任一个岗位
data='''97 90 0 0 0
92 85 96 0 0
0 0 0 0 93
0 0 0 80 86
89 83 97 0 0
82 86 0 0 0
0 0 0 87 90
0 97 96 0 0
0 0 89 0 0
95 99 0 0 0
0 0 96 97 0
0 0 0 93 98
94 91 0 0 0
0 83 87 0 0
0 0 98 97 98
0 0 0 93 86
98 83 99 98 81
93 87 92 96 98
0 0 0 89 92
0 99 96 95 81
'''.split()
data=list(map(int,data))
dd=[]
for i in range(len(data)//5):
  dd.append(data[i*5:(i+1)*5])
def Com(X,Y,dui):
    if len(dui)==5:#结束条件
        res.append(sum(dui))#结果添加
        return
    for i in range(20):
        for j in range(5):#可选选择
            if (i not in X) and (j not in Y):
                X.append(i)
                Y.append(j)
                dui.append(dd[i][j])
                Com(X,Y,dui)
                X.pop()
                Y.pop()
                dui.pop()
if __name__=='__main__':
    res=[]
    import time
    ss=time.time()
    Com([],[],[])
    end=time.time()
    print(len(res))
    print(max(res))
    print('时间:%f' %(end-ss))

结果为：