Unity 二叉树装箱算法

已于 2023-03-14 22:30:16 修改
阅读量984 收藏 3
点赞数
分类专栏： 算法 文章标签： unity 算法
于 2023-02-01 22:51:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34014668/article/details/128841006
版权

在这里插入图片描述
开发中碰到的需求：在滚动视图中添加不同尺寸的图片，并尽量保持紧密排列，如上图所示
在Asset Store中发现插件 Optimized ScrollView Adapter 已经实现了这个功能，这里截取其中的关键代码做演示

原理

插件使用了二叉树装箱算法（Binary Tree Bin Packing Algorithm）
在这里插入图片描述
当我们在整个区域内添加一个黄色方块后，可以把整个区域分成3个矩形：黄色矩形，矩形A，矩形B
这里有两种划分方法，一种是矩形A与黄色方块等高，一种是矩形B与黄色方块等宽，如图所示，在代码中设计一些规则来决定使用哪种划分方式
在这里插入图片描述
然后就可以构建二叉树，记录整个空间的划分，根节点Root记录第一个黄色方块的位置，大小等信息，它的两个节点分别记录右侧区域和下面区域的信息，当添加第二个方块时，检查A，B那个区域能放下，如果放在区域A下，则按照上面的方式再次划分，区域A记录第二个方块位置，大小信息，它的两个子节点记录两个新划分的区域，这样递归下去

下面是这部分算法的代码

using System;
using System.Collections.Generic;

/// <summary>
/// Heavily modified version of https://github.com/cariquitanmac/2D-Bin-Pack-Binary-Search,
/// which is a C# implementation of Jakes Gordon Binary Tree Algorithm for 2D Bin Packing https://github.com/jakesgordon/bin-packing/
/// <para>All rights go to the original author.</para>
/// </summary>
public class Packer2DBox
{
	List<Box> _Boxes;
	Node _RootNode;
	double _Spacing;
	bool _AlternatingStrategyBiggerRightNode;
	bool _AlternatingOtherStrategyBiggerRightNode;
	double _ContainerWidth;
	double _ContainerHeight;
	// 分割节点时的策略
	NodeChoosingStrategy _ChoosingStrategy;

	public Packer2DBox(double containerWidth, double containerHeight, double spacing)
	{
		this._ContainerWidth = containerWidth;
		this._ContainerHeight = containerHeight;
		this._Spacing = spacing;
	}

	public void Pack(List<Box> boxes, bool sort, NodeChoosingStrategy choosingStrategy, out double totalWidth, out double totalHeight)
	{
		_ChoosingStrategy = choosingStrategy;

		_AlternatingStrategyBiggerRightNode = _ChoosingStrategy == NodeChoosingStrategy.ALTERNATING_START_WITH_RIGHT;

		_RootNode = new Node(0d, 0d) { height = _ContainerHeight, width = _ContainerWidth };
		_Boxes = boxes;
		if (sort)
		{
			// Biggest boxes first with maxside, then secondarily by volume 
			// More info: https://codeincomplete.com/posts/bin-packing/
			_Boxes.Sort((a, b) =>
			{
				var aMax = System.Math.Max(a.width, a.height);
				var bMax = System.Math.Max(b.width, b.height);

				if (aMax != bMax)
					return (int)(bMax - aMax);

				return (int)(b.volume - a.volume);
			});
		}

		totalWidth = 0f;
		totalHeight = 0f;
		foreach (var box in _Boxes)
		{
			Node node = null;
			FindNode(_RootNode, box.width, box.height, ref node);

			if (node != null)
			{
				// Split rectangles
				box.position = SplitNode(node, box.width, box.height);

				double width = box.position.x + box.width;
				if (width > totalWidth)
					totalWidth = width;

				double height = box.position.y + box.height;
				if (height > totalHeight)
					totalHeight = height;
			}
		}
	}

