62、分组背包问题（MCKP）Greedy、Dyer-Zemel、对偶界、动态规划实现

最新推荐文章于 2025-01-15 19:25:09 发布
最新推荐文章于 2025-01-15 19:25:09 发布
阅读量4.2k 收藏 8
点赞数 3
分类专栏： 装箱问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chaoyuzhang/article/details/106945421
版权
本文探讨了多元约束背包问题(MCKP)的多种求解算法，包括线性支配过滤、贪心算法、Dyer-Zemel算法、拉格朗日松弛和动态规划。通过实例演示了各算法的实现过程与结果对比。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原文链接：https://link.springer.com/chapter/10.1007/978-3-540-24777-7_11

不同于传统的背包问题，MCKP需要保证每个分组里面至少选一个物品，建模如下

 

其提出线性支配（LP-dominated）的定义如下

这是个筛选的过程，把处于支配（同一组内存在比你重量小但价值高的物品）的去掉，线性支配的定义会更强，比如3和7，其被线性支配，故被去掉，我个人理解这样在部分情况有可能把最优解去掉了，所以一般采用前者。

 

纯贪心算法如下

class Good():
    def __init__(self, row, col, p, w):
        self.row = row
        self.col = col
        self.p = p
        self.w = w

    def __repr__(self):
        return str((self.w, self.p))

def goods_filter_LP_dominated(goods, exacting=True):

    [goods[i].sort(key=lambda n:n.w, reverse=False) for i in range(len(goods))]

    goods1 = [[goods[i][0]] for i in range(len(goods))]
    for i in range(len(goods)):
        p, w = goods1[i][0].p, goods1[i][0].w
        for j in range(1, len(goods[i])):
            if goods[i][j].w == w and goods[i][j].p > p:
                goods1[i][-1] = goods[i][j]
                p = goods[i][j].p
            elif goods[i][j].w > w and goods[i][j].p > p:
                goods1[i].append(goods[i][j])
                p, w = goods[i][j].p, goods[i][j].w

    # 严格LP_dominated
    if exacting:
        goods2 = [[goods1[i][0]] for i in range(len(goods1))]
        for i in range(len(goods1)):
            j = 0
            while j < len(goods1[i]) - 1:
                slopes = [[k, (goods1[i][k].p - goods1[i][j].p) / (goods1[i][k].w - goods1[i][j].w)] for k in range(j + 1, len(goods1[i]))]
                slopes.sort(key=lambda x: x[1], reverse=True)
                j = slopes[0][0]
                goods2[i].append(goods1[i][j])
        goods1 = goods2

    return goods1


#每次更新都选择局部提升最大的
def Greedy(goods, c):

    goods = goods_filter_LP_dominated(goods, exacting=True)

    # 做成链表的形式，利于贪心算法
    class Node():
        def __init__(self, good):
            self.good = good
            self.improve = float("-inf")
            self.next = None
        def __repr__(self):
            return str(self.good)

    L_Node = []
    for i in range(len(goods)):
        n = Node(goods[i][0])
        temp = n
        j = 0
        while j+1 < len(goods[i]):
            j += 1
            temp.next = Node(goods[i][j])
            temp.improve = (goods[i][j].p - goods[i][j-1].p) / (goods[i][j].w - goods[i][j-1].w)
            temp = temp.next
        L_Node.append(n)

    # 初始化可行解Y，使用空间d，价值z
    d = sum([L_Node[i].good.w for i in range(len(L_Node))])

    is_end = False
    while not is_end:
        is_end = True
        L_Node.sort(key=lambda x: x.improve, reverse=True)
        for i in range(len(L_Node)):
            if L_Node[i].next and L_Node[i].next.good.w - L_Node[i].good.w <= c-d:
                d += L_Node[i].next.good.w - L_Node[i].good.w
                L_Node[i] = L_Node[i].next
                is_end = False
                break

    obj = sum([n.good.p for n in L_Node])
    cost = sum([n.good.w for n in L_Node])

    res_choose = [L_Node[i].good for i in range(len(L_Node))]
    res_choose.sort(key=lambda x:x.row)
    return res_choose, obj, cost


