初始化算子修改第一版，多目标进化过程待修改

src/lead/core/evolution.py

@@ -40,20 +40,33 @@ class EvolutionEngine:
         
 
     def initialize_population(self, size: int) -> List[AlgorithmIndividual]:
-        """使用LLM生成初始种群"""
+        """改进后的种群初始化方法"""
         problem_config = self._load_problem_config()
-        individuals = []
         
-        while len(individuals) < size:
+        # 首先生成多个不同的算法思路
+        ideas = self.initialize_operator.ideas_generator.generate_ideas(
+            problem_config["description"],
+            size
+        )
+        
+        # 基于每个思路生成具体实现
+        individuals = []
+        for i, idea in enumerate(ideas):
             code = self.initialize_operator.generate_initial_code(
                 problem_config["description"],
                 problem_config["function_name"],
                 problem_config["input_format"],
-                problem_config["output_format"]
+                problem_config["output_format"],
+                idea
             )
-            if code:  # 只添加成功生成的代码
+            if code:
-                individuals.append(AlgorithmIndividual(code, generation=0))
+                individuals.append(AlgorithmIndividual(
+                    code,
+                    generation=0,
+                    metadata={"idea": idea}  # 保存原始思路
+                ))
         
+        print(f"成功生成初始种群，包含{len(individuals)}个不同个体")
         return individuals
     
     def run_evolution(self, generations: int = None, population_size: int = None):

src/lead/core/multi_objective/evolution.py

@@ -35,20 +35,33 @@ class MultiObjectiveEvolutionEngine:
         print(f"多目标进化参数：{self.evolution_params}")
     
     def initialize_population(self, size: int) -> List[MultiObjectiveIndividual]:
-        """使用LLM生成初始种群"""
+        """改进后的种群初始化方法"""
         problem_config = self._load_problem_config()
-        population = []
         
-        while len(population) < size:
+        # 首先生成多个不同的算法思路
+        ideas = self.initialize_operator.ideas_generator.generate_ideas(
+            problem_config["description"],
+            size
+        )
+        
+        # 基于每个思路生成具体实现
+        population = []
+        for i, idea in enumerate(ideas):
             code = self.initialize_operator.generate_initial_code(
                 problem_config["description"],
                 problem_config["function_name"],
                 problem_config["input_format"],
-                problem_config["output_format"]
+                problem_config["output_format"],
+                idea
             )
             if code:
-                population.append(MultiObjectiveIndividual(code, generation=0))
+                population.append(MultiObjectiveIndividual(
+                    code,
+                    generation=0,
+                    metadata={"idea": idea}  # 保存原始思路
+                ))
         
+        print(f"成功生成初始种群，包含{len(population)}个不同个体")
         return population
     
     def run_evolution(self, generations: int = None, population_size: int = None):

src/lead/core/multi_objective/individual.py

@@ -8,6 +8,7 @@ class MultiObjectiveIndividual:
     code: str
     generation: int
     fitnesses: Dict[str, float] = field(default_factory=dict)
+    metadata: Dict[str, Any] = field(default_factory=dict)
     
     def dominates(self, other: 'MultiObjectiveIndividual') -> bool:
         """检查当前个体是否Pareto支配另一个个体"""
@@ -27,7 +28,8 @@ class MultiObjectiveIndividual:
         return {
             "code": self.code,
             "generation": self.generation,
-            "fitnesses": self.fitnesses
+            "fitnesses": self.fitnesses,
+            "metadata": self.metadata
         }
     
     @classmethod
@@ -36,7 +38,8 @@ class MultiObjectiveIndividual:
         return cls(
             code=data["code"],
             generation=data["generation"],
-            fitnesses=data.get("fitnesses", {})
+            fitnesses=data.get("fitnesses", {}),
+            metadata=data.get("metadata", {})
         )
     
     def crowding_distance(self, front: List['MultiObjectiveIndividual']) -> float:

src/lead/core/operators/initialize_operator.py

@@ -1,18 +1,44 @@
-from typing import Optional
+from typing import Optional, List
 from ..llm_integration import LLMClient
 from .verify_operator import VerifyOperator
 