	void FindNode(Node rootNode, double boxWidth, double boxHeight, ref Node node)
	{
		if (rootNode.isOccupied)
		{
			FindNode(rootNode.rightNode, boxWidth, boxHeight, ref node);
			FindNode(rootNode.bottomNode, boxWidth, boxHeight, ref node);
		}
		else if (boxWidth <= rootNode.width && boxHeight <= rootNode.height)
		{
			 if (node == null || rootNode.distFromOrigin < node.distFromOrigin)
				node = rootNode;
		}
	}

	/// <summary>
	/// 分割节点，有两种分割方法，按策略选择
	/// 方法1.右侧节点与填入的box一样高
	/// 方法2.下面节点与填入的box一样宽
	/// </summary>
	Node SplitNode(Node node, double boxWidth, double boxHeight)
	{
		node.isOccupied = true;

		double rightNodeFullWidth = node.width - (boxWidth + _Spacing);
		double rightNodeFullHeight = node.height;

		double bottomNodeFullWidth = node.width;
		double bottomNodeFullHeight = node.height - (boxHeight + _Spacing);

		bool biggerRightNode;

		var localStrategy = _ChoosingStrategy;
		if (localStrategy == NodeChoosingStrategy.MAX_VOLUME)
		{
			// 比较box面积，如果分割后右侧节点的面积更大，就按照方法1分割
			double rightVolume = rightNodeFullWidth * rightNodeFullHeight;
			double bottomVolume = bottomNodeFullWidth * bottomNodeFullHeight;

			if (rightVolume == bottomVolume)
			{
				// In case of equality, alternate between what we chose the last time
				biggerRightNode = _AlternatingOtherStrategyBiggerRightNode;
				_AlternatingOtherStrategyBiggerRightNode = !_AlternatingOtherStrategyBiggerRightNode;
			}
			else
			{
				biggerRightNode = rightVolume > bottomVolume;
			}
		}
		else if (localStrategy == NodeChoosingStrategy.MAX_SIDE)
		{
			// 比较两个节点的最大边长，边长大的优先
			double rightMaxSide = Math.Max(rightNodeFullWidth, rightNodeFullHeight);
			double bottomMaxSide = Math.Max(bottomNodeFullWidth, bottomNodeFullHeight);

			if (rightMaxSide == bottomMaxSide)
			{
				// In case of equality, alternate between what we chose the last time
				biggerRightNode = _AlternatingOtherStrategyBiggerRightNode;
				_AlternatingOtherStrategyBiggerRightNode = !_AlternatingOtherStrategyBiggerRightNode;
			}
			else
			{
				biggerRightNode = rightMaxSide > bottomMaxSide;
			}
		}
		else if (localStrategy == NodeChoosingStrategy.MAX_SUM)
		{
			// 比较两个节点的边长和，结果大的优先
			double rightSum = rightNodeFullWidth + rightNodeFullHeight;
			double bottomSum = bottomNodeFullWidth + bottomNodeFullHeight;

			if (rightSum == bottomSum)
			{
				// In case of equality, alternate between what we chose the last time
				biggerRightNode = _AlternatingOtherStrategyBiggerRightNode;
				_AlternatingOtherStrategyBiggerRightNode = !_AlternatingOtherStrategyBiggerRightNode;
			}
			else
			{
				biggerRightNode = rightSum > bottomSum;
			}
		}
		else
		{
			if (_ChoosingStrategy == NodeChoosingStrategy.RIGHT)
				biggerRightNode = true;
			else if (_ChoosingStrategy == NodeChoosingStrategy.BOTTOM)
				biggerRightNode = false;
			else
			{
				// Alternating
				biggerRightNode = _AlternatingStrategyBiggerRightNode;
				_AlternatingStrategyBiggerRightNode = !_AlternatingStrategyBiggerRightNode;
			}
		}

		node.rightNode = new Node(node.x + (boxWidth + _Spacing), node.y)
		{
			depth = node.depth + 1,
			width = rightNodeFullWidth,
			height = biggerRightNode ? node.height : boxHeight
		};
		node.bottomNode = new Node(node.x, node.y + (boxHeight + _Spacing))
		{
			depth = node.depth + 1,
			width = biggerRightNode ? boxWidth : node.width,
			height = bottomNodeFullHeight
		};

		return node;
	}
	
