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

最新推荐文章于 2024-05-23 23:25:10 发布
最新推荐文章于 2024-05-23 23:25:10 发布
阅读量3.7k 收藏 7
点赞数 3
分类专栏： 装箱问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoyuzhang/article/details/106945421
版权

原文链接：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()

 

chaoyuzhang
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用户增长全局最优化和评估
chazhongxinbitc的博客
04-04 537
说完用户增长整体框架，个体的因果推断预测，接下来是根据个体的预估，求解全局最优解，得到最优决策。 1. 干预场景 干预变量(比如淘宝的业务场景)： push - 整体约束：下行条数、点击率约束；个体周期频控 优惠券 - 约束：核销成本；发放限制 红点/气泡 - 约束：区域展示次数；个体周期频控 2. 全局最优决策 [wiki] [kkt] 3. 求解-分组背包问题 这个线性松弛后的问题我们称为 LMCKP。LMCKP 的求解是很容易的，常见的算法有贪婪算法（复杂度O(Nlog⁡(.
基于无线传感器网络的MCKP-MMF算法matlab仿真
熟悉python,matlab,C,C++,JAVA等
11-11 151
第一阶段是通常所谓的慢启动阶段，在该阶段，各个sink开始于最小半径的请求，然后以某种速度增加其请求半径，直到算法发现一个潜在的瓶颈节点，此时相关sink将收到消息。某个访问点可能先后收到来自多个拥塞节点的重新设置影响半径的要求，此时为了满足带宽消耗最大的节点的带宽限制，访问点需要将其新影响半径设置为其中最小的一个。一种简单的方法是每次收到这样的请求之后，将其中包含的新影响半径与访问点当前影响半径比较，如果新影响半径较小则修改当前影响半径为新影响半径，否则访问点保持当前影响半径。
优化问题基础知识
最新发布
一去不复返的通信er
05-23 723
优化问题知识记录
预算分配Budget Allocation：两篇论文（二）
素质云笔记
06-09 4885
1 达摩院：A Unified Framework for Marketing Budget Allocation A Unified Framework for Marketing Budget Allocation 参考解读文章：A Unified Framework for Marketing Budget Allocation 1.1 通用预算分配框架 这篇paper总结的蛮给力的，一个预算分配的通用框架，包括两个步骤， 首先通过历史数据去学习需求曲线，也可称为市场响应模型（market resp
因果推断10--一种大规模预算约束因果森林算法（LBCF）
as472780551的博客
02-26 2048
向用户提供奖励(例如亚马逊的优惠券，优步的折扣和抖音的视频奖金)是在线平台用来提高用户粘性和平台收入的常用策略。尽管这些营销激励已被证明是有效的，但如果使用不当，会产生不可避免的成本，并可能导致低ROI(投资回报)。另一方面，不同的用户对这些激励措施的反应不同，例如，有些用户从未在没有优惠券的情况下购买某些产品，而另一些用户则无论如何都会购买。因此，如何在预算限制下为每个用户选择合适的激励(即待遇)是一个具有重大现实意义的重要研究问题。在本文中，我们称这种问题为预算约束的治疗选择问题。
Lecture09:Benders分解--理论部分
AmieeXue的博客
01-05 5244
Benders分解的理论推导
预算约束下营销效果优化的端到端框架（快手）
as472780551的博客
04-24 746
向消费者提供奖励(如现金奖励、折扣、优惠券)是在线平台获取新用户、增加用户参与度、提高平台收益的有效途径[2,3,9,20,21,32,37,38,40,41]。例如，在淘宝[37]中提供优惠券以增加用户活跃度，在Booking[9]中提供促销以提高用户满意度，在快手[2]中使用现金奖励来刺激用户留存，在Uber[40]中使用促销来鼓励用户开始使用新产品。尽管有效，但这些营销活动可能会产生高成本，因此在实际场景中总预算通常是有限的。
随机对偶动态规划 SDDP，报童模型的一个 python 例子
天天向上的专栏
03-31 5014
将 benders 分解与 SAA 方法结合在一起，就产生了随机对偶动态规划方法。这两年在论文里看到了这个方法，一般用在运输或能源规划问题中，在库存管理问题中还没见别人用过。
solve_Greedy Algorithms.zip_0-1背包问题_algorithms_greedy算法_背包问题_贪婪算
07-14
背包问题0,1问题，贪婪算法MATLAB源程序
e-greedy n-armed bandits problem matlab实现
09-12
使用matlab实现 e-geedy 算法，关于n-armed bandits problem。结果是产生Reinforcement Learning: An Introduction Figure 2.2 。
abcd.rar_greedy knapsack_knapsack c_背包问题 贪婪_贪婪_贪婪算法
09-19
贪婪算法解决背包问题
背包问题之贪婪算法求解C语言源代码).rar_greedy_greedy knapsack_knapsack greedy_背包
09-23
背包问题的贪婪算法，需要的下，不需要帐号的，自由的下。
4-7d多处最优服务次序问题.zip_greedy knapsack_passage2zn_算法设计与分析；贪心_背包问题
09-15
用贪心算法实现课后习题多处服务次序最优问题、会场活动安排问题、特殊0-1背包问题
背包问题及其对偶问题
weixin_51121822的博客
01-08 948
简要介绍了背包问题，以0-1背包问题为例，主要描述了背包问题的对偶问题的两种解法——动态规划算法和完全多项式的近似算法，并进行了两者之间的性能对比。
无线传感器网络基于MCKP-MMF算法的流量估计matlab仿真
FPGA/MATLAB学习教程/源码/项目合作开发
10-19 1599
基于此，节点与访问点之间的通信可以用图表示，在中两个节点之间存在一条边当且仅当它们之间的距离小于某一常数值。为了定义访问点的本地影响范围，我们需要引入，我们称之为访问点半径，访问点与中距离其最远的节点的跳数。访问点半径从某种程度上反应了访问点对网络的影响力，或该访问点的效用。此后，算法在执行的每一轮中发现一个较好的部分解，并将相关的访问点置为停止状态，直至所有访问点都成为停止状态，算法终止。当然，回报函数在此可以更确切的描述为代价函数，表示对于某个访问点，其影响半径从变化为时，给节点带来的额外负担。
随机规划求解方法总结
热门推荐
天天向上的专栏
03-09 1万+
随机规划问题由于随机性的存在，非常难于求解，自己根据目前的阅读与研究，总结出以下几点： 1. 使用随机动态规划。 这本质上是一种穷举的方法，能够得到最优解，然而不适宜求解大规模问题。 2. 分析问题的性质，找到最优解结构。 一般需要针对特定问题，需要高超的数学推导技巧。 3. 将其中的随机函数线性化。 若能够线性化，则可以用线性规划软件直接求解。但并不是所有的随机函数都能够...
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 #数据生成，输入为箱子种类数，箱子最大长、最小长、最大宽、最小宽、商品个数、商品最大长、最小长、最大宽...
greedy best-first search
06-28
### 回答1： 贪心最佳优先搜索（Greedy Best-First Search）是一种启发式搜索算法，它通过在每个搜索步骤中优先考虑最有可能导致解决方案的节点，来寻找最优解。与广度优先搜索不同，贪心最佳优先搜索使用一个评估函数来衡量搜索状态的好坏，然后按照评估函数的值来选择下一个要扩展的节点。贪心最佳优先搜索通常用于解决状态空间较大，但具有良好的启发信息的问题。 ### 回答2： 贪婪最优先搜索（GBFS）是一种启发式搜索算法，其基本思想是根据一定的启发函数，尽可能快地向目标状态方向搜索。它的搜索过程类似于最优先搜索，但是它不使用精确的代价函数，而是使用启发函数来估计从当前状态到目标状态的代价。 GBFS通过选择启发函数中具有最小估计代价的节点来扩展搜索树，因此它可能会快速地向目标状态移动。然而，由于它只考虑了估计代价，而没有考虑实际代价，因此它有可能陷入死胡同或者过早的终止搜索。 与最优先搜索类似，GBFS也具有一个开放列表，其中包含了待搜索的节点。通过比较启发函数的值，GBFS选择启发值最小的节点进行扩展。当搜索到达目标状态时，GBFS停止搜索。 与其他搜索算法相比，GBFS具有以下优缺点： 优点： 1. 它可以快速地向目标状态移动。 2. 它在内存和计算资源上比A*搜索更加高效。 缺点： 1. 它可能陷入局部最优解并忽略其他有可能更优的解。 2. 它无法保证找到最优解。 3. 它存在一个问题，即当启发函数不准确时，可能会浪费大量的时间和计算资源搜索不必要的节点。 总的来说，GBFS对于大多数问题而言是一个高效的搜索算法，但是它的表现取决于使用的启发函数的准确性。 ### 回答3： 贪婪最佳优先搜索（Greedy Best-First Search）是一种启发式搜索算法，它选取可行节点中最有希望的节点作为下一个扩展节点。在贪婪最佳优先搜索中，每个节点都被赋予一个估价函数的值，估价函数用于估计从当前节点到目标节点的最小代价或距离，该算法通常用于解决单目标问题，如路径规划或机器人导航。 贪婪最佳优先搜索过程中，节点状态用一个优先队列来维护。节点的优先级由估价函数的值决定，即节点的估价函数值越小，则节点的优先级越高，队列中位置越靠前。这种贪心策略导致该算法的效率很高，但是不能保证它能找到全局最优解，它只能找到靠近目标的局部最优解。 贪婪最佳优先搜索的优点是速度快，但是它有缺陷。该算法只能找到越来越接近终点的节点，但是它不能保证一些没有被考虑的位于路径上的节点，这些节点可能会导致更短或更优的路径。因此，该算法只适用于简单问题，但是在复杂问题上找到最优解的准确性不可靠。 在实际问题中，我们通常使用A*算法代替贪婪最佳优先搜索。A*算法既具备贪婪最佳优先搜索的速度和效率，又能优化贪婪算法的不足之处，它能确保找到最优解，并取得了广泛的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值