+class AlgorithmIdeasGenerator:
+    def __init__(self, llm_client: LLMClient):
+        self.llm_client = llm_client
+        
+    def generate_ideas(self, problem_desc: str, num_ideas: int) -> List[str]:
+        """生成多个不同的算法思路"""
+        prompt = f"""请为以下问题生成{num_ideas}个不同的算法解决思路：
+问题描述：{problem_desc}
+
+要求：
+1. 每个思路用一行简洁描述
+2. 不要包含其他任何信息
+3. 思路之间应有明显差异
+4. 总共返回正好{num_ideas}行
+
+示例格式：
+思路1描述
+思路2描述
+...
+思路{num_ideas}描述
+"""
+        response = self.llm_client._call_llm(prompt, operator="generate_ideas")
+        return [line.strip() for line in response.split('\n') if line.strip()]
+
 class InitializeOperator:
     def __init__(self, llm_client: LLMClient):
         self.llm_client = llm_client
+        self.ideas_generator = AlgorithmIdeasGenerator(llm_client)
         self.verify_operator = VerifyOperator(llm_client)
 
-    def generate_initial_code(self, problem_desc: str, function_name: str, input_fmt: str, output_fmt: str) -> str:
+    def generate_initial_code(self, problem_desc: str, function_name: str,
-        """生成初始算法代码"""
+                            input_fmt: str, output_fmt: str, idea: str = None) -> str:
-        prompt = f"""请用Python编写一个解决以下问题的函数：
+        """基于特定思路生成初始代码"""
-问题描述：{problem_desc}
+        base_prompt = f"""请用Python实现以下算法思路：
+思路：{idea or '默认算法'}
 
-函数要求：
+具体要求：
 1. 函数名：{function_name}
 2. 输入：{input_fmt}
 3. 返回值：{output_fmt}
@@ -20,11 +46,10 @@ class InitializeOperator:
 注意：
 - 不需要添加类型注解
 - 只返回函数代码，不要包含任何解释或测试用例