	public class Node
	{
		public int depth;
		public Node rightNode;
		public Node bottomNode;
		// 节点左上角坐标
		public double x;
		public double y;
		public double width;
		public double height;
		readonly public double distFromOrigin;
		// 节点被占用，也就是被分割了
		public bool isOccupied;
		
		public Node(double x, double y)
		{
			this.x = x;
			this.y = y;
			distFromOrigin = Math.Sqrt(x * x + y * y);
		}
	}
	
	public class Box
	{
		public double height;
		public double width;
		public double volume;
		public Node position;
		
		public Box(double width, double height)
		{
			this.width = width;
			this.height = height;
			volume = width * height;
		}
	}
	
	/// <summary>Note expanding choices, in order of success rate</summary>
	public enum NodeChoosingStrategy
	{
		MAX_VOLUME,
		MAX_SUM,
		MAX_SIDE,
		ALTERNATING_START_WITH_BOTTOM,
		RIGHT,
		BOTTOM,
		ALTERNATING_START_WITH_RIGHT, // same as BOTTOM, in 99% of cases
		COUNT_
	}
}

作者设计了几种划分空间的策略，如根据区域面积，边长和，最大边长等

还需要一个布局脚本管理所有的子节点

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// Layout class to arrange children elements in a circular grid format. Circular in the . Items will try to occupy as much space as possible.
/// </summary>
public class PackedGridLayoutGroup : LayoutGroup
{
	[SerializeField] protected float m_ForcedSpacing = 0f;

	[Tooltip("The specified axis will have the 'Preferred' size set based on children")]
	[SerializeField] protected AxisOrNone m_childrenControlSize = AxisOrNone.Vertical;

	/// <summary>
	/// 执行每个策略算一个pass，然后对比不同策略的空间填充率，填充率要求不高设置为1就行
	/// </summary>
	[Tooltip("Set to as many as possible, if the FPS allows")]
	[Range(1, (int)Packer2DBox.NodeChoosingStrategy.COUNT_)]
	[SerializeField] protected int m_numPasses = (int)Packer2DBox.NodeChoosingStrategy.COUNT_;

	/// <summary>
	/// The spacing to use between layout elements in the grid on both axes. 
	/// The spacing is created by shrinking the childrens' sizes rather than actually adding spaces.
	/// If you want true spacing, consider modifying the children themselves to also include some padding inside them
	/// </summary>
	public float ForcedSpacing { get { return m_ForcedSpacing; } set { SetProperty(ref m_ForcedSpacing, value); } }

	/// <summary>
	/// The specified axis will have the 'Preferred' size set based on children
	/// </summary>
	public AxisOrNone ChildrenControlSize { get { return m_childrenControlSize; } set { SetProperty(ref m_childrenControlSize, value); } }

	protected PackedGridLayoutGroup() { }

#if UNITY_EDITOR
	protected override void OnValidate()
	{
		base.OnValidate();
	}
#endif
	
	public override void CalculateLayoutInputHorizontal()
	{
		base.CalculateLayoutInputHorizontal();

		float minWidthToSet;
		float preferredWidthToSet;
		if (m_childrenControlSize == AxisOrNone.Horizontal)
		{
			float width, _;
			GetChildSetups(out width, out _);

			minWidthToSet = preferredWidthToSet = width + padding.horizontal;
		}
		else
		{
			minWidthToSet = minWidth;
			preferredWidthToSet = preferredWidth;
		}

		SetLayoutInputForAxis(minWidthToSet, preferredWidthToSet, -1, 0);
	}