def run_one():

    #不一定最优、反例
    # P = [
    #     [25, 55, 65, 76, 40, 20, 80, 50, 89, 30, 82],
    #     [47, 20, 50, 95, 70, 40, 75, 30],
    #     [35, 10, 59, 20, 71, 15, 45, 40, 80]
    # ]
    #
    # W = [
    #     [7, 12, 24, 26, 35, 45, 51, 58, 65, 85, 90],
    #     [12, 20, 24, 36, 50, 60, 80, 84],
    #     [8, 10, 24, 30, 40, 55, 60, 80, 85]
    # ]

    P = [
        [76, 49, 79, 41, 25, 78, 31, 55, 63, 19, 89],
        [95, 17, 36, 47, 29, 51, 84, 73],
        [35, 39, 20, 51, 24, 71, 59, 80, 14]
    ]

    W = [
        [26, 62, 84, 35, 7, 54, 82, 12, 23, 50, 65],
        [36, 25, 62, 12, 91, 28, 73, 54],
        [8, 85, 61, 62, 30, 40, 24, 85, 11]
    ]
    c = 100

    goods = [[Good(i, j, P[i][j], W[i][j]) for j in range(len(W[i]))] for i in range(len(W)) if len(W[i]) > 0]
    res_choose_greedy, obj_greedy, cost_greedy = Greedy(goods, c)
    print("\nres_choose_greedy:", res_choose_greedy)
    print("obj_greedy:", obj_greedy)
    print("cost_greedy:", cost_greedy)


if __name__ == '__main__':
    run_one()

Dyer-Zemel算法如下

import numpy as np
from MCKP.method.MCKP_Greedy import *

#用中位数去筛选边，有点lagrangian的意思
def Dyer_Zemel(goods, c):

    goods = goods_filter_LP_dominated(goods, exacting=False)

    while True:
        slopes = [(goods[i][j+1].p - goods[i][j].p) / (goods[i][j+1].w - goods[i][j].w) for i in range(len(goods)) for j in range(len(goods[i])-1)]
        alpha = np.median(slopes)
        values_alpha = [[goods[i][j].p - alpha*goods[i][j].w for j in range(len(goods[i]))] for i in range(len(goods))]
        L_a = [values_alpha[i].index(max(values_alpha[i])) for i in range(len(values_alpha))]
        L_b = [L_a[i]+1 if L_a[i] < len(values_alpha[i])-1 and values_alpha[i][L_a[i]] == values_alpha[i][L_a[i]+1] else L_a[i] for i in range(len(values_alpha))]
        w_a_sum = sum([goods[i][L_a[i]].w for i in range(len(goods))])
        w_b_sum = sum([goods[i][L_b[i]].w for i in range(len(goods))])
        if w_a_sum > c:
            goods = [[goods[i][j] for j in range(len(goods[i])) if j == 0 or (j > 1 and (goods[i][j].p - goods[i][j-1].p) / (goods[i][j].w - goods[i][j-1].w)) >= alpha] for i in range(len(goods))]
        elif w_b_sum < c:
            goods = [[goods[i][j] for j in range(len(goods[i])) if j == len(goods[i])-1 or (j < len(goods[i])-1 and (goods[i][j+1].p - goods[i][j].p) / (goods[i][j+1].w - goods[i][j].w)) <= alpha] for i in range(len(goods))]
        else:
            break

    goods1 = [[goods[i][L_a[i]], goods[i][L_b[i]]] if L_a[i] < L_b[i] else [goods[i][L_a[i]]] for i in range(len(goods))]

    return Greedy(goods1, c)


