From f96c9c56c7d15412dc857b562b1e170bed8bcc1d Mon Sep 17 00:00:00 2001 From: yangyudong <916291030@qq.com> Date: Tue, 13 May 2025 15:48:25 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E4=BA=8C=E7=BB=B4=E8=A3=85?= =?UTF-8?q?=E7=AE=B1=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lead/problems/bp/dataset/data_loader.py | 42 +++ src/lead/problems/bp/evaluation.py | 100 +++++++ .../problems/bp/multi_objective_evolution.log | 1 + .../20250513_151843/generation_0.json | 275 ++++++++++++++++++ src/lead/problems/bp/problem_config.json | 22 +- .../20250513_112501/generation_0.json | 49 ++++ .../20250513_112501/generation_1.json | 76 +++++ 7 files changed, 558 insertions(+), 7 deletions(-) create mode 100644 src/lead/problems/bp/dataset/data_loader.py create mode 100644 src/lead/problems/bp/evaluation.py create mode 100644 src/lead/problems/bp/multi_objective_evolution.log create mode 100644 src/lead/problems/bp/multi_objective_history/20250513_151843/generation_0.json create mode 100644 src/lead/problems/sort/multi_objective_history/20250513_112501/generation_0.json create mode 100644 src/lead/problems/sort/multi_objective_history/20250513_112501/generation_1.json diff --git a/src/lead/problems/bp/dataset/data_loader.py b/src/lead/problems/bp/dataset/data_loader.py new file mode 100644 index 0000000..175d8b2 --- /dev/null +++ b/src/lead/problems/bp/dataset/data_loader.py @@ -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) \ No newline at end of file diff --git a/src/lead/problems/bp/evaluation.py b/src/lead/problems/bp/evaluation.py new file mode 100644 index 0000000..3b8c924 --- /dev/null +++ b/src/lead/problems/bp/evaluation.py @@ -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') + } \ No newline at end of file diff --git a/src/lead/problems/bp/multi_objective_evolution.log b/src/lead/problems/bp/multi_objective_evolution.log new file mode 100644 index 0000000..ec58555 --- /dev/null +++ b/src/lead/problems/bp/multi_objective_evolution.log @@ -0,0 +1 @@ +Generation 0000 | Pareto Front Size: 12 | Timestamp: 2025-05-13T15:44:39.489046 diff --git a/src/lead/problems/bp/multi_objective_history/20250513_151843/generation_0.json b/src/lead/problems/bp/multi_objective_history/20250513_151843/generation_0.json new file mode 100644 index 0000000..4b5baff --- /dev/null +++ b/src/lead/problems/bp/multi_objective_history/20250513_151843/generation_0.json @@ -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" + ] +} \ No newline at end of file diff --git a/src/lead/problems/bp/problem_config.json b/src/lead/problems/bp/problem_config.json index 60e859e..f733e3a 100644 --- a/src/lead/problems/bp/problem_config.json +++ b/src/lead/problems/bp/problem_config.json @@ -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 } } diff --git a/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_0.json b/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_0.json new file mode 100644 index 0000000..2880ffd --- /dev/null +++ b/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_0.json @@ -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" + ] +} \ No newline at end of file diff --git a/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_1.json b/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_1.json new file mode 100644 index 0000000..d5fe452 --- /dev/null +++ b/src/lead/problems/sort/multi_objective_history/20250513_112501/generation_1.json @@ -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" + ] +} \ No newline at end of file