deastern/lead
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增二维装箱问题

Browse Source
This commit is contained in:
yangyudong
2025-05-13 15:48:25 +08:00
parent 805e99b8a1
commit f96c9c56c7
7 changed files with 558 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/lead/problems/bp/dataset/data_loader.py Normal file
View File

@@ -0,0 +1,42 @@
import numpy as np
import random
from typing import List, Tuple, Dict
def generate_dataset(num_items: int, container_size: Tuple[int, int], seed: int = 2025) -> Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]:
"""
生成二维装箱问题的数据集
Args:
num_items: 物品数量
container_size: 容器的宽度和高度
seed: 随机种子，默认为2025
Returns:
Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]: 包含物品列表和容器尺寸的字典
"""
random.seed(seed)
np.random.seed(seed)
items = []
for _ in range(num_items):
width = random.randint(1, container_size[0] // 2)
height = random.randint(1, container_size[1] // 2)
items.append((width, height))
return {"data": (items, container_size)}
class ProblemDataLoader:
def __init__(self, problem_path: str):
self.problem_path = problem_path
def get_data(self) -> Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]:
"""
加载二维装箱问题的数据集
Returns:
Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]: 包含物品列表和容器尺寸的字典
"""
# 使用固定随机种子生成数据集
num_items = 10
container_size = (100, 100)
return generate_dataset(num_items, container_size, seed=2025)

100
src/lead/problems/bp/evaluation.py Normal file
View File

@@ -0,0 +1,100 @@
import numpy as np
import time
from typing import Callable, Dict, List, Tuple
def evaluate(packing_func: Callable[[Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]], List[Dict[str, int]]],
input_data: Dict[str, Tuple[List[Tuple[int, int]], Tuple[int, int]]]) -> Dict[str, float]:
"""评估二维装箱算法的多目标性能
Args:
packing_func: 装箱算法函数
input_data: 一个字典，包含两个部分:
- 'data': 一个元组，包含物品列表和容器尺寸
Returns:
Dict[str, float]: 包含两个目标值的字典:
- utilization_rate: 容器的利用率
- execution_time: 运行时间(秒)
如果解不合法(物品超出容器边界或重叠)则返回无穷大
"""
try:
# 解包输入数据
items, container = input_data["data"]
# 计时并执行装箱算法
start_time = time.time()
packing_result = packing_func(input_data)
print(f"[DEBUG] Packing result: {packing_result}")
end_time = time.time()
execution_time = end_time - start_time
# 检查解的合法性
container_width, container_height = container
occupied_area = 0
# 尝试标准化 packing_result 的结构
standardized_result = []
for placement in packing_result:
if isinstance(placement, tuple) and len(placement) >= 3:
x, y, rotated = placement[:3]
standardized_result.append({"x": x, "y": y, "rotated": rotated})
elif isinstance(placement, dict):
standardized_result.append(placement)
else:
print(f"[ERROR] Invalid packing_result structure: {packing_result}")
return {
"utilization_rate": float('inf'),
"execution_time": float('inf')
}
packing_result = standardized_result
for item, placement in zip(items, packing_result):
item_width, item_height = item
x, y, rotated = placement["x"], placement["y"], placement["rotated"]
if rotated:
item_width, item_height = item_height, item_width
# 检查是否超出容器边界
if x + item_width > container_width or y + item_height > container_height:
print(f"非法解:物品超出容器边界")
return {
"utilization_rate": float('inf'),
"execution_time": float('inf')
}
# 检查是否重叠
for other_item, other_placement in zip(items, packing_result):
if placement == other_placement:
continue
other_x, other_y, other_rotated = other_placement["x"], other_placement["y"], other_placement["rotated"]
other_width, other_height = other_item
if other_rotated:
other_width, other_height = other_height, other_width
if not (x + item_width <= other_x or other_x + other_width <= x or
y + item_height <= other_y or other_y + other_height <= y):
print(f"非法解:物品重叠")
return {
"utilization_rate": float('inf'),
"execution_time": float('inf')
}
occupied_area += item_width * item_height
# 计算容器利用率
vacancy_rate = 1 - (occupied_area / (container_width * container_height))
print(f"执行时间:{execution_time:.4f}秒, 容器空置率:{vacancy_rate:.4f}")
return {
"vacancy_rate": vacancy_rate,
"execution_time": execution_time
}
except Exception as e:
print(f"评估过程出错: {str(e)}")
return {
"utilization_rate": float('inf'),
"execution_time": float('inf')
}

1
src/lead/problems/bp/multi_objective_evolution.log Normal file
View File

@@ -0,0 +1 @@
Generation 0000 | Pareto Front Size: 12 | Timestamp: 2025-05-13T15:44:39.489046

275
src/lead/problems/bp/multi_objective_history/20250513_151843/generation_0.json Normal file
View File