def run_one():

    P = [
        [76, 49, 79, 41, 25, 78, 31, 55, 63, 19, 89],
        [95, 17, 36, 47, 29, 51, 84, 73],
        [35, 39, 20, 51, 24, 71, 59, 80, 14]
    ]

    W = [
        [26, 62, 84, 35, 7, 54, 82, 12, 23, 50, 65],
        [36, 25, 62, 12, 91, 28, 73, 54],
        [8, 85, 61, 62, 30, 40, 24, 85, 11]
    ]
    c = 100

    goods = [[Good(i, j, P[i][j], W[i][j]) for j in range(len(W[i]))] for i in range(len(W)) if len(W[i]) > 0]
    res_choose_Dyer_Zemel, obj_Dyer_Zemel, cost_Dyer_Zemel = Dyer_Zemel(goods, c)
    print("\nres_choose_Dyer_Zemel:", res_choose_Dyer_Zemel)
    print("obj_Dyer_Zemel:", obj_Dyer_Zemel)
    print("cost_Dyer_Zemel:", cost_Dyer_Zemel)


if __name__ == '__main__':
    run_one()

 

其对偶问题如下

class Good():
    def __init__(self, row, col, p, w):
        self.row = row
        self.col = col
        self.p = p
        self.w = w

    def __repr__(self):
        return str((self.w, self.p))

def goods_filter_LP_dominated(goods, exacting=True):

    [goods[i].sort(key=lambda n:n.w, reverse=False) for i in range(len(goods))]

    goods1 = [[goods[i][0]] for i in range(len(goods))]
    for i in range(len(goods)):
        p, w = goods1[i][0].p, goods1[i][0].w
        for j in range(1, len(goods[i])):
            if goods[i][j].w == w and goods[i][j].p > p:
                goods1[i][-1] = goods[i][j]
                p = goods[i][j].p
            elif goods[i][j].w > w and goods[i][j].p > p:
                goods1[i].append(goods[i][j])
                p, w = goods[i][j].p, goods[i][j].w

    # 严格LP_dominated
    if exacting:
        goods2 = [[goods1[i][0]] for i in range(len(goods1))]
        for i in range(len(goods1)):
            j = 0
            while j < len(goods1[i]) - 1:
                slopes = [[k, (goods1[i][k].p - goods1[i][j].p) / (goods1[i][k].w - goods1[i][j].w)] for k in range(j + 1, len(goods1[i]))]
                slopes.sort(key=lambda x: x[1], reverse=True)
                j = slopes[0][0]
                goods2[i].append(goods1[i][j])
        goods1 = goods2

    return goods1

def L(goods, u, c):
    return u*c + sum([max([g.p-u*g.w for g in goods[i]]) for i in range(len(goods))])

def U2_generate(goods, r, c, step_min):
    left = 0
    right = 1
    # 先采用放缩法确定寻优区间
    while L(goods, right * (2 - r), c) < L(goods, right, c):
        right = right * (2 - r)
    right = right * (2 - r)

    # 采用三分法确定步长
    mid1 = left * 2 / 3 + right / 3
    mid2 = left / 3 + right * 2 / 3
    while abs(right - left) > step_min:
        if L(goods, mid1, c) < L(goods, mid2, c):
            right = mid2
        else:
            left = mid1
        mid1 = left * 2 / 3 + right / 3
        mid2 = left / 3 + right * 2 / 3

    return L(goods, left, c)

#每次更新都选择局部提升最大的
def Lagrangian(goods, c, r=0.8, step_min=0.00001):

    goods = goods_filter_LP_dominated(goods, exacting=False)

    return U2_generate(goods, r, c, step_min)