	public override void CalculateLayoutInputVertical()
	{
		float minHeightToSet;
		float preferredHeightToSet;
		if (m_childrenControlSize == AxisOrNone.Vertical)
		{
			float _, height;
			GetChildSetups(out _, out height);

			minHeightToSet = preferredHeightToSet = height + padding.vertical;
		}
		else
		{
			minHeightToSet = minHeight;
			preferredHeightToSet = preferredHeight;
		}

		SetLayoutInputForAxis(minHeightToSet, preferredHeightToSet, -1, 1);
	}

	public override void SetLayoutHorizontal()
	{
		LayoutChildren(true, false);
	}

	public override void SetLayoutVertical()
	{
		LayoutChildren(false, true);
	}
	
	void GetInsetAndEdges(float chWidth, float chHeight, out RectTransform.Edge xInsetEdge, out RectTransform.Edge yInsetEdge, out float xAddInset, out float yAddInset)
	{
		var gridRect = rectTransform.rect;

		xInsetEdge = RectTransform.Edge.Left;
		yInsetEdge = RectTransform.Edge.Top;
		xAddInset = 0f;
		yAddInset = 0f;
		if (m_childrenControlSize != AxisOrNone.Horizontal)
		{
			switch (childAlignment)
			{
				case TextAnchor.UpperLeft:
				case TextAnchor.LowerLeft:
				case TextAnchor.MiddleLeft:
					xInsetEdge = RectTransform.Edge.Left;
					xAddInset = padding.left;
					break;

				case TextAnchor.UpperRight:
				case TextAnchor.LowerRight:
				case TextAnchor.MiddleRight:
					xInsetEdge = RectTransform.Edge.Right;
					xAddInset = padding.right;
					break;

				case TextAnchor.UpperCenter:
				case TextAnchor.MiddleCenter:
				case TextAnchor.LowerCenter:
					xAddInset = Mathf.Max((gridRect.width - chWidth), padding.horizontal) / 2f;
					break;
			}
		}

		if (m_childrenControlSize != AxisOrNone.Vertical)
		{
			switch (childAlignment)
			{
				case TextAnchor.UpperLeft:
				case TextAnchor.UpperCenter:
				case TextAnchor.UpperRight:
					yInsetEdge = RectTransform.Edge.Top;
					yAddInset = padding.top;
					break;

				case TextAnchor.LowerLeft:
				case TextAnchor.LowerCenter:
				case TextAnchor.LowerRight:
					yInsetEdge = RectTransform.Edge.Bottom;
					yAddInset = padding.bottom;
					break;

				case TextAnchor.MiddleLeft:
				case TextAnchor.MiddleCenter:
				case TextAnchor.MiddleRight:
					yAddInset = Mathf.Max((gridRect.height - chHeight), padding.vertical) / 2f;
					break;
			}
		}
	}

	void LayoutChildren(bool hor, bool vert)
	{
		float chWidth, chHeight;
		var setups = GetChildSetups(out chWidth, out chHeight);

		RectTransform.Edge xInsetEdge, yInsetEdge;
		float xAddInset, yAddInset;
		GetInsetAndEdges(chWidth, chHeight, out xInsetEdge, out yInsetEdge, out xAddInset, out yAddInset);

		foreach (var child in setups)
		{
			var c = child as ChildSetup;
			if (c.box.position == null)
				continue;

			if (hor)
				c.child.SetInsetAndSizeFromParentEdge(xInsetEdge, (float)c.box.position.x + xAddInset, (float)c.box.width - ForcedSpacing);

			if (vert)
				c.child.SetInsetAndSizeFromParentEdge(yInsetEdge, (float)c.box.position.y + yAddInset, (float)c.box.height - ForcedSpacing);
		}
	}