-- 我们允许返回的代码中包含了多个函数，但是一定要确直接运行{function_name}函数并将数据传入即可完成全部流程并获得预期的返回
+- 可以包含多个辅助函数
-- 算法应该尽可能地创新，避免完全依赖已有的成熟算法，可以接受在成熟算法的基础上进行一定的修改
+- 代码应简洁高效
-- 算法应该尽可能地简洁，避免不必要的复杂性
 """
-        code = self.llm_client._call_llm(prompt, operator="initialize")
+        code = self.llm_client._call_llm(base_prompt, operator="initialize")
         if code:
             return self.verify_operator.verify_code_format(code, function_name)
         return None

src/lead/problems/mc/multi_objective_evolution.log

@@ -1,11 +0,0 @@
-Generation 0000 | Pareto Front Size: 1 | Timestamp: 2025-04-16T01:20:59.478238
-Generation 0000 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:20:24.296920
-Generation 0001 | Pareto Front Size: 5 | Timestamp: 2025-04-16T15:21:20.873092
-Generation 0002 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:23:24.293834
-Generation 0003 | Pareto Front Size: 5 | Timestamp: 2025-04-16T15:24:37.459385
-Generation 0004 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:26:28.544849
-Generation 0005 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:30:30.213218
-Generation 0006 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:36:01.517114
-Generation 0007 | Pareto Front Size: 2 | Timestamp: 2025-04-16T15:40:15.364620
-Generation 0008 | Pareto Front Size: 2 | Timestamp: 2025-04-16T15:47:35.288547
-Generation 0009 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:51:29.712877

src/lead/problems/mc/multi_objective_history/20250416_010845/generation_0.json

@@ -1,83 +0,0 @@
-{
-  "generation": 0,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available = [False] * n\n    \n    def get_neighbor_colors(node):\n        for neighbor in range(n):\n            if adj_matrix[node][neighbor] == 1 and colors[neighbor] != -1:\n                available[colors[neighbor]] = True\n\n    def assign_color(node):\n        get_neighbor_colors(node)\n        color = 0\n        while color < n:\n            if not available[color]:\n                colors[node] = color\n                break\n            color += 1\n        for neighbor in range(n):\n            if adj_matrix[node][neighbor] == 1 and colors[neighbor] != -1:\n                available[colors[neighbor]] = False\n    \n    for node in range(n):\n        if colors[node] == -1:\n            assign_color(node)\n        available = [False] * n\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.0018470287322998
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    \n    vertex_order = list(range(n))\n    random.shuffle(vertex_order)\n    \n    for vertex in vertex_order:\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        color = 0\n        while color < n and not available_colors[color]:\n            color += 1\n        \n        colors[vertex] = color\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.5306849479675293
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def greedy_coloring():\n        colors[0] = 0\n\n        for u in range(1, n):\n            available_colors[:] = [True] * n\n            \n            for v in range(n):\n                if adj_matrix[u][v] == 1 and colors[v] != -1:\n                    available_colors[colors[v]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[u] = color\n                    break\n\n    greedy_coloring()\n    \n    def optimize_colors():\n        color_count = max(colors) + 1\n        color_mapping = {i: [] for i in range(color_count)}\n        \n        for vertex in range(n):\n            if colors[vertex] != -1:\n                color_mapping[colors[vertex]].append(vertex)\n        \n        for color in range(color_count):\n            if not color_mapping[color]:\n                continue\n            for new_color in range(color + 1, color_count):\n                if new_color not in color_mapping:\n                    continue\n                is_codable = True\n                for v1 in color_mapping[color]:\n                    for v2 in color_mapping[new_color]:\n                        if adj_matrix[v1][v2] == 1:\n                            is_codable = False\n                            break\n                    if not is_codable:\n                        break\n                if is_codable:\n                    for v in color_mapping[new_color]:\n                        colors[v] = color\n                    del color_mapping[new_color]\n                    break\n\n    optimize_colors()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.539431095123291
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    available_colors = [False] * n\n    \n    def find_available_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return n\n\n    for vertex in range(n):\n        colors[vertex] = find_available_color(vertex)\n    \n    def optimize_coloring():\n        unique_colors = sorted(set(colors))\n        color_map = {old_color: new_color for new_color, old_color in enumerate(unique_colors)}\n        for i in range(n):\n            colors[i] = color_map[colors[i]]\n\n    optimize_coloring()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 2.813322067260742
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    \n    def get_available_colors(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        return available_colors\n\n    vertex_order = list(range(n))\n    random.shuffle(vertex_order)\n    \n    for vertex in vertex_order:\n        available_colors = get_available_colors(vertex)\n        \n        color = 0\n        while color < n and not available_colors[color]:\n            color += 1\n        \n        if color == n:\n            min_color_used = min([c for c in colors if c != -1], default=0)\n            color = min_color_used + 1\n        \n        colors[vertex] = color\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 2.3673529624938965
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n    \n    def assign_colors():\n        for node in range(n):\n            if colors[node] == -1:\n                reset_available()\n                for neighbor in range(n):\n                    if adj_matrix[node][neighbor] == 1 and colors[neighbor] != -1:\n                        available_colors[colors[neighbor]] = False\n                colors[node] = get_first_available_color()\n    \n    def reset_available():\n        for i in range(n):\n            available_colors[i] = True\n\n    def get_first_available_color():\n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return n\n\n    def local_search():\n        for node in range(n):\n            current_color = colors[node]\n            for try_color in range(n):\n                if try_color != current_color and is_valid_color_assignment(node, try_color):\n                    colors[node] = try_color\n                    break\n\n    def is_valid_color_assignment(node, color):\n        for neighbor in range(n):\n            if adj_matrix[node][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    assign_colors()\n    \n    for _ in range(n):\n        local_search()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": Infinity,
-        "execution_time": Infinity
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def is_color_possible(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def greedy_coloring():\n        for vertex in range(n):\n            available_colors[:] = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n\n    def local_search():\n        improved = True\n        while improved:\n            improved = False\n            for vertex in range(n):\n                current_color = colors[vertex]\n                conflict_colors = set()\n                for neighbor in range(n):\n                    if adj_matrix[vertex][neighbor] == 1:\n                        conflict_colors.add(colors[neighbor])\n                for new_color in range(len(conflict_colors) + 1):\n                    if new_color not in conflict_colors:\n                        if new_color != current_color:\n                            colors[vertex] = new_color\n                            improved = True\n                            break\n\n    local_search()\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": Infinity,
-        "execution_time": Infinity
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def greedy_coloring():\n        colors[0] = 0\n\n        for u in range(1, n):\n            available_colors[:] = [True] * n\n            \n            for v in range(n):\n                if adj_matrix[u][v] == 1 and colors[v] != -1:\n                    available_colors[colors[v]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[u] = color\n                    break\n\n    greedy_coloring()\n    \n    def optimize_colors():\n        color_count = max(colors) + 1\n        color_mapping = {i: [] for i in range(color_count)}\n        \n        for vertex in range(n):\n            if colors[vertex] != -1:\n                color_mapping[colors[vertex]].append(vertex)\n        \n        merged = True\n        while merged:\n            merged = False\n            for color in range(color_count):\n                if not color_mapping[color]:\n                    continue\n                for new_color in range(color + 1, color_count):\n                    if new_color not in color_mapping:\n                        continue\n                    is_codable = True\n                    for v1 in color_mapping[color]:\n                        for v2 in color_mapping[new_color]:\n                            if adj_matrix[v1][v2] == 1:\n                                is_codable = False\n                                break\n                        if not is_codable:\n                            break\n                    if is_codable:\n                        for v in color_mapping[new_color]:\n                            colors[v] = color\n                        del color_mapping[new_color]\n                        merged = True\n                        color_count -= 1\n                        break\n                if merged:\n                    break\n\n    optimize_colors()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 2.5284109115600586
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available = [False] * n\n    \n    def get_neighbor_colors(node):\n        for neighbor in range(n):\n            if adj_matrix[node][neighbor] == 1 and colors[neighbor] != -1:\n                available[colors[neighbor]] = True\n\n    def assign_color(node):\n        get_neighbor_colors(node)\n        color = 0\n        while color < n:\n            if not available[color]:\n                colors[node] = color\n                break\n            color += 1\n        for neighbor in range(n):\n            if adj_matrix[node][neighbor] == 1 and colors[neighbor] != -1:\n                available[colors[neighbor]] = False\n    \n    for node in range(n):\n        if colors[node] == -1:\n            assign_color(node)\n        available = [False] * n\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.0018470287322998
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_0.json

@@ -1,91 +0,0 @@
-{
-  "generation": 0,
-  "population": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9745118618011475
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0744099617004395
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9745118618011475
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 1.0532798767089844
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.081273078918457
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9857227802276611
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = True\n\n    for vertex in range(n):\n        if colors[vertex] == -1:\n            assign_color(vertex)\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.9481892585754395
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9745118618011475
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0744099617004395
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9745118618011475
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_1.json

@@ -1,115 +0,0 @@
-{
-  "generation": 1,
-  "population": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.026442050933838
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0927319526672363
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.149785041809082
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9988811016082764
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_2.json

@@ -1,99 +0,0 @@
-{
-  "generation": 2,
-  "population": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.026442050933838
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 1000,
-        "execution_time": 1.0046441555023193
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    greedy_coloring()\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.087792158126831
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.035233974456787
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0927319526672363
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def optimized_greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    optimized_greedy_coloring()\n    \n    return colors",
-      "generation": 3,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0933640003204346
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def assign_color(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    def greedy_coloring():\n        for vertex in vertices:\n            if colors[vertex] == -1:\n                assign_color(vertex)\n    \n    greedy_coloring()\n    \n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0939011573791504
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.026442050933838
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 1000,
-        "execution_time": 1.0046441555023193
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    greedy_coloring()\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.087792158126831
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_3.json

@@ -1,115 +0,0 @@
-{
-  "generation": 3,
-  "population": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return -1\n\n    for vertex in order:\n        colors[vertex] = optimized_color_selection(vertex)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.004497766494751
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 1000,
-        "execution_time": 1.0046441555023193
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
-      "generation": 0,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.035233974456787
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.9886589050292969
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return -1\n\n    for vertex in order:\n        colors[vertex] = optimized_color_selection(vertex)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 1.004497766494751
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_4.json

@@ -1,83 +0,0 @@
-{
-  "generation": 4,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9938340187072754
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.975269079208374
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0908830165863037
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        color_mapping = {}\n        next_color = 0\n        \n        for vertex in vertices:\n            available_colors = set(range(n))\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors.discard(colors[neighbor])\n            chosen_color = min(available_colors)\n            colors[vertex] = chosen_color\n            \n            if chosen_color not in color_mapping:\n                color_mapping[chosen_color] = next_color\n                next_color += 1\n            colors[vertex] = color_mapping[chosen_color]\n    \n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(unique_colors)}\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_map[colors[i]]\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.1260502338409424
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        min_color = n\n        for color in range(n):\n            if available_colors[color]:\n                min_color = min(min_color, color)\n        return min_color if min_color < n else -1\n\n    for vertex in order:\n        chosen_color = optimized_color_selection(vertex)\n        colors[vertex] = chosen_color\n\n    color_count = len(set(colors))\n    improvement = True\n\n    while improvement:\n        improvement = False\n        for vertex in order:\n            current_color = colors[vertex]\n            if current_color == -1:\n                continue\n            \n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color] and color != current_color:\n                    colors[vertex] = color\n                    new_color_count = len(set(colors))\n                    if new_color_count < color_count:\n                        color_count = new_color_count\n                        improvement = True\n                    else:\n                        colors[vertex] = current_color\n                    break\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 30,
-        "execution_time": 2.031809091567993
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_5.json

@@ -1,83 +0,0 @@
-{
-  "generation": 5,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.975269079208374
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0908830165863037
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    # Optimize color assignment to minimize color_count\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    # Remap colors to ensure they are contiguous and minimize color_count\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 3,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.1028988361358643
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_6.json

@@ -1,83 +0,0 @@
-{
-  "generation": 6,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9685137271881104
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0908830165863037
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.975269079208374
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 0.5790848731994629
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_7.json

@@ -1,91 +0,0 @@
-{
-  "generation": 7,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9685137271881104
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0908830165863037
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.975269079208374
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.6299710273742676
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9685137271881104
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_8.json

@@ -1,91 +0,0 @@
-{
-  "generation": 8,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9685137271881104
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 33,
-        "execution_time": 0.975269079208374
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.6299710273742676
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 3.362344980239868
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 0.9685137271881104
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_9.json

@@ -1,99 +0,0 @@
-{
-  "generation": 9,
-  "population": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0919930934906006
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 2.6567630767822266
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.6299710273742676
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 31,
-        "execution_time": 2.893918037414551
-      }
-    },
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    final_colors = [-1] * n\n    color_mapping = {}\n    next_color = 0\n\n    for i in range(n):\n        if colors[i] != -1:\n            if colors[i] not in color_mapping:\n                color_mapping[colors[i]] = next_color\n                next_color += 1\n            final_colors[i] = color_mapping[colors[i]]\n\n    return final_colors",
-      "generation": 5,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 2.8868300914764404
-      }
-    }
-  ],
-  "pareto_front": [
-    {
-      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 4,
-      "fitnesses": {
-        "color_count": 29,
-        "execution_time": 1.0881679058074951
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
-      "generation": 1,
-      "fitnesses": {
-        "color_count": 32,
-        "execution_time": 1.0035450458526611
-      }
-    },
-    {
-      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
-      "generation": 2,
-      "fitnesses": {
-        "color_count": 34,
-        "execution_time": 0.9917922019958496
-      }
-    }
-  ],
-  "objective_names": [
-    "color_count",
-    "execution_time"
-  ]
-}