贪心算法（Greedy Algorithm）：最优装载问题（python）

　**利用贪心算法求解的问题具有两个特性：

　　　　1.贪心选择策略：指原问题的最优解可以通过一系列局部最优得到

　　　　2.最优子结构性质：一个问题的最优解是否包含其子问题的最优解。　

问题：选择装载最多的物品

　　容器体积为：20

　　物品体积【L[i]】：4,1,3,2,7,12，11，7　　

 

　　1.算法设计：

　　　　（1），当容器体积为定值C时，L[i]越小，可能装载的物品数量 n 就越大，只要依次选择最小的物品，直到不能装为止。

　　　　（2）, 把 n 个物品的重量从小到大（非递减）排序，然后根据贪心选择策略尽可能多的选出前 i 个物品，直到不能继续装为止，此时达到最优。

　　python代码展示：(欢迎大佬指点)

　　

 1 class greedy:
 2     l1=[]
 3     ans=0   #代表已经装载物品的个数
 4     tmp=0   #代表物品的体积
 5     c=0    #载重量
 6     def __init__(self,lists,c):
 7         self.c=c
 8         self.l1=lists
 9 
10 
11     def load(self):
12         self.l1.sort()
13         #按照贪心策略寻找最优解
14         for i in self.l1:
15             self.tmp += i
16             if(self.tmp<=self.c):
17                 self.ans+=1
18             else:
19                 break
20 
21         return self.ans
22 
23 #Test：
24 g1=greedy([4,1,3,2,7,12,11,7],20)
25 print(g1.load())

 

　　算法复杂度分析：

　　1.时间复杂度： 首先按照物品体积进行排序，调用sort() 函数，其最优时间复杂度为O(n),最差时间复杂度为 O(n logn),平均时间复杂度为O(n logn), 其中按照 贪心策略寻找最优解的 for 语句的时间复杂度为均为 O(n),因此时间复杂度为 O(n+nlogn)。

　　2.空间复杂度： 程序中变量tmp，ans等占用了一些辅助空间，这些辅助空间都是常数阶的，因此空间复杂度为 O(1)。

 

*也可以把按照代码中“贪心策略找最优解”替换成 load1():如下：

　　　　

 1 class greedy:
 2     l1=[]
 3     ans=0   #代表已经装载物品的个数
 4     tmp=0   #代表物品的体积
 5     c=0    #容器体积
 6     def __init__(self,lists,c):
 7         self.c=c
 8         self.l1=lists
 9 
10    def load1(self):
11         self.l1.sort()
12         #按照贪心策略寻找最优解
13         for i in self.l1:
14             print(i)
15             self.tmp+=i
16             if(self.tmp>=self.c):
17                 if self.tmp==self.c:
18                     self.ans=self.l1.index(i)+1
19                 else:
20                     self.ans=self.l1.index(i)
21 
22                 return self.ans
23                 break
24 
25 
26 g1=greedy([4,1,3,2,7,12,11,7],20)
27 print(g1.load1())