def run_one():

    #不一定最优、反例
    # P = [
    #     [25, 55, 65, 76, 40, 20, 80, 50, 89, 30, 82],
    #     [47, 20, 50, 95, 70, 40, 75, 30],
    #     [35, 10, 59, 20, 71, 15, 45, 40, 80]
    # ]
    #
    # W = [
    #     [7, 12, 24, 26, 35, 45, 51, 58, 65, 85, 90],
    #     [12, 20, 24, 36, 50, 60, 80, 84],
    #     [8, 10, 24, 30, 40, 55, 60, 80, 85]
    # ]

    P = [
        [76, 49, 79, 41, 25, 78, 31, 55, 63, 19, 89],
        [95, 17, 36, 47, 29, 51, 84, 73],
        [35, 39, 20, 51, 24, 71, 59, 80, 14]
    ]

    W = [
        [26, 62, 84, 35, 7, 54, 82, 12, 23, 50, 65],
        [36, 25, 62, 12, 91, 28, 73, 54],
        [8, 85, 61, 62, 30, 40, 24, 85, 11]
    ]
    c = 100

    goods = [[Good(i, j, P[i][j], W[i][j]) for j in range(len(W[i]))] for i in range(len(W)) if len(W[i]) > 0]
    U2 = Lagrangian(goods, c)
    print("\nU2:", U2)


if __name__ == '__main__':
    run_one()

 

动态规划

class Good():
    def __init__(self, row, col, p, w):
        self.row = row
        self.col = col
        self.p = p
        self.w = w

    def __repr__(self):
        return str((self.w, self.p))

def goods_filter_LP_dominated(goods, exacting=True):

    [goods[i].sort(key=lambda n:n.w, reverse=False) for i in range(len(goods))]

    goods1 = [[goods[i][0]] for i in range(len(goods))]
    for i in range(len(goods)):
        p, w = goods1[i][0].p, goods1[i][0].w
        for j in range(1, len(goods[i])):
            if goods[i][j].w == w and goods[i][j].p > p:
                goods1[i][-1] = goods[i][j]
                p = goods[i][j].p
            elif goods[i][j].w > w and goods[i][j].p > p:
                goods1[i].append(goods[i][j])
                p, w = goods[i][j].p, goods[i][j].w

    # 严格LP_dominated
    if exacting:
        goods2 = [[goods1[i][0]] for i in range(len(goods1))]
        for i in range(len(goods1)):
            j = 0
            while j < len(goods1[i]) - 1:
                slopes = [[k, (goods1[i][k].p - goods1[i][j].p) / (goods1[i][k].w - goods1[i][j].w)] for k in range(j + 1, len(goods1[i]))]
                slopes.sort(key=lambda x: x[1], reverse=True)
                j = slopes[0][0]
                goods2[i].append(goods1[i][j])
        goods1 = goods2

    return goods1


#每次更新都选择局部提升最大的
def Dynamic(goods, c):

    goods = goods_filter_LP_dominated(goods, exacting=False)

    class Combination():
        def __init__(self, P, W, L):
            self.P = P
            self.W = W
            self.L = L

        def __repr__(self):
            return str((self.W, self.P))

    C = {goods[0][j].w: Combination(goods[0][j].p, goods[0][j].w, [goods[0][j]]) for j in range(len(goods[0]))}

    for i in range(1, len(goods)):
        C_next = {}
        for j in range(len(goods[i])):
            for k,v in C.items():
                if goods[i][j].w + k > c:
                    continue
                #不在或价值更高则更新
                if (goods[i][j].w + k not in C_next) or (goods[i][j].w + k in C_next and goods[i][j].p + v.P > C_next[goods[i][j].w + k].P):
                    C_next[goods[i][j].w + k] = Combination(goods[i][j].p + v.P, goods[i][j].w + k, v.L+[goods[i][j]])
        C = C_next

    res = list(C.values())
    res.sort(key=lambda x:x.P, reverse=True)
    res_choose = res[0].L
    obj = res[0].P
    cost = res[0].W
    return res_choose, obj, cost


