[Python3]BFS优先队列分枝限界法求解0/1背包问题

感觉网络上关于优先队列分枝限界法求解0/1背包问题的python代码很少，下面给出一些自己学习过程中的心得体会，(以下代码是从各路大神那里学来的)以及详细代码解释，如有错误请务必留言指正！先给出代码:

import queue
class Node:
    def __init__(self,level,weight,value,bound):
        self.level = level
        self.value = value
        self.weight = weight
        self.bound = bound
    def __lt__(self,other):
        return self.bound < other.bound
    
class Solution:   
    def BFS(self,weights,values,W,n):
        max_value = 0
        priority_queue = queue.PriorityQueue()
        root = Node(-1,0,0,0)
        priority_queue.put(root)

        while not priority_queue.empty():
            node = priority_queue.get()

            if node.level < n-1:
                level = node.level + 1
                
                next_weights = node.weight + weights[level]
                next_values = node.value + values[level]
                
                if next_weights <= W and next_values > max_value:
                    max_value = next_values
                
                bound_value = node.value + (W - node.weight) * (values[level]/weights[level])
                
                if bound_value > max_value:
                    lnode = Node(level,next_weights,next_values,bound_value)
                    priority_queue.put(lnode)
                
                rnode = Node(level,node.weight,node.value,node.bound)
                priority_queue.put(rnode)
        return max_value

weights = [4, 7, 5, 3]
values = [40, 42, 25, 12]
W = 10
n = 4
b = Solution()
a = b.BFS(weights,values,W,n)
print(a)

前情提要:import了queue这个包，主要是为了调用优先队列这个库函数，这个库函数写开就是一个大顶堆，如果有能力希望能够自己写这个函数，而不是直接调用库函数。

一、结构定义:

        定义了Node类，并且初始化了level,value,weight,bound，分别对应层数(头结点为-1层)，价        值，重量，以及上界。

        __lt__是python中的magic函数，当self.bound < other.bound的时候返回True，否则返回False，用来维持queue.PriorityQueue这个优先队列中结点的值的优先级，bound值越大的排在前面，优先级越高。

class Node:
    def __init__(self,level,weight,value,bound):
        self.level = level
        self.value = value
        self.weight = weight
        self.bound = bound
    def __lt__(self,other):
        return self.bound < other.bound

二、函数解释:

1)我们采用二叉树的BFS来搜索最合适的结点，我们定义了BFS函数，将最大价值(max_value)设置为0，实例化一个优先队列(queue.PriorityQueue)，这个优先队列实际上是由堆来维持最大值的，实例化根节点，只传入根节点(根节点的level=-1)，使用.put()将根节点传入优先队列中。

def BFS(self,weights,values,W,n):
        max_value = 0
        priority_queue = queue.PriorityQueue()
        root = Node(-1,0,0,0)
        priority_queue.put(root)

2)下面是while内的逐行解释（从第一次循环开始）:

1.使用一个while循环，当优先队列不为空的时候，使用.get()从优先队列中获取结点。

2.如果还未搜索到叶子结点(node.level < n-1)，则进入到下一层，对level+1(始终记得根节点是-1)。

3.此时对第二层的结点的重量以及价值进行一个判断，node.weight是根节点的重量为0，weights[level]为第二个结点的重量(我们输入的weights是一个列表，其中的索引为[0,1,2,3],因此此时加的是索引为1的这个值), 对value做同样的操作.

4.if语句判断next_weights和next_values是否超过最大重量W和最大价值,如果没有超过最大重量，并且当前价值超过了最大价值，那么把当前的最大价值赋值给max_value。

5.bound_value这里是一个限界函数，具体解释如下:

如果所有剩余的物品不能全部装入背包，那么价值的上界 

       node.value=node.value+ (value[i+1]+…+value[k])+(物品k+1装入的部分重量)× 物品k+1的单位价值,这样每个结点实际装入背包的价值一定小于等于该上界。 

同时这个限界函数给出每一个可行结点相应的子树可能获得的最大价值的上界。如 果这个上界不比当前最优值更大，则说明相应的子树中不含问题的最优解， 因此该结点可以剪去(剪枝)。

6.如果这个限界值bound_value大于max_value，则说明，这个结点可以进行扩展，是有可能找到更优解的，因此将其存入优先队列，并且Node中传入更新后的重量，价值，level，以及限界值。

如果bound_value <= max_value则什么都不做(相当于剪枝了).

最后未选择的结点我们不改变重量，价值以及限界值，只改变level，将其存储优先队列。

注意:此时优先队列中始终维护传入队列的结点的最大值为第一个值，因为最大的值更有可能作为扩展对象，可以增大搜索效率。

最后while循环结束传入max_value

while not priority_queue.empty():
            node = priority_queue.get()

            if node.level < n-1:
                level = node.level + 1
                
                next_weights = node.weight + weights[level]
                next_values = node.value + values[level]
                
                if next_weights <= W and next_values > max_value:
                    max_value = next_values
                
                bound_value = node.value + (W - node.weight) * (values[level]/weights[level])
                
                if bound_value > max_value:
                    lnode = Node(level,next_weights,next_values,bound_value)
                    priority_queue.put(lnode)
                
                rnode = Node(level,node.weight,node.value,node.bound)
                priority_queue.put(rnode)
        return max_value

3）进行测试

weights = [4, 7, 5, 3]
values = [40, 42, 25, 12]
W = 10
n = 4
b = Solution()
a = b.BFS(weights,values,W,n)
print(a)

测试的最终结果为65。