@@ -0,0 +1,275 @@
{
"generation": 0,
"population": [
{
"code": "def solve_bp(data):\n def rectangle_area(rect):\n return rect[0] * rect[1]\n\n def can_place(rect, x, y, occupied):\n width, height = rect\n for ox, oy, owidth, oheight in occupied:\n if not (x + width <= ox or x >= ox + owidth or y + height <= oy or y >= oy + oheight):\n return False\n return True\n\n def find_position(rect, occupied, container_width, container_height):\n width, height = rect\n for y in range(container_height - height + 1):\n for x in range(container_width - width + 1):\n if can_place(rect, x, y, occupied):\n return x, y\n return None\n\n items, (container_width, container_height) = data['data']\n items_with_info = []\n for idx, (w, h) in enumerate(items):\n area = w * h\n items_with_info.append({'index': idx, 'w': w, 'h': h, 'area': area})\n\n items_with_info.sort(key=lambda x: x['area'], reverse=True)\n\n placed_items = []\n occupied = []\n\n for item in items_with_info:\n w, h = item['w'], item['h']\n position = find_position((w, h), occupied, container_width, container_height)\n rotated = False\n if position:\n x, y = position\n else:\n w_rot, h_rot = h, w\n position = find_position((w_rot, h_rot), occupied, container_width, container_height)\n if position:\n x, y = position\n w, h = w_rot, h_rot\n rotated = True\n else:\n continue\n placed_items.append({\n 'index': item['index'],\n 'x': x,\n 'y': y,\n 'rotated': rotated,\n 'width': w,\n 'height': h\n })\n occupied.append((x, y, w, h))\n\n result = [None] * len(items)\n for p in placed_items:\n idx = p['index']\n result[idx] = {\n 'x': p['x'],\n 'y': p['y'],\n 'rotated': p['rotated']\n }\n return result",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "使用贪心策略逐个放置最大面积物品到剩余空间中"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n\n def fit_items(placed_items, remaining_items):\n if not remaining_items:\n return True\n \n item = remaining_items[0]\n width, height = item\n for rotated in [False, True]:\n if rotated:\n width, height = height, width\n \n for x in range(container_width - width + 1):\n for y in range(container_height - height + 1):\n if can_place(placed_items, (x, y, width, height)):\n placed_items.append({'x': x, 'y': y, 'rotated': rotated})\n if fit_items(placed_items, remaining_items[1:]):\n return True\n placed_items.pop()\n\n return False\n\n def can_place(placed_items, new_item):\n new_x, new_y, new_w, new_h = new_item\n for item in placed_items:\n item_x = item['x']\n item_y = item['y']\n item_w = item['rotated'] and item['height'] or item['width']\n item_h = item['rotated'] and item['width'] or item['height']\n\n if not (new_x + new_w <= item_x or new_x >= item_x + item_w or \n new_y + new_h <= item_y or new_y >= item_y + item_h):\n return False\n return True\n\n fit_items([], items)\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用分支限界法搜索所有可能的布局以找到最优解"
}
},
{
"code": "import random\n\ndef solve_bp(input_dict):\n items, (W, H) = input_dict['data']\n\n POPSIZE = 50\n GENERATIONS = 150\n MUTATION_RATE = 0.2\n TOURNAMENT_SIZE = 5\n\n def create_individual():\n order = list(range(len(items)))\n random.shuffle(order)\n rotates = [random.choice([False, True]) for _ in items]\n return (order, rotates)\n\n def rect_fits(x, y, w, h):\n return 0 <= x <= W - w and 0 <= y <= H - h\n\n def overlap(r1, r2):\n x1, y1, w1, h1 = r1\n x2, y2, w2, h2 = r2\n return not (x1 + w1 <= x2 or x2 + w2 <= x1 or y1 + h1 <= y2 or y2 + h2 <= y1)\n\n def place_items(order, rotates):\n placed = []\n taken_area = 0\n for idx in order:\n w, h = items[idx]\n if rotates[idx]:\n w, h = h, w\n pos = try_place(w, h, placed)\n if pos is None:\n return None, 0\n x, y = pos\n placed.append((x, y, w, h))\n taken_area += w * h\n return placed, taken_area\n\n def try_place(w, h, placed):\n STEP = 5\n for y in range(0, H - h + 1, STEP):\n for x in range(0, W - w + 1, STEP):\n r = (x, y, w, h)\n if all(not overlap(r, p) for p in placed):\n return (x, y)\n return None\n\n def fitness(ind):\n placed, area = place_items(ind[0], ind[1])\n return area / (W * H), placed\n\n def tournament(pop):\n best = None\n for _ in range(TOURNAMENT_SIZE):\n ind = random.choice(pop)\n if best is None or ind[2] > best[2]:\n best = ind\n return best\n\n def crossover(p1, p2):\n o1, r1 = p1[0][:], p1[1][:]\n o2, r2 = p2[0][:], p2[1][:]\n size = len(o1)\n\n start, end = sorted(random.sample(range(size), 2))\n o1_new = [-1]*size\n o2_new = [-1]*size\n\n o1_new[start:end] = o2[start:end]\n o2_new[start:end] = o1[start:end]\n\n def fill_offspring(o_new, o_old, start, end):\n for i in range(size):\n if i >= start and i < end:\n continue\n candidate = o_old[i]\n while candidate in o_new[start:end]:\n candidate = o_old[o_old.index(candidate)]\n o_new[i] = candidate\n\n fill_offspring(o1_new, o1, start, end)\n fill_offspring(o2_new, o2, start, end)\n\n cross_pt = random.randint(1, size - 1)\n r1_new = r1[:cross_pt] + r2[cross_pt:]\n r2_new = r2[:cross_pt] + r1[cross_pt:]\n\n return (o1_new, r1_new), (o2_new, r2_new)\n\n def mutate(ind):\n order, rotates = ind[0][:], ind[1][:]\n\n for i in range(len(rotates)):\n if random.random() < MUTATION_RATE:\n rotates[i] = not rotates[i]\n\n if random.random() < MUTATION_RATE:\n i, j = random.sample(range(len(order)), 2)\n order[i], order[j] = order[j], order[i]\n\n return (order, rotates)\n\n population = []\n for _ in range(POPSIZE):\n ind = create_individual()\n fit, placed = fitness(ind)\n population.append((ind[0], ind[1], fit, placed))\n\n for _ in range(GENERATIONS):\n new_pop = []\n while len(new_pop) < POPSIZE:\n p1 = tournament(population)\n p2 = tournament(population)\n c1, c2 = crossover((p1[0], p1[1]), (p2[0], p2[1]))\n c1 = mutate(c1)\n c2 = mutate(c2)\n for c in [c1, c2]:\n fit, placed = fitness(c)\n new_pop.append((c[0], c[1], fit, placed))\n if len(new_pop) >= POPSIZE:\n break\n population = sorted(new_pop, key=lambda x: x[2], reverse=True)[:POPSIZE]\n\n best = population[0]\n order, rotates, _, placed = best\n\n pos_dict = [{} for _ in items]\n for i, idx in enumerate(order):\n x, y, w, h = placed[i]\n rotated = rotates[idx]\n pos_dict[idx] = {'x': x, 'y': y, 'rotated': rotated}\n return pos_dict",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "采用遗传算法模拟物品的组合与位置优化"
}
},
{
"code": "import random\nimport math\n\ndef solve_bp(data):\n items, container_size = data['data']\n container_width, container_height = container_size\n\n def area_used(placed_items):\n return sum(item['width'] * item['height'] for item in placed_items)\n\n def check_fit(item, x, y, placed_items):\n item_width, item_height = item['width'], item['height']\n if x + item_width > container_width or y + item_height > container_height:\n return False\n for placed in placed_items:\n if (x < placed['x'] + placed['width'] and\n x + item_width > placed['x'] and\n y < placed['y'] + placed['height'] and\n y + item_height > placed['y']):\n return False\n return True\n\n def simulated_annealing(items):\n current_solution = []\n for item in items:\n placed = False\n for rotation in [False, True]:\n width, height = (item['width'], item['height']) if not rotation else (item['height'], item['width'])\n for x in range(container_width - width + 1):\n for y in range(container_height - height + 1):\n if check_fit({'width': width, 'height': height}, x, y, current_solution):\n current_solution.append({'x': x, 'y': y, 'rotated': rotation, 'width': width, 'height': height})\n placed = True\n break\n if placed:\n break\n if placed:\n break\n \n return current_solution\n\n result = simulated_annealing([{'width': w, 'height': h} for w, h in items])\n return [{'x': item['x'], 'y': item['y'], 'rotated': item['rotated']} for item in result]",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "应用模拟退火算法逐步降低布局的空余空间"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n item_count = len(items)\n \n best_arrangement = []\n max_area_used = 0\n\n def can_place(item, position):\n width, height, rotated = item\n x, y = position\n if rotated:\n width, height = height, width\n return (0 <= x <= container_width - width) and (0 <= y <= container_height - height)\n\n def pack(items_left, positions):\n nonlocal best_arrangement, max_area_used\n\n if not items_left:\n current_area_used = sum(pos['width'] * pos['height'] for pos in positions)\n if current_area_used > max_area_used:\n max_area_used = current_area_used\n best_arrangement = positions[:]\n return\n\n item = items_left[0]\n width, height = item\n for y in range(container_height):\n for x in range(container_width):\n for rotated in [False, True]:\n if can_place(item, (x, y)):\n new_position = {'x': x, 'y': y, 'rotated': rotated, 'width': width if not rotated else height, 'height': height if not rotated else width}\n pack(items_left[1:], positions + [new_position])\n\n pack(items, [])\n \n return best_arrangement",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "使用动态规划判断子空间的最佳装载方案"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n\n def can_place(item, x, y, rotated):\n width, height = item[1], item[0] if rotated else item\n return x + width <= container_width and y + height <= container_height\n\n def place_item(item, x, y, rotated):\n width, height = item[1], item[0] if rotated else item\n placements.append({'x': x, 'y': y, 'rotated': rotated})\n\n def recursive_backtrack(remaining_items, current_x, current_y):\n if not remaining_items:\n return True\n\n for i, item in enumerate(remaining_items):\n for rotated in (False, True):\n if can_place(item, current_x, current_y, rotated):\n place_item(item, current_x, current_y, rotated)\n \n next_x = current_x + (item[1] if rotated else item[0])\n next_y = current_y\n\n if next_x >= container_width:\n next_x = 0\n next_y += max(item[0], item[1]) if rotated else min(item[0], item[1])\n \n if next_y < container_height:\n if recursive_backtrack(remaining_items[:i] + remaining_items[i+1:], next_x, next_y):\n return True\n \n placements.pop()\n\n return False\n\n recursive_backtrack(items, 0, 0)\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "基于矩形分割的递归空间划分与放置策略"
}
},
{
"code": "def solve_bp(input_dict):\n items, (W, H) = input_dict['data']\n \n def score(item):\n w, h = item\n return w*h*1000 + abs(w - h)\n items_sorted = sorted(enumerate(items), key=lambda x: score(x[1]), reverse=True)\n \n placed = [None]*len(items)\n \n skyline = [(0, 0, W)]\n \n def find_position(w, h):\n best_x, best_y = None, None\n best_y_min = None\n for i in range(len(skyline)):\n x_start, y, width = skyline[i]\n if width >= w:\n x_end = x_start + w\n max_y = y\n curr_x = x_start\n j = i\n cover_width = 0\n while cover_width < w and j < len(skyline):\n xs, ys, ws = skyline[j]\n seg_end = xs + ws\n seg_cover = min(seg_end, x_start+w) - curr_x\n if seg_cover <= 0:\n break\n max_y = max(max_y, ys)\n cover_width += seg_cover\n curr_x += seg_cover\n j += 1\n if cover_width >= w and max_y + h <= H:\n if best_y_min is None or max_y < best_y_min or (max_y == best_y_min and x_start < best_x):\n best_y_min = max_y\n best_x = x_start\n best_y = max_y\n return best_x, best_y\n \n def update_skyline(x, y, w):\n new_skyline = []\n i = 0\n while i < len(skyline):\n sx, sy, sw = skyline[i]\n if sx + sw <= x:\n new_skyline.append((sx, sy, sw))\n i += 1\n elif sx >= x + w:\n break\n else:\n if sx < x:\n new_skyline.append((sx, sy, x - sx))\n if sx + sw > x + w:\n skyline[i] = (x + w, sy, sx + sw - (x + w))\n i -= 1\n i += 1\n break\n new_skyline.append((x, y, w))\n while i < len(skyline):\n new_skyline.append(skyline[i])\n i += 1\n \n merged = []\n for seg in new_skyline:\n if merged and merged[-1][1] == seg[1]:\n merged[-1] = (merged[-1][0], merged[-1][1], merged[-1][2]+seg[2])\n else:\n merged.append(seg)\n return merged\n \n def try_place(i, w, h):\n x, y = find_position(w, h)\n if x is None:\n return None\n nonlocal skyline\n skyline = update_skyline(x, y + h, w)\n return {'x': x, 'y': y, 'rotated': False}\n \n def try_place_rotated(i, w, h):\n x, y = find_position(h, w)\n if x is None:\n return None\n nonlocal skyline\n skyline = update_skyline(x, y + w, h)\n return {'x': x, 'y': y, 'rotated': True}\n \n for idx, (w, h) in items_sorted:\n pos = try_place(idx, w, h)\n if pos is None:\n pos = try_place_rotated(idx, w, h)\n if pos is None:\n pos = {'x': -1, 'y': -1, 'rotated': False}\n placed[idx] = pos\n \n return placed",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "实现启发式排序，将面积大或形状特殊的物品优先放入"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n best_placement = []\n\n def can_place(x, y, item_width, item_height):\n if x + item_width > container_width or y + item_height > container_height:\n return False\n for placement in placements:\n if (x < placement['x'] + placement['width'] and\n x + item_width > placement['x'] and\n y < placement['y'] + placement['height'] and\n y + item_height > placement['y']):\n return False\n return True\n\n def place_item(x, y, width, height, rotated):\n placements.append({\n 'x': x,\n 'y': y,\n 'width': width,\n 'height': height,\n 'rotated': rotated\n })\n\n def remove_item():\n placements.pop()\n\n def backtrack(index):\n if index == len(items):\n nonlocal best_placement\n if len(placements) > len(best_placement):\n best_placement = placements.copy()\n return\n\n item_width, item_height = items[index]\n for x in range(container_width):\n for y in range(container_height):\n if can_place(x, y, item_width, item_height):\n place_item(x, y, item_width, item_height, False)\n backtrack(index + 1)\n remove_item()\n \n if can_place(x, y, item_height, item_width):\n place_item(x, y, item_height, item_width, True)\n backtrack(index + 1)\n remove_item()\n\n backtrack(0)\n\n return [{'x': p['x'], 'y': p['y'], 'rotated': p['rotated']} for p in best_placement]",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用剪枝技术在搜索过程中提前排除不可行布局"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placed_items = []\n \n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for item in placed_items:\n if not (x + width <= item['x'] or x >= item['x'] + item['width'] or\n y + height <= item['y'] or y >= item['y'] + item['height']):\n return False\n return True\n\n def place_item(x, y, width, height, rotated):\n placed_items.append({\n 'x': x,\n 'y': y,\n 'width': width,\n 'height': height,\n 'rotated': rotated\n })\n \n def arrange_items():\n for width, height in items:\n rotated = False\n if not can_place(0, 0, width, height):\n if can_place(0, 0, height, width):\n width, height = height, width\n rotated = True\n\n placed = False\n for x in range(container_width + 1 - width):\n for y in range(container_height + 1 - height):\n if can_place(x, y, width, height):\n place_item(x, y, width, height, rotated)\n placed = True\n break\n if placed:\n break\n \n arrange_items()\n \n result = [{'x': item['x'], 'y': item['y'], 'rotated': item['rotated']} for item in placed_items]\n return result",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "结合局部搜索优化已有的装箱布局以提升空间利用率"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n\n grid_size = 10\n grid = [[None for _ in range(container_width // grid_size + 1)] for _ in range(container_height // grid_size + 1)]\n\n def can_place(item, x, y, rotated):\n width, height = (item[1], item[0]) if rotated else item\n if x + width > container_width or y + height > container_height:\n return False\n for i in range(y // grid_size, (y + height) // grid_size + 1):\n for j in range(x // grid_size, (x + width) // grid_size + 1):\n if grid[i][j] is not None:\n return False\n return True\n\n def place_item(item, x, y, rotated):\n width, height = (item[1], item[0]) if rotated else item\n for i in range(y // grid_size, (y + height) // grid_size + 1):\n for j in range(x // grid_size, (x + width) // grid_size + 1):\n grid[i][j] = item\n\n placements = []\n \n for item in items:\n placed = False\n for rotated in [False, True]:\n width, height = (item[1], item[0]) if rotated else item\n for y in range(0, container_height - height + 1, grid_size):\n for x in range(0, container_width - width + 1, grid_size):\n if can_place(item, x, y, rotated):\n place_item(item, x, y, rotated)\n placements.append({'x': x, 'y': y, 'rotated': rotated})\n placed = True\n break\n if placed:\n break\n if placed:\n break\n\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "引入多层次网格划分，逐层细化装箱方案"
}
},
{
"code": "import random\n\ndef solve_bp(params):\n data = params['data']\n items, container_size = data\n container_width, container_height = container_size\n \n items = sorted(items, key=lambda item: item[0] * item[1], reverse=True)\n positions = []\n \n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for pos in positions:\n if (x < pos['x'] + (pos['rotated'] * pos['height'] or pos['width']) and\n x + width > pos['x'] and\n y < pos['y'] + (pos['rotated'] * pos['width'] or pos['height']) and\n y + height > pos['y']):\n return False\n return True\n\n def place_item(width, height, rotated):\n for x in range(container_width):\n for y in range(container_height):\n if can_place(x, y, width, height):\n return {'x': x, 'y': y, 'rotated': rotated}\n return None\n\n for width, height in items:\n placed = place_item(width, height, False)\n if not placed:\n placed = place_item(height, width, True)\n if placed:\n positions.append(placed)\n \n return positions",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用机器学习模型预测最佳物品排序和放置顺序"
}
},
{
"code": "def solve_bp(data):\n items, (container_width, container_height) = data['data']\n positions = []\n used_space = [[False] * container_width for _ in range(container_height)]\n\n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for i in range(y, y + height):\n for j in range(x, x + width):\n if used_space[i][j]:\n return False\n return True\n\n def place_item(x, y, width, height):\n for i in range(y, y + height):\n for j in range(x, x + width):\n used_space[i][j] = True\n\n for width, height in items:\n placed = False\n \n for y in range(container_height):\n for x in range(container_width):\n if can_place(x, y, width, height):\n positions.append({'x': x, 'y': y, 'rotated': False})\n place_item(x, y, width, height)\n placed = True\n break\n if placed:\n break\n\n if not placed:\n for y in range(container_height):\n for x in range(container_width):\n if can_place(x, y, height, width):\n positions.append({'x': x, 'y': y, 'rotated': True})\n place_item(x, y, height, width)\n placed = True\n break\n if placed:\n break\n\n return positions",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "采用混合算法，结合启发式与精确算法进行优化"
}
}
],
"pareto_front": [
{
"code": "def solve_bp(data):\n def rectangle_area(rect):\n return rect[0] * rect[1]\n\n def can_place(rect, x, y, occupied):\n width, height = rect\n for ox, oy, owidth, oheight in occupied:\n if not (x + width <= ox or x >= ox + owidth or y + height <= oy or y >= oy + oheight):\n return False\n return True\n\n def find_position(rect, occupied, container_width, container_height):\n width, height = rect\n for y in range(container_height - height + 1):\n for x in range(container_width - width + 1):\n if can_place(rect, x, y, occupied):\n return x, y\n return None\n\n items, (container_width, container_height) = data['data']\n items_with_info = []\n for idx, (w, h) in enumerate(items):\n area = w * h\n items_with_info.append({'index': idx, 'w': w, 'h': h, 'area': area})\n\n items_with_info.sort(key=lambda x: x['area'], reverse=True)\n\n placed_items = []\n occupied = []\n\n for item in items_with_info:\n w, h = item['w'], item['h']\n position = find_position((w, h), occupied, container_width, container_height)\n rotated = False\n if position:\n x, y = position\n else:\n w_rot, h_rot = h, w\n position = find_position((w_rot, h_rot), occupied, container_width, container_height)\n if position:\n x, y = position\n w, h = w_rot, h_rot\n rotated = True\n else:\n continue\n placed_items.append({\n 'index': item['index'],\n 'x': x,\n 'y': y,\n 'rotated': rotated,\n 'width': w,\n 'height': h\n })\n occupied.append((x, y, w, h))\n\n result = [None] * len(items)\n for p in placed_items:\n idx = p['index']\n result[idx] = {\n 'x': p['x'],\n 'y': p['y'],\n 'rotated': p['rotated']\n }\n return result",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "使用贪心策略逐个放置最大面积物品到剩余空间中"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n\n def fit_items(placed_items, remaining_items):\n if not remaining_items:\n return True\n \n item = remaining_items[0]\n width, height = item\n for rotated in [False, True]:\n if rotated:\n width, height = height, width\n \n for x in range(container_width - width + 1):\n for y in range(container_height - height + 1):\n if can_place(placed_items, (x, y, width, height)):\n placed_items.append({'x': x, 'y': y, 'rotated': rotated})\n if fit_items(placed_items, remaining_items[1:]):\n return True\n placed_items.pop()\n\n return False\n\n def can_place(placed_items, new_item):\n new_x, new_y, new_w, new_h = new_item\n for item in placed_items:\n item_x = item['x']\n item_y = item['y']\n item_w = item['rotated'] and item['height'] or item['width']\n item_h = item['rotated'] and item['width'] or item['height']\n\n if not (new_x + new_w <= item_x or new_x >= item_x + item_w or \n new_y + new_h <= item_y or new_y >= item_y + item_h):\n return False\n return True\n\n fit_items([], items)\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用分支限界法搜索所有可能的布局以找到最优解"
}
},
{
"code": "import random\n\ndef solve_bp(input_dict):\n items, (W, H) = input_dict['data']\n\n POPSIZE = 50\n GENERATIONS = 150\n MUTATION_RATE = 0.2\n TOURNAMENT_SIZE = 5\n\n def create_individual():\n order = list(range(len(items)))\n random.shuffle(order)\n rotates = [random.choice([False, True]) for _ in items]\n return (order, rotates)\n\n def rect_fits(x, y, w, h):\n return 0 <= x <= W - w and 0 <= y <= H - h\n\n def overlap(r1, r2):\n x1, y1, w1, h1 = r1\n x2, y2, w2, h2 = r2\n return not (x1 + w1 <= x2 or x2 + w2 <= x1 or y1 + h1 <= y2 or y2 + h2 <= y1)\n\n def place_items(order, rotates):\n placed = []\n taken_area = 0\n for idx in order:\n w, h = items[idx]\n if rotates[idx]:\n w, h = h, w\n pos = try_place(w, h, placed)\n if pos is None:\n return None, 0\n x, y = pos\n placed.append((x, y, w, h))\n taken_area += w * h\n return placed, taken_area\n\n def try_place(w, h, placed):\n STEP = 5\n for y in range(0, H - h + 1, STEP):\n for x in range(0, W - w + 1, STEP):\n r = (x, y, w, h)\n if all(not overlap(r, p) for p in placed):\n return (x, y)\n return None\n\n def fitness(ind):\n placed, area = place_items(ind[0], ind[1])\n return area / (W * H), placed\n\n def tournament(pop):\n best = None\n for _ in range(TOURNAMENT_SIZE):\n ind = random.choice(pop)\n if best is None or ind[2] > best[2]:\n best = ind\n return best\n\n def crossover(p1, p2):\n o1, r1 = p1[0][:], p1[1][:]\n o2, r2 = p2[0][:], p2[1][:]\n size = len(o1)\n\n start, end = sorted(random.sample(range(size), 2))\n o1_new = [-1]*size\n o2_new = [-1]*size\n\n o1_new[start:end] = o2[start:end]\n o2_new[start:end] = o1[start:end]\n\n def fill_offspring(o_new, o_old, start, end):\n for i in range(size):\n if i >= start and i < end:\n continue\n candidate = o_old[i]\n while candidate in o_new[start:end]:\n candidate = o_old[o_old.index(candidate)]\n o_new[i] = candidate\n\n fill_offspring(o1_new, o1, start, end)\n fill_offspring(o2_new, o2, start, end)\n\n cross_pt = random.randint(1, size - 1)\n r1_new = r1[:cross_pt] + r2[cross_pt:]\n r2_new = r2[:cross_pt] + r1[cross_pt:]\n\n return (o1_new, r1_new), (o2_new, r2_new)\n\n def mutate(ind):\n order, rotates = ind[0][:], ind[1][:]\n\n for i in range(len(rotates)):\n if random.random() < MUTATION_RATE:\n rotates[i] = not rotates[i]\n\n if random.random() < MUTATION_RATE:\n i, j = random.sample(range(len(order)), 2)\n order[i], order[j] = order[j], order[i]\n\n return (order, rotates)\n\n population = []\n for _ in range(POPSIZE):\n ind = create_individual()\n fit, placed = fitness(ind)\n population.append((ind[0], ind[1], fit, placed))\n\n for _ in range(GENERATIONS):\n new_pop = []\n while len(new_pop) < POPSIZE:\n p1 = tournament(population)\n p2 = tournament(population)\n c1, c2 = crossover((p1[0], p1[1]), (p2[0], p2[1]))\n c1 = mutate(c1)\n c2 = mutate(c2)\n for c in [c1, c2]:\n fit, placed = fitness(c)\n new_pop.append((c[0], c[1], fit, placed))\n if len(new_pop) >= POPSIZE:\n break\n population = sorted(new_pop, key=lambda x: x[2], reverse=True)[:POPSIZE]\n\n best = population[0]\n order, rotates, _, placed = best\n\n pos_dict = [{} for _ in items]\n for i, idx in enumerate(order):\n x, y, w, h = placed[i]\n rotated = rotates[idx]\n pos_dict[idx] = {'x': x, 'y': y, 'rotated': rotated}\n return pos_dict",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "采用遗传算法模拟物品的组合与位置优化"
}
},
{
"code": "import random\nimport math\n\ndef solve_bp(data):\n items, container_size = data['data']\n container_width, container_height = container_size\n\n def area_used(placed_items):\n return sum(item['width'] * item['height'] for item in placed_items)\n\n def check_fit(item, x, y, placed_items):\n item_width, item_height = item['width'], item['height']\n if x + item_width > container_width or y + item_height > container_height:\n return False\n for placed in placed_items:\n if (x < placed['x'] + placed['width'] and\n x + item_width > placed['x'] and\n y < placed['y'] + placed['height'] and\n y + item_height > placed['y']):\n return False\n return True\n\n def simulated_annealing(items):\n current_solution = []\n for item in items:\n placed = False\n for rotation in [False, True]:\n width, height = (item['width'], item['height']) if not rotation else (item['height'], item['width'])\n for x in range(container_width - width + 1):\n for y in range(container_height - height + 1):\n if check_fit({'width': width, 'height': height}, x, y, current_solution):\n current_solution.append({'x': x, 'y': y, 'rotated': rotation, 'width': width, 'height': height})\n placed = True\n break\n if placed:\n break\n if placed:\n break\n \n return current_solution\n\n result = simulated_annealing([{'width': w, 'height': h} for w, h in items])\n return [{'x': item['x'], 'y': item['y'], 'rotated': item['rotated']} for item in result]",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "应用模拟退火算法逐步降低布局的空余空间"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n item_count = len(items)\n \n best_arrangement = []\n max_area_used = 0\n\n def can_place(item, position):\n width, height, rotated = item\n x, y = position\n if rotated:\n width, height = height, width\n return (0 <= x <= container_width - width) and (0 <= y <= container_height - height)\n\n def pack(items_left, positions):\n nonlocal best_arrangement, max_area_used\n\n if not items_left:\n current_area_used = sum(pos['width'] * pos['height'] for pos in positions)\n if current_area_used > max_area_used:\n max_area_used = current_area_used\n best_arrangement = positions[:]\n return\n\n item = items_left[0]\n width, height = item\n for y in range(container_height):\n for x in range(container_width):\n for rotated in [False, True]:\n if can_place(item, (x, y)):\n new_position = {'x': x, 'y': y, 'rotated': rotated, 'width': width if not rotated else height, 'height': height if not rotated else width}\n pack(items_left[1:], positions + [new_position])\n\n pack(items, [])\n \n return best_arrangement",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "使用动态规划判断子空间的最佳装载方案"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n\n def can_place(item, x, y, rotated):\n width, height = item[1], item[0] if rotated else item\n return x + width <= container_width and y + height <= container_height\n\n def place_item(item, x, y, rotated):\n width, height = item[1], item[0] if rotated else item\n placements.append({'x': x, 'y': y, 'rotated': rotated})\n\n def recursive_backtrack(remaining_items, current_x, current_y):\n if not remaining_items:\n return True\n\n for i, item in enumerate(remaining_items):\n for rotated in (False, True):\n if can_place(item, current_x, current_y, rotated):\n place_item(item, current_x, current_y, rotated)\n \n next_x = current_x + (item[1] if rotated else item[0])\n next_y = current_y\n\n if next_x >= container_width:\n next_x = 0\n next_y += max(item[0], item[1]) if rotated else min(item[0], item[1])\n \n if next_y < container_height:\n if recursive_backtrack(remaining_items[:i] + remaining_items[i+1:], next_x, next_y):\n return True\n \n placements.pop()\n\n return False\n\n recursive_backtrack(items, 0, 0)\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "基于矩形分割的递归空间划分与放置策略"
}
},
{
"code": "def solve_bp(input_dict):\n items, (W, H) = input_dict['data']\n \n def score(item):\n w, h = item\n return w*h*1000 + abs(w - h)\n items_sorted = sorted(enumerate(items), key=lambda x: score(x[1]), reverse=True)\n \n placed = [None]*len(items)\n \n skyline = [(0, 0, W)]\n \n def find_position(w, h):\n best_x, best_y = None, None\n best_y_min = None\n for i in range(len(skyline)):\n x_start, y, width = skyline[i]\n if width >= w:\n x_end = x_start + w\n max_y = y\n curr_x = x_start\n j = i\n cover_width = 0\n while cover_width < w and j < len(skyline):\n xs, ys, ws = skyline[j]\n seg_end = xs + ws\n seg_cover = min(seg_end, x_start+w) - curr_x\n if seg_cover <= 0:\n break\n max_y = max(max_y, ys)\n cover_width += seg_cover\n curr_x += seg_cover\n j += 1\n if cover_width >= w and max_y + h <= H:\n if best_y_min is None or max_y < best_y_min or (max_y == best_y_min and x_start < best_x):\n best_y_min = max_y\n best_x = x_start\n best_y = max_y\n return best_x, best_y\n \n def update_skyline(x, y, w):\n new_skyline = []\n i = 0\n while i < len(skyline):\n sx, sy, sw = skyline[i]\n if sx + sw <= x:\n new_skyline.append((sx, sy, sw))\n i += 1\n elif sx >= x + w:\n break\n else:\n if sx < x:\n new_skyline.append((sx, sy, x - sx))\n if sx + sw > x + w:\n skyline[i] = (x + w, sy, sx + sw - (x + w))\n i -= 1\n i += 1\n break\n new_skyline.append((x, y, w))\n while i < len(skyline):\n new_skyline.append(skyline[i])\n i += 1\n \n merged = []\n for seg in new_skyline:\n if merged and merged[-1][1] == seg[1]:\n merged[-1] = (merged[-1][0], merged[-1][1], merged[-1][2]+seg[2])\n else:\n merged.append(seg)\n return merged\n \n def try_place(i, w, h):\n x, y = find_position(w, h)\n if x is None:\n return None\n nonlocal skyline\n skyline = update_skyline(x, y + h, w)\n return {'x': x, 'y': y, 'rotated': False}\n \n def try_place_rotated(i, w, h):\n x, y = find_position(h, w)\n if x is None:\n return None\n nonlocal skyline\n skyline = update_skyline(x, y + w, h)\n return {'x': x, 'y': y, 'rotated': True}\n \n for idx, (w, h) in items_sorted:\n pos = try_place(idx, w, h)\n if pos is None:\n pos = try_place_rotated(idx, w, h)\n if pos is None:\n pos = {'x': -1, 'y': -1, 'rotated': False}\n placed[idx] = pos\n \n return placed",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "实现启发式排序，将面积大或形状特殊的物品优先放入"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placements = []\n best_placement = []\n\n def can_place(x, y, item_width, item_height):\n if x + item_width > container_width or y + item_height > container_height:\n return False\n for placement in placements:\n if (x < placement['x'] + placement['width'] and\n x + item_width > placement['x'] and\n y < placement['y'] + placement['height'] and\n y + item_height > placement['y']):\n return False\n return True\n\n def place_item(x, y, width, height, rotated):\n placements.append({\n 'x': x,\n 'y': y,\n 'width': width,\n 'height': height,\n 'rotated': rotated\n })\n\n def remove_item():\n placements.pop()\n\n def backtrack(index):\n if index == len(items):\n nonlocal best_placement\n if len(placements) > len(best_placement):\n best_placement = placements.copy()\n return\n\n item_width, item_height = items[index]\n for x in range(container_width):\n for y in range(container_height):\n if can_place(x, y, item_width, item_height):\n place_item(x, y, item_width, item_height, False)\n backtrack(index + 1)\n remove_item()\n \n if can_place(x, y, item_height, item_width):\n place_item(x, y, item_height, item_width, True)\n backtrack(index + 1)\n remove_item()\n\n backtrack(0)\n\n return [{'x': p['x'], 'y': p['y'], 'rotated': p['rotated']} for p in best_placement]",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用剪枝技术在搜索过程中提前排除不可行布局"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n placed_items = []\n \n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for item in placed_items:\n if not (x + width <= item['x'] or x >= item['x'] + item['width'] or\n y + height <= item['y'] or y >= item['y'] + item['height']):\n return False\n return True\n\n def place_item(x, y, width, height, rotated):\n placed_items.append({\n 'x': x,\n 'y': y,\n 'width': width,\n 'height': height,\n 'rotated': rotated\n })\n \n def arrange_items():\n for width, height in items:\n rotated = False\n if not can_place(0, 0, width, height):\n if can_place(0, 0, height, width):\n width, height = height, width\n rotated = True\n\n placed = False\n for x in range(container_width + 1 - width):\n for y in range(container_height + 1 - height):\n if can_place(x, y, width, height):\n place_item(x, y, width, height, rotated)\n placed = True\n break\n if placed:\n break\n \n arrange_items()\n \n result = [{'x': item['x'], 'y': item['y'], 'rotated': item['rotated']} for item in placed_items]\n return result",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "结合局部搜索优化已有的装箱布局以提升空间利用率"
}
},
{
"code": "def solve_bp(input_data):\n items, container_size = input_data['data']\n container_width, container_height = container_size\n\n grid_size = 10\n grid = [[None for _ in range(container_width // grid_size + 1)] for _ in range(container_height // grid_size + 1)]\n\n def can_place(item, x, y, rotated):\n width, height = (item[1], item[0]) if rotated else item\n if x + width > container_width or y + height > container_height:\n return False\n for i in range(y // grid_size, (y + height) // grid_size + 1):\n for j in range(x // grid_size, (x + width) // grid_size + 1):\n if grid[i][j] is not None:\n return False\n return True\n\n def place_item(item, x, y, rotated):\n width, height = (item[1], item[0]) if rotated else item\n for i in range(y // grid_size, (y + height) // grid_size + 1):\n for j in range(x // grid_size, (x + width) // grid_size + 1):\n grid[i][j] = item\n\n placements = []\n \n for item in items:\n placed = False\n for rotated in [False, True]:\n width, height = (item[1], item[0]) if rotated else item\n for y in range(0, container_height - height + 1, grid_size):\n for x in range(0, container_width - width + 1, grid_size):\n if can_place(item, x, y, rotated):\n place_item(item, x, y, rotated)\n placements.append({'x': x, 'y': y, 'rotated': rotated})\n placed = True\n break\n if placed:\n break\n if placed:\n break\n\n return placements",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "引入多层次网格划分，逐层细化装箱方案"
}
},
{
"code": "import random\n\ndef solve_bp(params):\n data = params['data']\n items, container_size = data\n container_width, container_height = container_size\n \n items = sorted(items, key=lambda item: item[0] * item[1], reverse=True)\n positions = []\n \n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for pos in positions:\n if (x < pos['x'] + (pos['rotated'] * pos['height'] or pos['width']) and\n x + width > pos['x'] and\n y < pos['y'] + (pos['rotated'] * pos['width'] or pos['height']) and\n y + height > pos['y']):\n return False\n return True\n\n def place_item(width, height, rotated):\n for x in range(container_width):\n for y in range(container_height):\n if can_place(x, y, width, height):\n return {'x': x, 'y': y, 'rotated': rotated}\n return None\n\n for width, height in items:\n placed = place_item(width, height, False)\n if not placed:\n placed = place_item(height, width, True)\n if placed:\n positions.append(placed)\n \n return positions",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "利用机器学习模型预测最佳物品排序和放置顺序"
}
},
{
"code": "def solve_bp(data):\n items, (container_width, container_height) = data['data']\n positions = []\n used_space = [[False] * container_width for _ in range(container_height)]\n\n def can_place(x, y, width, height):\n if x + width > container_width or y + height > container_height:\n return False\n for i in range(y, y + height):\n for j in range(x, x + width):\n if used_space[i][j]:\n return False\n return True\n\n def place_item(x, y, width, height):\n for i in range(y, y + height):\n for j in range(x, x + width):\n used_space[i][j] = True\n\n for width, height in items:\n placed = False\n \n for y in range(container_height):\n for x in range(container_width):\n if can_place(x, y, width, height):\n positions.append({'x': x, 'y': y, 'rotated': False})\n place_item(x, y, width, height)\n placed = True\n break\n if placed:\n break\n\n if not placed:\n for y in range(container_height):\n for x in range(container_width):\n if can_place(x, y, height, width):\n positions.append({'x': x, 'y': y, 'rotated': True})\n place_item(x, y, height, width)\n placed = True\n break\n if placed:\n break\n\n return positions",
"generation": 0,
"fitnesses": {
"utilization_rate": Infinity,
"execution_time": Infinity
},
"metadata": {
"idea": "采用混合算法，结合启发式与精确算法进行优化"
}
}
],
"objective_names": [
"utilization_rate",
"execution_time"
]
}