	List<ChildSetup> GetChildSetups(out float width, out float height)
	{
		var list = new List<ChildSetup>(rectChildren.Count);
		foreach (var child in rectChildren)
		{
			float chWidth = LayoutUtility.GetPreferredSize(child, 0);
			float chHeight = LayoutUtility.GetPreferredSize(child, 1);
			list.Add(new ChildSetup(chWidth, chHeight, child));
		}

		float availableWidth, availableHeight;
		if (m_childrenControlSize == AxisOrNone.Horizontal)
		{
			availableWidth = float.MaxValue;
			availableHeight = rectTransform.rect.height - padding.vertical;
		}
		else if (m_childrenControlSize == AxisOrNone.Vertical)
		{
			availableWidth = rectTransform.rect.width - padding.horizontal;
			availableHeight = float.MaxValue;
		}
		else
		{
			availableHeight = rectTransform.rect.height - padding.vertical;
			availableWidth = rectTransform.rect.width - padding.horizontal;
		}
		
		// Spacing usually creates mode big empty spaces where no item can fit
		float spacingToUse = 0f;
		var packer = new Packer2DBox(availableWidth, availableHeight, spacingToUse);

		int maxStrategiesToUse = m_numPasses;
		List<Packer2DBox.Box>[] boxesPerStrategy = new List<Packer2DBox.Box>[maxStrategiesToUse];
		int[] nullPositionsPerStrategy = new int[maxStrategiesToUse];
		double[] totalWidthsPerStrategy = new double[maxStrategiesToUse];
		double[] totalHeightsPerStrategy = new double[maxStrategiesToUse];

		int iBest = -1;
		bool copyBoxesForFinalResult = maxStrategiesToUse > 1;
		for (int i = 0; i < maxStrategiesToUse; i++)
		{
			var boxesThisPass = i == 0 ? list.ConvertAll(c => c.box) : list.ConvertAll(c => { c.ReinitBox(); return c.box; });
			double totalWidthThisPass;
			double totalHeightThisPass;
			packer.Pack(boxesThisPass, false, (Packer2DBox.NodeChoosingStrategy)i, out totalWidthThisPass, out totalHeightThisPass);
			int thisPassNullPositions = 0;
			for (int j = 0; j < boxesThisPass.Count; j++)
			{
				var b = boxesThisPass[j];
				if (b.position == null)
					++thisPassNullPositions;
			}

			boxesPerStrategy[i] = boxesThisPass;
			nullPositionsPerStrategy[i] = thisPassNullPositions;
			totalWidthsPerStrategy[i] = totalWidthThisPass;
			totalHeightsPerStrategy[i] = totalHeightThisPass;

			if (iBest == -1)
			{
				iBest = i;

				if (thisPassNullPositions == 0)
				{
					// Boxes won't be overridden by next strategies, so no need to copy them
					copyBoxesForFinalResult = false;

					// First pass is Packer2DBox.NodeChoosingStrategy.MAX_VOLUME and all boxes were fit => there's no better strategy
					break;
				}

				continue;
			}

			if (thisPassNullPositions < nullPositionsPerStrategy[iBest])
			{
				iBest = i;
				continue;
			}

			if (thisPassNullPositions > nullPositionsPerStrategy[iBest])
				continue;

			if (totalWidthThisPass * totalHeightThisPass < totalWidthsPerStrategy[i] * totalHeightsPerStrategy[i])
			{
				iBest = i;
				continue;
			}
		}

		if (copyBoxesForFinalResult)
		{
			var bestBoxes = boxesPerStrategy[iBest];
			for (int i = 0; i < list.Count; i++)
				list[i].box = bestBoxes[i];
		}

		width = (float)totalWidthsPerStrategy[iBest];
		height = (float)totalHeightsPerStrategy[iBest];

		return list;
	}
	
	public enum AxisOrNone
	{
		Horizontal = RectTransform.Axis.Horizontal,
		Vertical = RectTransform.Axis.Vertical,
		None
	}
	
	class ChildSetup
	{
		public RectTransform child;
		public Packer2DBox.Box box;
		
		public ChildSetup(double width, double height, RectTransform child)
		{
			this.child = child;

			box = new Packer2DBox.Box(width, height);
		}
		