def run_one():

    #不一定最优、反例
    # P = [
    #     [25, 55, 65, 76, 40, 20, 80, 50, 89, 30, 82],
    #     [47, 20, 50, 95, 70, 40, 75, 30],
    #     [35, 10, 59, 20, 71, 15, 45, 40, 80]
    # ]
    #
    # W = [
    #     [7, 12, 24, 26, 35, 45, 51, 58, 65, 85, 90],
    #     [12, 20, 24, 36, 50, 60, 80, 84],
    #     [8, 10, 24, 30, 40, 55, 60, 80, 85]
    # ]

    P = [
        [76, 49, 79, 41, 25, 78, 31, 55, 63, 19, 89],
        [95, 17, 36, 47, 29, 51, 84, 73],
        [35, 39, 20, 51, 24, 71, 59, 80, 14]
    ]

    W = [
        [26, 62, 84, 35, 7, 54, 82, 12, 23, 50, 65],
        [36, 25, 62, 12, 91, 28, 73, 54],
        [8, 85, 61, 62, 30, 40, 24, 85, 11]
    ]
    c = 100

    goods = [[Good(i, j, P[i][j], W[i][j]) for j in range(len(W[i]))] for i in range(len(W)) if len(W[i]) > 0]
    res_choose_Dynamic, obj_Dynamic, cost_Dynamic = Dynamic(goods, c)
    print("\nres_choose_Dynamic:", res_choose_Dynamic)
    print("obj_Dynamic:", obj_Dynamic)
    print("cost_Dynamic:", cost_Dynamic)


if __name__ == '__main__':
    run_one()

 