22
src/lead/problems/bp/problem_config.json
View File

@@ -1,8 +1,10 @@
{
"description": "尝试开发一个高效的算法用于解决二维装箱问题。你被给定了一组矩形物品和一个固定大小的矩形容器，目标是通过算法的规划将所有物品放入容器中，使得容器的利用率最大化。",
"function_name": "solve_bp",
"input_format": "一个包含多个矩形物品的列表，每个物品由其宽度和高度表示，以及一个表示容器宽度和高度的元组。",
"output_format": "返回一个列表，表示每个物品在容器中的位置和旋转状态。",
"input_format": "一个字典，包含两个部分：\n1. 'data': 一个元组，包含多个矩形物品的列表和一个表示容器宽度和高度的元组。\n - 矩形物品列表的每个元素是一个元组，表示物品的宽度和高度。\n - 容器元组表示容器的宽度和高度。\n",
"output_format": "返回一个列表，表示每个物品在容器中的位置和旋转状态。\n每个元素是一个字典，包含以下键：\n1. 'x': 物品左上角的x坐标。\n2. 'y': 物品左上角的y坐标。\n3. 'rotated': 一个布尔值，表示物品是否旋转。",
"multi_objective": true,
"objective_names": ["vacancy_rate", "execution_time"],
"evaluation_timeout": 60,
"llm_config": {
"api_key": "sk-cOqgMkQ605Om9Z28q3UtAfOAtOn7c53tld94Cu01oOEoVTmg",
@@ -12,10 +14,16 @@
"max_tokens": 4096
},
"evolution_params": {
"algorithm": "GA",
"population_size": 10,
"generations": 5,
"mutation_rate": 0.2,
"crossover_rate": 0.7
"algorithm": "MO",
"population_size": 12,
"generations": 8,
"mutation_rate": 0.5,
"crossover_rate": 0.4,
"F": 0.8,
"CR": 0.7
},
"dataset_generation": {
"script_path": "src/lead/problems/bp/dataset/data_loader.py",
"random_seed": 2025
}
}

