精华内容
下载资源
问答
  • 在一个特定的尺寸(1000*1200mm)内以最佳利用率的方式放满N个长方形或正方形(相同或不同尺寸均有),每个图形之间的距离为2mm,欢迎一起探讨(可私信),谢谢!
  • 二维箱式包装 所罗门·博斯韦尔 一个基于JukkaJylänki的文章包装箱的的二维箱包装库 该库用于脱机打包。 Jukka文章中的所有算法试探法和优化都包括在内。 可获得用Flask和ReactJS制作的Web演示。打包性能随优化...
  • 该项目是我们工程学院尼斯索菲亚理工学院算法课程的作业。 问题与装箱有关:我们有尺寸相同的容器和各种尺寸的箱子。 目标是使用尽可能少的容器来装满所有的盒子。 他们 == 方法== 我们的方法是对所有高度递减的框...
  • 【python】欧姆龙智能物料排布之二维装箱算法实现

    千次阅读 热门讨论 2020-02-24 10:13:52
    算法衍生自欧姆龙杯大赛智能物料排布赛项 最终实现给出一个在一个指定的平面区域内,不同形状、大小、数量的平面物料的最节省空间的排布方式,且具有实时显示功能 问题描述: 排布区域 平面区域为40×50(X方向×...

    本算法衍生自欧姆龙杯大赛智能物料排布赛项

    简介

    最终能实现给出一个在一个指定的平面区域内,不同形状、大小、数量的平面物料的最节省空间的排布方式,且具有实时显示功能

    问题描述:

    • 排布区域
      平面区域为40×50(X方向×Y方向)的矩形。
    • 物料描述
      1、包含矩形和三角形两种形状。
      2、矩形和三角形的总数为25个,每种形状至少有一个。
      3、矩形和三角形的面积、数量随机。
    • 排布规则
      1、所有物料都必须使用
      2、所有物料之间不能叠放
      3、物料可以进行任意角度的旋转
      4、物料不可进行镜像翻转
      5、所有物料的排布位置不能超过排布区域

    程序界面:


    (注:此图还没排完,处在暂停当中)


    • 显示框内红色线为此桢的排列的高度最高峰;灰色线为100%利用率高度线
    • 主线程mywin使用pyqt5实现界面的显示和刷新。在程序接收到物块坐标数据,并点击开始之后,线程Calculator开始对坐标数据进行计算,同时,mywin将以100hz的频率刷新显示。

    源码链接:

    https://github.com/Ralphson/2D-binning_omron


    突然有了契机,来回忆一下程序的实现

    运算框架


    • 其中排矩形是一个类贪心算法,保障底层排序时的空隙尽量小
    • 排三角形的逻辑是在矩形表面处的点上做遍历,在一个点上取重心低的姿态存储,一个三角形取所有位置低的姿态为最终姿态
    • 回溯则是在所有图形都排完后,对结果按照从高到低的顺序依次重新寻找位置:如示例界面中所示,红色的为当前最高峰、灰色为100%线,故数据集的回溯为从最高峰开始依次剔除100%线以上的所有图形并重新排列

    重要功能的实现

    1. 点在图形内检测:
      如何判断一个点是否在图形内(三角形、矩形甚至任意多边形),我用的方法是判断点与角的关系,即判断点是否在该角内,再重复所有角达到判断是否在图形内的目的。

      其中两组向量叉乘:
      OP×OAOP×OB \vec {OP} \times\vec {OA}和\vec {OP} \times \vec {OB}
      反映了向量OP与向量OAOB的位置关系:如果点P在角AOB内,则结果异号;若在边上,则结果包含0;若在外面,则结果同号。判断一个角如上,判断所有角同理。
    def judgePointInner(x, y, location):
    	'''
    	判断点在多边形内
    	进行区域规整的快速判断
    	:param x: 判断点x
    	:param y: 判断点y
    	:param location:待检测区域。必须是按照边的顺序,连着给的点; 图形坐标:[[], [], [], []]
    	:return:在里面为-1,在外面为1,在边上0
    	'''
    	# 判断是否在包络外
    	x_set = [i[0] for i in location]
    	y_set = [i[1] for i in location]
    	x_min = min(x_set)
    	x_max = max(x_set)
    	y_min = min(y_set)
    	y_max = max(y_set)
    	if x < x_min or x > x_max:
    	    return 1    # 在外面
    	if y < y_min or y > y_max:
    	    return 1    # 在外面
    	
    	flag = -1   # -1在里面;0在边上;1在外面
    	for i in range(len(location)):
    	    point = location[i]
    	    if i == 0:
    	        point_next = location[i + 1]
    	        point_bef = location[-1]
    	    elif i == len(location) - 1:
    	        point_next = location[0]
    	        point_bef = location[i - 1]
    	    else:
    	        point_next = location[i + 1]
    	        point_bef = location[i - 1]
    	    v0 = [x - point[0], y - point[1]]
    	    v1 = [point_next[0] - point[0], point_next[1] - point[1]]
    	    v2 = [point_bef[0] - point[0], point_bef[1] - point[1]]
    	
    	    # 叉乘之积
    	    answer = (v0[0]*v1[1] - v1[0]*v0[1]) * (v0[0]*v2[1] - v2[0]*v0[1])
    	    if answer > 0:  # 在外面
    	        flag = 1
    	        return flag
    	    if answer == 0:	# 在边上
    	        flag = 0
    	
    	return flag # 在里面
    
    1. 图形的重叠检测:
      在有了点是否在图形内的判断的基础上,就容易实现图形的重叠检测:
      (这套判断适用于任意多边形之间的判断,对于三角形和矩形的情景应该有简化的方案)
    现有图形A、B
    判断:
    1、A是否在B的矩形包络内;
    2、A的重心是否在B内,B的重心是否在A内;
    3、A的所有点是否在B内;
    4、A的所有边是否与B相交;
    
    def judgeCoin(self, Xc, Yc, location):
    	'''
    	待排图形与已排图形的重叠检测
    	根据已排图形来
    	
    	location:待检查图形, [[], [], []]
    	Xc:形心x
    	Yc:形心y
    	:return:    重叠T/不重叠F
    	'''
    	#判断是否在包络外
    	x_list = [i[0] for i in location]
    	y_list = [i[1] for i in location]
    	x_min = min(x_list) # 带派图形的x最低值
    	x_max = max(x_list)
    	y_min = min(y_list)
    	y_max = max(y_list)
    	
    	# 遍历已经排放图形的顶点信息
    	for Point in self.settledPoints: # [[Yc, y_max, Xc, gender, location, num, s], ..]
    	    settledGraph = Point[4] # [[], [], [], []] # 以排图形
    	    x_list_set = [i[0] for i in settledGraph]
    	    y_list_set = [i[1] for i in settledGraph]
    	    x_min_set = min(x_list_set)  # 已派图形的x最低值
    	    x_max_set = max(x_list_set)
    	    y_min_set = min(y_list_set)
    	    y_max_set = max(y_list_set)
    	    # 离得太远的直接跳过
    	    if x_max<x_min_set or x_min>x_max_set or y_max<y_min_set or y_min>y_max_set:
    	        continue
    	
    	    # 检查重心
    	    exist0 = self.judgePointInner(Xc, Yc, settledGraph)
    	    if exist0 == -1 or exist0 == 0:   # 形心不能在里面或边上
    	        return True # 形心在里面
    	
    	    # 检查各个点
    	    for i in range(len(location)):
    	        x = location[i][0]
    	        y = location[i][1]
    	        exist1 = self.judgePointInner(x, y, settledGraph)  # 图形的顶点
    	        if exist1  == -1:   # 顶点可以在边上但不能在里面
    	            return True #形心在里面
    	
    	    # 检查边界线香蕉
    	    line_already = []   # 已排图形的线
    	    if len(settledGraph) == 3:    # 三角形
    	        l = [[settledGraph[0], settledGraph[1]],   # 边线1
    	              [settledGraph[1], settledGraph[2]],   # 边线2
    	              [settledGraph[2], settledGraph[0]],   # 边线3
    	              # [settledGraph[0], [(settledGraph[1][0] + settledGraph[2][0])/2, (settledGraph[1][1] + settledGraph[2][1])/2]] ,   # 中线1
    	              # [settledGraph[1], [(settledGraph[0][0] + settledGraph[2][0])/2, (settledGraph[0][1] + settledGraph[2][1])/2]]      # 中线2
    	            ]
    	        line_already.extend(l)
    	    else:   # 矩形
    	        l = [[settledGraph[0], settledGraph[1]],  # 边线1
    	             [settledGraph[1], settledGraph[2]],  # 边线2
    	             [settledGraph[2], settledGraph[3]],  # 边线3
    	             [settledGraph[3], settledGraph[0]],  # 边线4
    	             # [settledGraph[0], settledGraph[2]],  # 中线1
    	             # [settledGraph[1], settledGraph[3]]  # 中线2
    	            ]
    	        line_already.extend(l)
    	    line_noready = []   # 未排图形的线
    	    if len(location) == 3:
    	        l = [[location[0], location[1]],   # 边线1
    	             [location[1], location[2]],   # 边线2
    	             [location[2], location[0]],   # 边线3
    	             [location[0], [(location[1][0] + location[2][0]) / 2, (location[1][1] + location[2][1]) / 2]],    # 中线1
    	             [location[1], [(location[0][0] + location[2][0]) / 2, (location[0][1] + location[2][1]) / 2]]    # 中线2
    	            ]
    	        line_noready.extend(l)
    	    else:   # 矩形
    	        l = [[location[0], location[1]],  # 边线1
    	             [location[1], location[2]],  # 边线2
    	             [location[2], location[3]],  # 边线3
    	             [location[3], location[0]],  # 边线4
    	             [location[0], location[2]],  # 中线1
    	             [location[1], location[3]]  # 中线2
    	            ]
    	        line_noready.extend(l)
    	
    	    for line0 in line_already:
    	        for line1 in line_noready:
    	            exist = self.judgeLineCross(line1, line0) # 检查线段
    	            if exist:
    	                return True # 出现香蕉
    	
    	return False    # 检查中没有发现重叠的情况
    
    1. 待补充

    另:

    python有现成的图形检测的包shapely,嫌自己开发麻烦的话直接pip install即可,但是在效率上貌似不如自己写逻辑来的好

    欢迎交流

    展开全文
  • 通过模拟人为装箱的习惯,以车柜一个角落为基点,我们放下一个物体,会在它的另外三个面继续堆叠,这个时候产生了可供堆叠的放置点,通过判断放置点的可用情况,包括添加限制条件,来实现装箱过程的计算,已经把过程...
  • 二维矩形装箱算法--二叉树--java实现.rar
  • 多个车子,N个箱子,用二维矩形方式进行装车。采用二叉树实现。java
  • 通过模拟人为装箱的习惯,以车柜一个角落为基点,我们放下一个物体,会在它的另外三个面继续堆叠,这个时候产生了可供堆叠的放置点,通过判断放置点的可用情况,包括添加限制条件,来实现装箱过程的计算,已经把过程...
  • 二维矩形装箱算法之二叉树

    万次阅读 2018-03-21 15:28:29
    如何将所有二维矩形块放入一个矩形框内。2.在满足问题1的情况下,矩形框的最小宽度和高度是多少。期望的效果图: 下面我们就来解决以上问题。1. 把矩形块放在固定大小的框内假设有一个固定大小的矩形框,比如1024...

    我们要解决两个问题:

    1.如何将所有二维矩形块放入一个矩形框内。

    2.在满足问题1的情况下,矩形框的最小宽度和高度是多少。

    期望的效果图:

     

    下面我们就来解决以上问题。

    1. 把矩形块放在固定大小的框内

    假设有一个固定大小的矩形框,比如1024x768,我们怎么把矩形块装在里面?答案:使用二叉树

    首先在左上角放置第一个(最大的)块,然后将该矩形框剩余的空白区域分割成两个较小的矩形


    以二叉树的形式递归地进行处理,最后得到一个填充的图像


    程序实现非常简单。假设输入矩形已经按从大到小排序。

    Packer = function(w, h) {
      this.root = { x: 0, y: 0, w: w, h: h };
    };
    
    Packer.prototype = {
    
      fit: function(blocks) {
        var n, node, block;
        for (n = 0; n < blocks.length; n++) {
          block = blocks[n];
          if (node = this.findNode(this.root, block.w, block.h))
            block.fit = this.splitNode(node, block.w, block.h);
        }
      },
    
      findNode: function(root, w, h) {
        if (root.used)
          return this.findNode(root.right, w, h) || this.findNode(root.down, w, h);
        else if ((w <= root.w) && (h <= root.h))
          return root;
        else
          return null;
      },
    
      splitNode: function(node, w, h) {
        node.used = true;
        node.down  = { x: node.x,     y: node.y + h, w: node.w,     h: node.h - h };
        node.right = { x: node.x + w, y: node.y,     w: node.w - w, h: h          };
        return node;
      }
    
    }

    2. 选择最小宽度和高度

    我们现在可以使用一棵二叉树来将矩形块放入一个固定大小的矩形。但是我们应该选择多大的尺寸来确保所有的矩形块都能以最优的方式放置

    我考虑了很多启发式方法。其中一个例子是取平均宽度和平均高度,然后分别乘以sqrt(n),以生成一个正方形。n是矩形块的数量。因为使用了平均值,生成矩形块矩形框可能太大也可能太小。

    那么有没有别的方法呢?下面来看我们提出的方法。

    3. 将矩形块填充进一个不断增长的矩形框

    我们不是试图猜测矩形框的最优宽度和高度,我们可以先建立一个小的目标:能容下第一个矩形块。然后在没有足够的空间来容纳下一个块的时候,扩充矩形框。

    先来看下没有足够的空间来容纳下一矩形块的情况:


    这时我们有两种选择,我们可以让矩形框向下生长,或者向右生长


    这可以通过在原始程序中添加几行代码来实现:

    fit: function(blocks) {
          var n, node, block;
    +     this.root = { x: 0, y: 0, w: blocks[0].w, h: blocks[0].h };
          for (n = 0; n < blocks.length; n++) {
            block = blocks[n];
            if (node = this.findNode(this.root, block.w, block.h))
              block.fit = this.splitNode(node, block.w, block.h);
    +       else
    +         block.fit = this.growNode(block.w, block.h);
          }
        },

    • 确保根节点被初始化为与第一个矩形块相同的大小
    • 每当findNode返回null时,调用一个新的方法grownode扩充矩形框

    实际上,实现grownode方法时需要一些条件判断:

    growNode: function(w, h) {
    
    1    var canGrowDown  = (w <= this.root.w);
    1    var canGrowRight = (h <= this.root.h);
    
    2    var shouldGrowRight = canGrowRight && (this.root.h >= (this.root.w + w)); // attempt to keep square-ish by growing right when height is much greater than width
    2    var shouldGrowDown  = canGrowDown  && (this.root.w >= (this.root.h + h)); // attempt to keep square-ish by growing down  when width  is much greater than height
    
         if (shouldGrowRight)
           return this.growRight(w, h);
         else if (shouldGrowDown)
           return this.growDown(w, h);
         else if (canGrowRight)
          return this.growRight(w, h);
         else if (canGrowDown)
           return this.growDown(w, h);
         else
           return null; // need to ensure sensible root starting size to avoid this happening
       },

    几点注意事项:

    • 如果矩形块比框宽,我们就不能支持矩形框向下生长
    • 如果矩形块比框高,我们就不能支持矩形框向右生长

    这对算法有相当大的影响。如果一个块比矩形框的宽和高都大,那么我们就不能生长了!解决方案是确保我们的块首先被排序,这样所有后续的块都至少有一个边缘比矩形框小。

     这并不是说我们不能支持这个,但会添加额外的复杂性。

    • 如果框的高度大于它的宽度再加上块的宽度,那么为了保持近似方形,框向右生长
    • 如果框的宽度大于它的高度再加上块的高度,那么为了保持近似方形,框向下生长

    这就阻止了我们不断地向右生长并创建一个水平的长条。这也阻止了我们不断的向下生长并创造一个狭窄的垂直地带。它的结果近似于正方形。

    4.对矩形块排序

    块被放入框的顺序对结果有很大的影响。让我们先看看专家们怎么说:

        理论和实证结果表明,‘first fit decreasing’是最好的启发式方法。按照从大到小的顺序排列对象,这样最大的对象第一放入,最小的最后一个放。将每个对象依次地插入到第一个有空间可以容纳它的箱子里。

    这里的大小是什么意思?宽度?高度?面积吗?

    通过从各种排序算法中进行选择

    宽度
    高度
    面积
    maxside——(宽度,高度)
    随机-随机化顺序

     每一种主要排序也有二级(有时是第三级)排序标准,以避免在其他情况下是相等的。

    结果表明,maxside几乎总是最好的选择。意思是,结果大致是正方形的(不是长而细的),并且有最少的空白。


    demo的演示地址:https://codeincomplete.com/posts/bin-packing/demo/

    展开全文
  • 有160个弹簧,20个箱子,每个箱子可以装8个弹簧,每个...第排5—8高度差不超过1mm,1-8之间的高度差不超过2mm。怎么装法最合理?160个弹簧,如果有超出这个条件的,需要返修后,再放入,怎么能做到最少的返修呢?
  • 二维装箱问题是具有广泛应用背景的一类组合优化问题 ,这类问题是 NP难问题 ,很难得到精确解 。将二维装箱问题表示为一个非线性规划模型 ,用变分分析中切锥的概念建立了这一优化问题的一阶最优性条件 。给出了求解这...
  • 基于二叉树与叶子链表算法思维对输入的矩形数据进行动态排版,缩进式树状打印与Opengl绘制显示排版结果。 实现了将全部的矩形紧凑封装在一个近似正方形的空间中,提高了空间利用率,能达到90%以上,减少了内存资源的...

    Github获取源码:https://github.com/ColorGalaxy/Bin-Paking-Algorithm

    B站算法讲解与展示:https://www.bilibili.com/video/av92839895


    基于二叉树叶子链表算法思维对输入的矩形数据进行动态排版,缩进式树状打印与Opengl绘制显示排版结果。
    实现了将全部的矩形紧凑封装在一个近似正方形的空间中,提高了空间利用率,能达到90%以上,减少了内存资源的浪费。

    配置:

    简单的使用了Glut库进行Opengl绘制窗体与矩形,首次编译需要配置glut环境,这也是我博客的博文,求关注嘿嘿
    配置结束后,记得将解决方案配置设置为Debug x86,否则glut.h文件会找不到

    内含:

    • 7个数据集,数据需为整数,5和7数据集复杂度高,新增了叶子链表查询后才跑的通

    功能:

    • 按照近似正方形的规则,添加矩形时会自适应的不断扩充外接矩形的大小
    • 按照宽度/高度/面积/最大边排序算法对矩形数据集排序
    • 调用windows文件浏览窗口,选择本地txt数据集作为输入(矩形格式为 宽 高 数量)
    • 使用Opengl显示列表在窗口中绘制空间利用率
    • 一次性绘制左键点击逐个绘制矩形排版结果(在glDraw.cpp中通过define设置)

    运行结果

    数据集5
    2 2 256
    4 4 128
    8 8 64
    16 16 32
    32 32 16
    64 64 8
    128 128 4
    256 256 2

    数据集7
    100 100 3
    60 60 3
    50 20 20
    20 50 20
    250 250 1
    250 100 1
    100 250 1
    400 80 1
    80 400 1
    10 10 100
    5 5 500

    展开全文
  • 简单的二维装箱代码

    热门讨论 2012-08-01 23:51:31
    简单实现了二维装箱问题。不过仅仅是简单实现,排列7、8个矩形没问题,超过10个就要花N久了。。
  • 改进了FFA算法,提出了区间合并和最小浪费面积的概念,并阐述了实现的方法.最后,采用基于改进的FFA算法的混合遗传算法得到了较好的结果,并对结果进行了分析.
  • 二维装箱

    千次阅读 2018-07-24 12:25:14
    //节点 public class Node { public int X { get; set; } public int Y { get; set; } public int W { get; set; } public int H { get; set; } public bool Is...
        //节点
        public class Node
        {
            public int X { get; set; }
            public int Y { get; set; }
            public int W { get; set; }
            public int H { get; set; }
            public bool IsUsed { get; set; }
            public Node Right { get; set; }
            public Node Down { get; set; }
            public DataModel Data { get; set; }
        }
        //数据源
        public class DataModel
        {
            public int W { get; set; }
            public int H { get; set; }
            public int Area { get; set; }
            public bool IsUsed { get; set; }
        }
        public class Core
        {
            private Node m_Root;
            private int m_TemplateWidth;
            private int m_TemplateHeight;
            public List<Model.DataModel> Data;
            public Core(List<DataModel> Datas,int TemplateWidth,int TemplateHeight)
            {
                this.Data = Datas;
                this.m_TemplateWidth = TemplateWidth;
                this.m_TemplateHeight = TemplateHeight;
            }
    
            public Node Paking()
            {
                this.m_Root = new Node() { W = this.m_TemplateWidth, H = this.m_TemplateHeight };
                foreach (var item in this.Data)
                {
                    if (!item.IsUsed)//该数据已经包装
                    {
                        var CurrentNode = this.FindNode(this.m_Root, item);
    
                        if (CurrentNode != null)
                        {
                            this.SplitNode(CurrentNode, item);
                            item.IsUsed = true;
                        }
                    }
                }
    
                return this.m_Root;
            }
    
            public Node FindNode(Node root, Model.DataModel model)
            {
                if (root.IsUsed)
                {
                    //往右摆放是否有空间
                    var node = FindNode(root.Right, model);
                    if (node == null)
                    {
                        //往下摆放是否有空间
                        node = FindNode(root.Down, model);
                    }
                    return node;
                }
    			//无需旋转
                else if (model.W <= root.W && model.H <= root.H)
                {
    				return root;
                }
    			//宽高交换
                else if (model.W <= root.H && model.H <= root.W)
                {
                    int Temp = model.W;
                    model.W = model.H;
                    model.H = Temp;
                    model.IsRotate = true;
                    return root;
                }
                else
                {
                    return null;
                }
            }
    
            public Node SplitPlate(Node node, Model.DataModel model)
            {
                node.IsUsed = true;
                node.Data = model;
                node.Down = new Node { W = node.W, H = node.H - model.H, X = node.X, Y = node.Y + model.H };
                node.Right = new Node { W = node.W - model.W, H = model.H, X = node.X + model.W, Y = node.Y };
    
                return node;
            }
        }
        static class Program
        {
            /// <summary>
            /// 应用程序的主入口点。
            /// </summary>
            [STAThread]
            static void Main()
            {
                List<Model.DataModel> Data;//绑定数据源
                int TemplateWidth = 1024,int TemplateHeight = 762;//容器
                Core core =new Core(Data.OrderBy(u=>u.Area).ToList(),TemplateWidth, TemplateHeight);
                Node root = core.Paking();
                //递归输出数据
            }
        }
    

    1.对数据源倒序

    2.通过摆放最大的体积

    3.将最大体积摆放后的下和上拆分成两个块,进行递归摆放。

    展开全文
  • 一种新的集装箱问题算法,适用二维
  • 题目描述 一个工厂制造的产品形状都是长方体,它们的高度都是h,长和宽都相等,一共有六个型号,他们的长宽分别为1*1, 2*2, 3*3, 4*4, 5*5, 6*6。这些产品通常使用一个 6*6*h 的长方体包裹包装然后邮寄给客户。...
  • 二维遗传算法matlab代码
  • 上面的描述是一个三维的装箱问题,但是题目说大箱子的长度和小箱子的长度相同,所以可以转换为一个二维空间上的装箱问题,只考虑宽和高。 思考: 怎么装才能保证装的最多?从最小的开始装,装到装不下了就是最多的...
  • 28、二维装箱

    千次阅读 2019-06-06 20:29:56
    from pyscipopt import Model, quicksum from vtk import * import vtk import random as rd import time import numpy as np ...#二维商品排序用 def cmp_2d(x,y): if x[0] < y[0]: return...
  • 论文研究-带二维装箱约束的物流配送车辆路径问题.pdf, 现实物流活动中大量存在的易损、 易碎物品的运输问题属于带二维装箱约束的物流配送问题, 该问题是二维装箱问题与...
  • 基于 三维装箱问题的算法研究-1 的基础上 对整个装箱过程发生的函数进行封装 # -*- coding: utf-8 -*- from matplotlib import pyplot as plt #设置图表刻度等格式 from matplotlib.ticker import MultipleLocator, ...
  • 同时在遗传迭代过程中,引入二维装箱问题的下界思想作为迭代的终止条件之一,减少了遗传算法无效迭代次数,另外根据问题自身特点,有效地降低了染色体长度,提高了整体的计算速度。在36个标准测试案例的测试基础上与...
  • 二维装箱问题顾名思义就是将若干个矩形物品装进矩形箱子中,并且在装箱的过程中不允许将矩形物品斜着放(PS:下图就是不允许的装箱操作),同时在装箱过程中允许将物品旋转90度放置(但是为了简单地求解问题,我们...
  • 一个三维装箱问题的搜索树算法

    千次阅读 2020-03-20 17:52:04
    维装箱问题的业务场景可以参考电商业务中的纸箱推荐问题. 文中考虑了如下问题. 输入 : 长宽高为(L,W,H)(L, W, H)(L,W,H)的箱子和nnn个物品, 其长宽高为(li,wi,hi)(l_i, w_i, h_i)(li​,wi​,hi​), i=1,2,…,ni=1...
  • #二维商品排序用 def cmp_2d(x,y): if x[0] [0]: return -1 elif x[0] > y[0]: return 1 elif x[1] [1]: return -1 elif x[1] > y[1]: return 1 else: return 0 def data_pre(boxs, goods): #箱子长边...
  • 1 粒子群算法的概念 粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的协作和信息...
  • 开始写我们的放置逻辑 所以从第个货物开始,我们就开始重复性的发生货物的堆叠 并重复性的产生新的放置点,直到放置点不再可用 #所以从我们的仓库B不断的把货物B_i搬到箱体里,限制条件为在X,Y,Z方向上可用点小于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,122
精华内容 1,248
关键字:

二维装箱算法