		public void ReinitBox() { box = new Packer2DBox.Box(box.width, box.height); }
	}
}

实现

在这里插入图片描述
新建一个Scroll View，在Content节点上添加布局脚本，注意Content的区域大小需要根据所有子节点占用宽高做调整，布局脚本PackedGridLayoutGroup 中的 GetChildSetups 方法可以计算填充后所有子对象占用的高度和宽度
Forced Spacing 控制子对象的间距，它是通过缩小子对象的宽高实现的
Num Passes 执行每个分割策略算一个pass，然后对比不同策略的空间填充率，填充率要求不高设置为1就行

在这里插入图片描述
Image作为模板，添加Layout Element组件，使用Preferred Width和Preferred Height控制宽高

using UnityEngine;
using UnityEngine.UI;
using Random = UnityEngine.Random;

public class PackDemo : MonoBehaviour
{
    public Image template;
    // Scroll View 下的content节点
    public Transform content;
    // 生成数量
    public int generateCount;

    private int lastCount;
    
    void Start()
    {
        lastCount = generateCount;
        GenerateCell();
    }

    void Update()
    {
        if (generateCount != lastCount)
        {
            lastCount = generateCount;
            GenerateCell();
        }
    }

    private void GenerateCell()
    {
        for (int i = 0; i < content.childCount; ++i)
        {
            var tf = content.GetChild(i);
            DestroyImmediate(tf.gameObject);
        }
        
        for (int i = 0; i < generateCount; ++i)
        {
            var go = Instantiate(template, content);
            go.gameObject.SetActive(true);
            go.color = new Color(Random.Range(0, 1f), Random.Range(0, 1f), Random.Range(0, 1f));
            var layout = go.GetComponent<LayoutElement>();
            layout.preferredWidth = Random.Range(1, 5) * 100;
            layout.preferredHeight = Random.Range(1, 5) * 100;
        }
    }
}

这里写了一个简单的脚本进行测试，会在Content节点下生成一定数量的Image，并随机颜色和大小

运行效果
在这里插入图片描述

优化

在脚本 PackedGridLayoutGroup 的 GetChildSetups 方法中会比较不同分割策略并选出最好的一个策略，但是一般情况下使用第一个面积分割策略就可以了，这里简化了源码来减少new对象

	public List<ChildSetup> GetChildSetups(out float width, out float height)
	{
		var list = new List<ChildSetup>(rectChildren.Count);
		foreach (var child in rectChildren)
		{
			float chWidth = LayoutUtility.GetPreferredSize(child, 0);
			float chHeight = LayoutUtility.GetPreferredSize(child, 1);
			list.Add(new ChildSetup(chWidth, chHeight, child));
		}

		float availableWidth, availableHeight;
		if (m_childrenControlSize == AxisOrNone.Horizontal)
		{
			availableWidth = float.MaxValue;
			availableHeight = rectTransform.rect.height - padding.vertical;
		}
		else if (m_childrenControlSize == AxisOrNone.Vertical)
		{
			availableWidth = rectTransform.rect.width - padding.horizontal;
			availableHeight = float.MaxValue;
		}
		else
		{
			availableHeight = rectTransform.rect.height - padding.vertical;
			availableWidth = rectTransform.rect.width - padding.horizontal;
		}
		
		// Spacing usually creates mode big empty spaces where no item can fit
		float spacingToUse = 0f;
		var packer = new Packer2DBox(availableWidth, availableHeight, spacingToUse);
		
		# region 修改部分，这里简化源码，只使用 MAX_VOLUME 策略，减少new对象
		var boxesThisPass = list.ConvertAll(c => c.box);
		packer.Pack(boxesThisPass, false, Packer2DBox.NodeChoosingStrategy.MAX_VOLUME, out var totalWidthThisPass, out var totalHeightThisPass);
		width = (float)totalWidthThisPass;
		height = (float)totalHeightThisPass;
		#endregion

		return list;
	}