49
src/lead/problems/sort/multi_objective_history/20250513_112501/generation_0.json Normal file
View File

@@ -0,0 +1,49 @@
{
"generation": 0,
"population": [
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.008332669734954834,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n \n return sorted_arr",
"generation": 0,
"fitnesses": {
"time": 0.0094107985496521,
"error": 0.0
},
"metadata": {
"idea": "思路4：使用计数排序或基数排序，专门处理包含大量重复元素的数组，以实现线性时间复杂度O(n)。"
}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n \n return sorted_arr",
"generation": 1,
"fitnesses": {
"time": 0.008702456951141357,
"error": 0.0
},
"metadata": {}
}
],
"pareto_front": [
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.008332669734954834,
"error": 0.0
},
"metadata": {}
}
],
"objective_names": [
"time",
"error"
]
}

76
src/lead/problems/sort/multi_objective_history/20250513_112501/generation_1.json Normal file
View File

@@ -0,0 +1,76 @@
{
"generation": 1,
"population": [
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.007822036743164062,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.007822036743164062,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr\n\ndef merge_sort(arr):\n if len(arr) <= 1:\n return arr\n mid = len(arr) // 2\n left = merge_sort(arr[:mid])\n right = merge_sort(arr[mid:])\n return merge(left, right)\n\ndef merge(left, right):\n merged = []\n i = j = 0\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n merged.append(left[i])\n i += 1\n else:\n merged.append(right[j])\n j += 1\n merged.extend(left[i:])\n merged.extend(right[j:])\n return merged",
"generation": 2,
"fitnesses": {
"time": 0.00847560167312622,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n \n return sorted_arr",
"generation": 1,
"fitnesses": {
"time": 0.008702456951141357,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n \n return sorted_arr",
"generation": 0,
"fitnesses": {
"time": 0.0094107985496521,
"error": 0.0
},
"metadata": {
"idea": "思路4：使用计数排序或基数排序，专门处理包含大量重复元素的数组，以实现线性时间复杂度O(n)。"
}
}
],
"pareto_front": [
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.007822036743164062,
"error": 0.0
},
"metadata": {}
},
{
"code": "def advanced_sort(arr):\n if not arr:\n return arr\n \n if len(arr) <= 10:\n return insertion_sort(arr)\n \n max_val = max(arr)\n min_val = min(arr)\n \n count_range = max_val - min_val + 1\n count = [0] * count_range\n\n for num in arr:\n count[num - min_val] += 1\n\n sorted_arr = []\n for i in range(count_range):\n sorted_arr.extend([i + min_val] * count[i])\n\n return sorted_arr\n\ndef insertion_sort(subarr):\n for i in range(1, len(subarr)):\n key = subarr[i]\n j = i - 1\n while j >= 0 and subarr[j] > key:\n subarr[j + 1] = subarr[j]\n j -= 1\n subarr[j + 1] = key\n return subarr",
"generation": 1,
"fitnesses": {
"time": 0.007822036743164062,
"error": 0.0
},
"metadata": {}
}
],
"objective_names": [
"time",
"error"
]
}