精华内容
下载资源
问答
  • 在一个特定的尺寸(1000*1200mm)内以最佳利用率的方式放满N个长方形或正方形(相同或不同尺寸均有),每个图形之间的距离为2mm,欢迎一起探讨(可私信),谢谢!
  • 二维装箱问题是具有广泛应用背景的一类组合优化问题 ,这类问题是 NP难问题 ,很难得到精确解 。将二维装箱问题表示为一个非线性规划模型 ,用变分分析中切锥的概念建立了这一优化问题的一阶最优性条件 。给出了求解这...
  • 二维箱式包装 所罗门·博斯韦尔 一个基于JukkaJylänki的文章包装箱的的二维箱包装库 该库用于脱机打包。 Jukka文章中的所有算法试探法和优化都包括在内。 可获得用Flask和ReactJS制作的Web演示。打包性能随优化...
  • 一种新的集装箱问题算法,适用二维
  • 二维矩形装箱算法--二叉树--java实现.rar
  • 改进了FFA算法,提出了区间合并和最小浪费面积的概念,并阐述了实现的方法.最后,采用基于改进的FFA算法的混合遗传算法得到了较好的结果,并对结果进行了分析.
  • 二维矩形装箱算法之二叉树

    万次阅读 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/

    展开全文
  • 多个车子,N个箱子,用二维矩形方式进行装车。采用二叉树实现。java
  • 问题装箱有关:我们有尺寸相同的容器和各种尺寸的箱子。 目标是使用尽可能少的容器来装满所有的盒子。 他们 == 方法== 我们的方法是对所有高度递减的框进行排序(如果发生冲突,则宽度递减)。 然后,我们将盒子...
  • 题目描述 一个工厂制造的产品形状都是长方体,它们的高度都是h,长和宽都相等,一共有六个型号,他们的长宽分别为1*1, 2*2, 3*3, 4*4...他们很需要有一个好的程序帮他们解决这个问题从而节省费用。现在这个程序由你

    参考原文请点击打开链接

    题目描述

    一个工厂制造的产品形状都是长方体,它们的高度都是h,长和宽都相等,一共有六个型号,他们的长宽分别为1*1, 2*2, 3*3, 4*4, 5*5, 6*6。这些产品通常使用一个 6*6*h 的长方体包裹包装然后邮寄给客户。因为邮费很贵,所以工厂要想方设法的减小每个订单运送时的包裹数量。他们很需要有一个好的程序帮他们解决这个问题从而节省费用。现在这个程序由你来设计。


    输入

    输入文件包括几行,每一行代表一个订单。每个订单里的一行包括六个整数,中间用空格隔开,分别为1*1至6*6这六种产品的数量。输入文件将以6个0组成的一行结尾。


    输出

    除了输入的最后一行6个0以外,输入文件里每一行对应着输出文件的一行,每一行输出一个整数代表对应的订单所需的最小包裹数。


    样例输入
    0 0 4 0 0 1 
    7 5 1 0 0 0 

    0 0 0 0 0 0 


    样例输出


    思路解析:

    我们知道—— 6 * 6 、 5 * 5 、 4 * 4 以及 3 * 3 的数量除以4向上取整的数量之和是它们必须占用的箱子数量,于是我们可以预先算出这一结果。我们把 1 * 1 和 2 * 2 的盒子用于“塞缝”。对于 2 * 2 的盒子,可以“给 4 * 4 盒子塞缝”,一个4 * 4 盒子的空隙能用5个 2 * 2 盒子填满;3 * 3 盒子空隙所需要的 2 * 2 盒子个数可以用一个数组存。1 * 1 的盒子用来最后填缝。 
    若空隙已经填满了,还剩余了 1 * 1 和 2 * 2 的盒子,此时需要先处理2*2的盒子,按照9个 2 * 2 盒子装满1个箱子的规则,计算需要额外几个箱子,最后计算1 * 1 盒子。从而计算出答案。


    代码:

    public static void Souhu2()
    	{
    		Scanner in = new Scanner(System.in);
    		int a[]=new int[6];
    		while(in.hasNext())
    		{
    			int count=0;
    			for(int i=0;i<6;i++)
    			{
    				a[i]=in.nextInt();
    				if(a[i]==0)
    					count++;
    				if(count>=6)
    					return;
    			}
    			int N=0;
    			int y=0,x=0;
    			int temp[]={0,5,3,1};// temp[0]无意义,temp[i]:箱子中有i个3*3的商品时还可以放多少个2*2的箱子个数
    			N=a[5]+a[4]+a[3]+(a[2]+3)/4;//计算必须占用的箱子数量
    			y=5*a[3]+temp[a[2]%4];// 因为5*5和6*6盒子填充的箱子无法用2*2的盒子填充缝隙,
    								  //因此只需要计算4*4和3*3盒子填充的箱子理论上需要多少个2*2的盒子才能填满
    			if(a[1]>y)
    				N=N+(a[1]-y+8)/9;
    			x=36*N-36*a[5]-25*a[4]-16*a[3]-9*a[2]-4*a[1];
    			if(a[0]>x)
    				N=N+(a[0]-x+35)/36;
    			System.out.println(N);
    		}
    	}


    展开全文
  • 基于 三维装箱问题算法研究-1 的基础上 对整个装箱过程发生的函数进行封装 # -*- coding: utf-8 -*- from matplotlib import pyplot as plt #设置图表刻度等格式 from matplotlib.ticker import MultipleLocator, ...

    基于 三维装箱问题的算法研究-1 的基础上
    对整个装箱过程发生的函数进行封装

    资源下载

    # -*- coding: utf-8 -*-
    from matplotlib import pyplot as plt
    #设置图表刻度等格式
    from matplotlib.ticker import MultipleLocator, FormatStrFormatter 
    from mpl_toolkits.mplot3d import Axes3D
    import numpy as np
    
    #make_pic内置函数
    def box(ax,x, y, z, dx, dy, dz, color='red'):
        xx = [x, x, x+dx, x+dx, x]
        yy = [y, y+dy, y+dy, y, y]
        kwargs = {'alpha': 1, 'color': color}
        ax.plot3D(xx, yy, [z]*5, **kwargs)#下底
        ax.plot3D(xx, yy, [z+dz]*5, **kwargs)#上底
        ax.plot3D([x, x], [y, y], [z, z+dz], **kwargs)
        ax.plot3D([x, x], [y+dy, y+dy], [z, z+dz], **kwargs)
        ax.plot3D([x+dx, x+dx], [y+dy, y+dy], [z, z+dz], **kwargs)
        ax.plot3D([x+dx, x+dx], [y, y], [z, z+dz], **kwargs)
        return ax
    #显示图形的函数:Items = [[num[0],num[1],num[2],num[3],num[4],num[5],num[6]],]
    def make_pic(Items):
        fig = plt.figure()
        ax = Axes3D(fig)
        ax.xaxis.set_major_locator(MultipleLocator(50)) 
        ax.yaxis.set_major_locator(MultipleLocator(50)) 
        ax.zaxis.set_major_locator(MultipleLocator(50)) 
        for num in Items:
            box(ax,num[0],num[1],num[2],num[3],num[4],num[5],num[6])
        plt.title('Cube')
        plt.show()
    #把尺寸数据生成绘图数据
    def make(O,C,color):
        data = [O[0],O[1],O[2],C[0],C[1],C[2],color]
        return data
    #可用点的生成方法
    def newsite(O,B_i):
        # 在X轴方向上生成
        O1 = (O[0]+B_i[0],O[1],O[2])
        # 在Y轴方向上生成
        O2 = (O[0],O[1]+B_i[1],O[2])
        # 在Z轴方向上生成
        O3 = (O[0],O[1],O[2]+B_i[2])
        return [O1,O2,O3]
    #3.拟人化依次堆叠方体
    def packing3D(show_num,color,O,Box_list):
        canput = 0
        O_items = [O]
        O_pop = []
        for i in range(0,len(Box_list)):
            #货物次序应小于等于可用点数量,如:第四个货物i=3,使用列表内的第4个放置点O_items[3],i+1即常见意义的第几个,len即总数,可用点总数要大于等于目前个数
            if i+1 <= len(O_items):
                #如果放置点放置货物后,三个方向都不会超过箱体限制,则认为可以堆放
                if O_items[i-1][0]+Box_list[i][0]<=C[0] and O_items[i-1][1]+Box_list[i][1]<=C[1] and O_items[i-1][2]+Box_list[i][2]<=C[2]:
                    #使用放置点,添加一个图显信息
                    new_show = make(O_items[i-1],Box_list[i],color)
                    if new_show not in show_num:
                        show_num.append(make(O_items[i-1],Box_list[i],color))
                    #计数加1
                    canput = len(show_num) - 1
                    #把堆叠后产生的新的点,加入放置点列表
                    for new_O in newsite(O_items[i-1],Box_list[i]):
                        #保证放入的可用点是不重复的
                        if new_O not in O_items:
                            O_items.append(new_O)
                #如果轮到的这个放置点不可用
                else:
                    #把这个可用点弹出弃用
                    O_pop.append(O_items.pop(i-1))
                    #弃用可用点后,货物次序应小于等于剩余可用点数量
                    if i+1 <= len(O_items):# and len(O_items)-1>=0:
                        #当可用点一直不可用时
                        while O_items[i-1][0]+Box_list[i][0]>C[0] or O_items[i-1][1]+Box_list[i][1]>C[1] or O_items[i-1][2]+Box_list[i][2]>C[2]:
                            #一直把可用点弹出弃用
                            O_pop.append(O_items.pop(i-1))
                            #如果弹出后货物次序超出剩余可用点,则认为无法继续放置
                            if i-1 > len(O_items)-1:
                                break
                        #货物次序应小于等于剩余可用点数量
                        if i+1 <= len(O_items):
                            #如果不再超出限制,在这个可用点上堆叠
                            new_show = make(O_items[i-1],Box_list[i],color)
                            if new_show not in show_num:
                                show_num.append(make(O_items[i-1],Box_list[i],color))
                            #计数加1
                            canput = len(show_num) - 1
                            #把堆叠后产生的新的点,加入放置点列表
                            for new_O in newsite(O_items[i-1],Box_list[i]):
                                #保证放入的可用点是不重复的
                                if new_O not in O_items:
                                    O_items.append(new_O)
        return canput,O_items,O_pop
    #<<<---写一个函数专门用来调整方向和计算剩余货物
    def surplus(num,Box_list,change):#change='ab','bc','ac',0有三组对调可能,共6种朝向
        new_Box_list = Box_list[num-1:-1]
        if num == 0:
            new_Box_list = Box_list
        if change == 'ab':
            for i in range(0,len(new_Box_list)):
                new_Box_list[i]=(new_Box_list[i][1],new_Box_list[i][0],new_Box_list[i][2])
        elif change == 'bc':
            for i in range(0,len(new_Box_list)):
                new_Box_list[i]=(new_Box_list[i][0],new_Box_list[i][2],new_Box_list[i][1])
        elif change == 'ac':
            for i in range(0,len(new_Box_list)):
                new_Box_list[i]=(new_Box_list[i][2],new_Box_list[i][1],new_Box_list[i][0])
        elif change == 0:
            return new_Box_list
        else:
            return new_Box_list
        return new_Box_list
    #残余点二次分配函数
    def twice(show_num,color,O_pop,Box_list):
        for a2 in O_pop:
            if a2[0]==0 and a2[1]==0:
                Plan = packing3D(show_num,color,a2,Box_list)
                Box_list = surplus(Plan[0],Box_list,0)
            elif a2[1]==0 and a2[2]==0:
                Plan = packing3D(show_num,color,a2,Box_list)
                Box_list = surplus(Plan[0],Box_list,0)
            elif a2[0]==0 and a2[2]==0:
                Plan = packing3D(show_num,color,a2,Box_list)
                Box_list = surplus(Plan[0],Box_list,0)
        return Box_list
    
    

    调用这些函数进行一次初步装箱和二次转向装箱

    #1.给定空间容器C      4.2*1.9*1.8
    O = (0,0,0)           #原点坐标
    C = (420,190,180)    #箱体长宽高
    color = 'red'         #箱体颜色
    #显示箱体
    show_num = [make(O,C,color)]
    
    #2.给定有限量个方体 500个(60,40,50)的方体,当方体大小存在差异时,我们将按照体积大小降序排列,优先摆放大体积的
    B=[(40,50,60) for num in range(0,1200)]
    
    #把货物第一次装箱
    Plan1 = packing3D(show_num,'blue',(0,0,0),B)
    #print(len(show_num))
    
    #把剩下的货物分出来
    B2 = surplus(Plan1[0],B,'ab')
    
    #把剩下的货物再次尝试装箱,针对三个在轴线上的点为新的原点
    twice(show_num,'orange',Plan1[2],B2)
    print(len(show_num))
    
    make_pic(show_num)
    

    最终显示效果
    在这里插入图片描述
    可以看到在第二次发生简单转向后,
    箱体的利用率再一次得到提升,这个时候装载率达到114/箱

    那么如果全部货物1200件,1200/114向上舍入,11车能够装完

    展开全文
  • 基于二叉树与叶子链表算法思维对输入的矩形数据进行动态排版,缩进式树状打印与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

    展开全文
  • 假设区域里就只有一块食物(即通常优化问题中所讲的最优解),鸟群的任务是找到这个食物源。鸟群在整个搜寻的过程中,通过相互传递各自的信息,让其他的鸟知道自己的位置,通过这样的协作,来判断自己找到的是不是最优...
  • 有160个弹簧,20个箱子,每个箱子可以装8个弹簧,每个...第排5—8高度差不超过1mm,1-8之间的高度差不超过2mm。怎么装法最合理?160个弹簧,如果有超出这个条件的,需要返修后,再放入,怎么能做到最少的返修呢?
  • 【python】欧姆龙智能物料排布之二维装箱算法实现

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

    千次阅读 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...
  • 开始写我们的放置逻辑 所以从第个货物开始,我们就开始重复性的发生货物的堆叠 并重复性的产生新的放置点,直到放置点不再可用 #所以从我们的仓库B不断的把货物B_i搬到箱体里,限制条件为在X,Y,Z方向上可用点小于...
  • 二维下料matlab bl算法,bl.mat是主函数,可以直接运行
  • 同时在遗传迭代过程中,引入二维装箱问题的下界思想作为迭代的终止条件之一,减少了遗传算法无效迭代次数,另外根据问题自身特点,有效地降低了染色体长度,提高了整体的计算速度。在36个标准测试案例的测试基础上与...
  • 简单的二维装箱代码

    热门讨论 2012-08-01 23:51:31
    简单实现了二维装箱问题。不过仅仅是简单实现,排列7、8个矩形没问题,超过10个就要花N久了。。
  • 二维装箱问题顾名思义就是将若干个矩形物品装进矩形箱子中,并且在装箱的过程中不允许将矩形物品斜着放(PS:下图就是不允许的装箱操作),同时在装箱过程中允许将物品旋转90度放置(但是为了简单地求解问题,我们...
  • 在满足3个著名约束的条件下,该算法将三维问题转化为带有高度约束的二维问题,通过对箱子放置后的剩余空间状态分析,提出了基于概率较优的空间分割方法和箱子布置规则。相比于传统算法,3D-RSO在求解过程中不需要...
  • 一种二维装箱问题的建模方法

    千次阅读 2020-08-27 15:06:18
    模型参数 参数 说明 I I I 物件的集合 W W W 箱子的宽度 H H H 箱子的高度 w i w_i wi​ 物件 i i i 的长边 h i h_i hi​ 物件 i i i 的短边 决策变量 变量 类型 说明 p i p_i pi​ 0-1 物件 i i i 是否被装箱 x i x...
  • 现实物流活动中大量存在的易损、 易碎物品的运输问题属于带二维装箱约束的物流配送问题, 该问题二维装箱问题与车辆路径问题这两个经典难题融合之后的一个新问题....
  • 二维装箱

    千次阅读 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...
  • 问题描述We have a number of bins each with a capacity of 1, and we have a set of objects all with different sizes, s1,s2,…,sn between 0 and 1. What is the fewest number of bins that would be needed ...
  • 通过模拟人为装箱的习惯,以车柜一个角落为基点,我们放下一个物体,会在它的另外三个面继续堆叠,这个时候产生了可供堆叠的放置点,通过判断放置点的可用情况,包括添加限制条件,来实现装箱过程的计算,已经把过程...
  • 维装箱问题Java代码的简单实现过程

    万次阅读 多人点赞 2016-07-06 10:48:58
    **三维装箱问题Java代码的简单实现过程**  时间:2016年7月  作者:竹林春雨  QQ:6996899 (一) 前言 勤勤恳恳地码农了很多年,也没少在CSDN上下东西,一直没有贡献过什么,突然略感愧疚。恰好最近领导指派...

空空如也

空空如也

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

二维装箱问题算法