北海6516
关注
专栏目录
Unity 面试篇|（六）数据结构和算法篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-20 5万+
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样遍历完后，堆中的10000个数就是所需的最大的10000个。桶排序是计数排序的升级版。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出1000*10000中的最终的结果。
Unity 面试篇⚠️ | 数据结构和算法篇，灵魂之汁，浇给~
m0_58523831的博客
06-10 1万+
Unity 面试篇⚠️ | 数据结构和算法篇，灵魂之汁，浇给~
【Opengl C++】基于二叉树与叶子链表的二维矩形装箱算法
ColorGalaxy
02-21 2392
Github获取源码：https://github.com/ColorGalaxy/Bin-Paking-Algorithm 基于二叉树与叶子链表算法思维对输入的矩形数据进行动态排版，缩进式树状打印与Opengl绘制显示排版结果。 实现了将全部的矩形紧凑封装在一个近似正方形的空间中，提高了空间利用率，能达到90%以上，减少了内存资源的浪费。 配置： 简单的使用了Glut库进行Opengl绘制...
二维矩形装箱算法之二叉树
热门推荐
lzhf1122的博客
03-21 1万+
我们要解决两个问题：1.如何将所有二维矩形块放入一个矩形框内。2.在满足问题1的情况下，矩形框的最小宽度和高度是多少。期望的效果图： 下面我们就来解决以上问题。1. 把矩形块放在固定大小的框内假设有一个固定大小的矩形框，比如1024x768，我们怎么把矩形块装在里面？答案：使用二叉树。首先在左上角放置第一个（最大的）块，然后将该矩形框剩余的空白区域分割成两个较小的矩形。以二叉树的形式递归地进行处理...
【算法】装箱问题
最新发布
wnm23的专栏
08-05 1453
Bin-Packing算法是解决资源优化分配问题的算法，旨在将多个物品有效地装入有限数量的容器中，以减少使用的容器数量。常见的算法包括First Fit、Next Fit、Best Fit等，它们通过不同的策略来实现物品的装箱，如按顺序放入第一个适合的容器或选择剩余空间最小的容器。这类算法在计算机科学、物流和生产制造等领域有广泛应用，能够提高资源利用率和操作效率。
二维矩形装箱算法--二叉树--java实现
03-22
多个车子，N个箱子，用二维矩形方式进行装车。采用二叉树实现。java
php箱子,PHP实现的装箱算法示例
weixin_35816790的博客
03-10 381
本文实例讲述了PHP实现的装箱算法。分享给大家供大家参考，具体如下：贪婪法是一种不追求最优解，只希望得到较为满意解的方法。贪婪法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪婪法不要回溯。例如平时购物找钱时，为使找回的零钱的硬币数最少，不考虑找零钱的所有各种发表方案，而是从最大面值的币种开始...
unity二叉树_在shader内实现二叉树
weixin_29790467的博客
01-14 306
研究动机由于某种原因 ，参与的超大场景项目放弃了unity自带的烘焙。单讨论平行光阴影来说 lightmask，和lightprobe都没有。所以远处的阴影内物体会变亮，这逻辑上正常因为再也没有描述遮挡关系的信息了。解决方案一般是三种实时阴影设置很远比如2000米，然后分7个级联，第一帧渲染1234，第二帧渲染1235，然后1236，1237，1234.听说原神是这样处理。静态shadowmap....
Python 二叉树算法解决二维装箱问题 (2d bin-packing problem)
axelboss的博客
12-08 2176
Python 二叉树算法尝试解决二维装箱问题
Unity游戏开发客户端面经——数据结构（初级）
Sea3752的博客
10-25 9434
Unity游戏开发客户端面经 之 数据结构篇
unity算法面试_Unity面试准备
weixin_39788703的博客
12-22 230
前言为Unity面试而准备一些问题，如果有什么说的不对的，欢迎指正语言机制类1、GC机制在C/C++中程序员要自己负责系统的内存管理，而C#采用Garbage Collection自动回收内存，当Java虚拟机(VM)或.NETCLR发觉内存资源紧张的时候，就会自动地去清理无用对象(没有被引用到的对象)所占用的内存空间，查找没有被引用的对象有一系列的算法，Lua语言的GC机制采用是Mark and...
集装箱的装箱问题（c语言算法）
09-26
贪心算法的思想---集装箱的装箱问题（c语言算法）
bin-packing-algorithms
04-02
装箱算法
集装箱优化算法设计
05-11
集装箱优化算法设计文档 利用集装箱运输货物的方式是一种方便又灵活的运输措施。现在已被众多的货主所采用，他可以在最大限度上减少运输过程中造成的货损。集装箱船配载方案的优劣直接关系到船舶和货物的安全，在众多的可行性配载方案中，寻求一种相对最优的配载方案一直是配载人员追求的目标。 集装箱优化设计的要求是在给定集装箱的尺寸后，在该空间内放入长方形，正方形，实现这三种形状货物的最大限度的摆放，从而使集装箱的剩余空间最小。这种开发主要运用在一些为装运和运输计算最优化的装载，计算最大限度的装载空间，从而节省时间和在运输上的费用以致节省成本。 本设计是一个简单的模拟测试软件，通过编写来分析计算各种形状的货物在集装箱中堆放方式所占用的空间，从中找到最优化的摆放方式，提高集装箱配载率，降低货物运输环节的费用，提高企业的核心竞争力，最终达到最大利润。
关于装箱问题的算法研究
Tekim的博客
04-15 5113
装箱问题的算法研究 山东大学 赵一帆 问题描述 在箱子装载问题中，有若干个容量为c的箱子和n个待装载入箱子中的物品。物品i需占s[i]个单元（0<s[i]≤c）。所谓成功装载（feasible packing），是指能把所有物品都装入箱子而不溢出，而最优装载（optimal packing）则是指使用了最少箱子的成功装载。 问题分析 这道题目是算法课设发给我要求完成的题目，给了四种基本的算法，再加上avl树和竞赛树优化（竞赛树那部分我写的还是有点满意），后续我感觉可以用模拟退火来做一下，所以就搜集资料
Unity C#二叉排序树的原理及泛型写法详解（图文）
cube454517408的专栏
07-14 1067
目录 1.简介 2.性质 3.泛型声明 4.树的结构 5.查找 6.插入 7.遍历 8.删除 9.示例 1.简介 二叉排序树：顾名思义它是一颗具有一定访问顺序的二叉树，通过中序遍历可以得到一个有序的序列 2.性质 一颗二叉排序树可以是空树，当它是非空树时具有以下特性： 1）当它的左子树不为空时，所有左子节点的值均小于根节点的值 2）当它的右子树不为空时，所有右子节点的值均大于根节点的值 3）它的左右子树均为二叉排序树 3.泛型声明 泛型数据需实现IComparerSear
装箱算法实验
weixin_30364147的博客
03-09 138
源代下载：下载 欢迎大家讨论交流 1. 参考文献：http://zhidao.baidu.com/question/31400053.htmlhttp://baike.baidu.com/view/158424.htm 2. 测试数据：物品参数：100, 150, 350, 450, 130, 480, 500, 160, 460, 20, 10, 250, 72, 168, 3...
unity（C#）实现二叉树（2）
weixin_51481499的博客
12-27 1046
功能实现： //直接复制（可用） using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public class BST2<Key, Value> where Key : IComparable<Key> { private class Node { public Key key; public V
Unity3D游戏开发算法：贪婪法与装箱问题解析
"Unity3D教程：游戏开发算法（三）2" 本文主要讲解了在Unity3D游戏开发中，如何运用算法来优化游戏设计。在本教程的第三部分，作者聚焦于贪婪法这一策略，这是一种在游戏开发中寻找近似最优解的高效方法。 贪婪法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值