无线传感器网络中基于MCKP-MMF算法的流量估计——MATLAB仿真
2301_79326510的博客
09-12 181
该算法的基本思想是将传感器节点视为背包中的物品，节点之间的通信需求视为物品的重量，而网络中的链路容量则视为背包的容量。通过求解多个约束条件下的背包问题，可以得到网络中每个节点的流量需求。将节点的流量需求与链路的传输能力进行比较，即可得到流量估计结果。在传感器网络中，流量估计是一个重要的问题，它可以帮助我们了解网络中的数据流量情况，并优化网络资源的分配和管理。你可以根据自己的实际需求，修改节点流量需求和链路传输能力的参数，以及约束条件的设置，来进行不同场景下的仿真实验。）和网络链路的传输能力（
背包问题及其对偶问题
weixin_51121822的博客
01-08 1296
简要介绍了背包问题，以0-1背包问题为例，主要描述了背包问题的对偶问题的两种解法——动态规划算法和完全多项式的近似算法，并进行了两者之间的性能对比。
MCKP_AX32_220128P06.tar
02-11
ARM V7 AX32 版 -- 220128 支持 AX3000/AX6600 AX82/AX56/AX56Uv2/AX58U AX89X RAX50等
线上运筹优化公式推导
最新发布
Swift's Blog
01-15 556
min−∑ijxijpijs.t.xij∈01∑jxij1∑ijxijcij≤Cmin−ij∑​xij​pij​s.t.xij​j∑​xij​ij∑​xij​cij​​∈011≤C​xijx_{ij}xij​表示是否给用户iii发放红包jjjpijp_{ij}pij​表示用户iii在红包jjj下的核销率，由量价模型预估产生c。
分组背包问题
蓝的博客
05-31 307
有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有 N 组数据： 每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量； 每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i
分组背包问题描述与实现
weixin_33887443的博客
03-13 68
#include <stdio.h> int w[301][21]; int get_max(int a, int b) { if(a>=b) return a; else return b; } int main(void) { int tc, T; ...
分组背包问题汇总
daogujufeng的博客
07-11 403
背包问题
随机对偶动态规划 SDDP，报童模型的一个 python 例子
天天向上的专栏
03-31 6300
将 benders 分解与 SAA 方法结合在一起，就产生了随机对偶动态规划方法。这两年在论文里看到了这个方法，一般用在运输或能源规划问题中，在库存管理问题中还没见别人用过。
kp背包问题
qq_38802910的博客
04-09 408
kp背包问题
solve_Greedy Algorithms.zip_0-1背包问题_algorithms_greedy算法_背包问题_贪婪算
07-14
背包问题0,1问题，贪婪算法MATLAB源程序
基于python实现贪心算法、蛮力法、动态规划法解决分数背包问题和0-1背包问题源码+项目说明.zip
12-03
资源下载一、资源简介本资源包包含基于贪心算法、蛮力法和动态规划法解决分数背包问题和0-1背包问题的Python源码及项目说明。通过这些算法的实现，帮助用户理解不同算法在解决同一类问题上的差异和优劣。二、资源...
0-1背包问题 动态规划 分支限界 回溯 贪心四种方法
05-26
**动态规划（Dynamic Programming, DP）**是解决0-1背包问题的一种常用方法。动态规划通过构建一个二维数组，其中的每个元素表示在当前背包容量下能够获得的最大价值。状态转移方程可以表示为：`dp[i][j] = max(dp[i...
背包问题理解思路（01背包、完全背包、分组背包）
qq_37720936的博客
02-15 1154
因为三个背包问题实际上解决思路是几乎相同的，所以这里把三个问题放到一起进行记录，首先简单说下三个背包问题的题干1.01背包问题：即有数件物品，每样物品均有不同的价值和重量，先给定一个背包容量大小，求背包能装下的最大价值。2.完全背包问题：在01背包问题的基础上，每样物品有无限个（即可重复装包），求背包能装下的最大价值。3.分组背包问题：在01背包问题的基础上，把数样物品改为数组物品，每组物品中只能选择一件，求背包能装下的最大价值。
分组背包（背包问题）
weixin_52513845的博客
01-14 359
分组背包： 1.定义 （1）分组背包，通俗的讲就是，给你N组物品，然后每一组你至多选择一个物品(也可以不选),每个物品都有自己的体积和价值，现在给你一个容里为M的背包，让你用这个背包装物品，使得物品价值总和最大. （2）其实就类似于01背包，对于一个物品有两种决策选或不选，但是分组背包是在01背包的基础上对物品进行了分组，并且每一组只能最多选择一个物品，所以我们不妨用01背包的思想去思考分组背包. 2.思路 我们设f[i][j]为当前考虑到了第i组物品，剩余容里为j的背包能装物品的最大价值，那么很容易想到我
对偶问题
kyle1314608的博客
02-21 439
...
背包问题细节探析
NeverGiveUp
06-08 4189
引言：上一周在看《背包九讲》，这周也在练习背包型动态规划的题目，在这里分享几点学习过程中的体会，涉及到空间优化：二维转一维的理解以及循环顺序的理解，最后会析背包问题的一些变种问题。为了叙述方便，这篇博客仅仅谈及01背白问题和完全背包问题，其余读者感兴趣可以自己查阅《背包九讲》01背包01背包问题是所有背包问题的基础，先来看裸的01背包问题： 题目：有N件物品和一个容量为V 的背包。第i件物品的费用
背包问题
A_fearless_engineer的博客
10-31 304
文章目录概述0/1背包问题问题描述输入格式输出格式输入样例输出样例解题思路完全背包问题问题描述输入格式输出格式测试样例解题思路多重背包问题问题描述输入格式输出格式测试样例解题思路 概述   背包问题已经被研究了超过一个世纪，是动态规划中的经典问题，也是理解动态规划思想的重要工具。背包问题可以被抽象解释为：给出一个特定体积（重量）容量的背包，再分别给出多个物品的体积（重量）和价值，求解将哪些物品装入...
30、二维装箱（单品）
热门推荐
chaoyuzhang的博客
06-28 1万+
from pyscipopt import Model, quicksum from vtk import * import vtk import random as rd import time import numpy as np import functools import copy #数据生成，输入为箱子种类数，箱子最大长、最小长、最大宽、最小宽、商品个数、商品最大长、最小长、最大宽...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值