Long-term multi-agent task allocation-oriented elastic graph coloring cultural genetic algorithm

Abstract

The application discloses an elastic graph coloring cultural gene algorithm for long-term multi-agent task allocation, and aims to solve the long-term task allocation problem in a warehouse scene. Tasks in such a scene are continuously generated and executed, and multiple challenges are faced in a long time span. The tasks continuously and unpredictably arrive, the planned execution time is easy to overlap, and the scheduling conflict management is difficult. The agent load is easy to be unbalanced, and the situation of task saturation of part of the agents and idling of part of the agents frequently occurs. After the scale of the tasks and the agents is expanded, the algorithm calculation complexity rises, and the system expansibility and real-time response are difficult to be considered. In the long-period operation, the deviation such as path congestion is continuously accumulated, and the optimization difficulty of the allocation scheme continuously increases. First, the long-term multi-agent task allocation problem is converted into an elastic graph coloring problem. The tasks are taken as nodes of a graph, and the associated relationship of the task plan execution time window with intersection is taken as an edge of the graph. The associated relationship represented by the edge is the node conflict. The "graph expansion-graph contraction" mechanism is used to adapt to the continuous arrival of the tasks. Second, a backbone crossover and Kempe mutation evolution strategy is designed. The excellent coloring structure without node conflict in the parent generation is reserved, and the locally optimal coloring scheme is jumped out. Finally, a local search for reducing the node conflict and balancing the task load of the agents is integrated by using the tabu search, the variable neighborhood descent and the self-adaptive confusion degree driving conflict resolution. The method realizes the stable conflict resolution and load balancing ability in the long-term continuous environment, provides an expandable task allocation framework for the continuous multi-agent cooperation, and exhibits stable performance advantages in the complex warehouse and robot cluster scene.

Description

Technical Field

[0001] This invention relates to the field of multi-agent systems and task scheduling technology, specifically to an elastic graph coloring culture gene algorithm for long-term multi-agent task allocation, applicable to scenarios such as intelligent warehousing that require continuous task processing, achieving long-term task allocation with shorter task cycle times. Background Technology

[0002] Multi-agent task allocation is a core research area in intelligent systems, aiming to rationally distribute a series of tasks among multiple agents to improve task execution efficiency. Traditional research on multi-agent task allocation often focuses on static scenarios, assuming that all tasks are known in advance and the environment is fixed. However, in practical applications, scenarios such as intelligent warehouse order processing and disaster relief dispatch exhibit "long-term" characteristics, meaning that new tasks continuously arrive, requiring algorithms to respond to changes in task states in real time and optimize allocation schemes.

[0003] Existing solutions have several limitations: some algorithms break down long-term task allocation into multiple independent subproblems and solve them sequentially, ignoring time overlap conflicts between tasks. That is, when the planned execution time windows of two tasks overlap, it leads to low scheduling efficiency and extended task cycle time. Some heuristic or exact optimization algorithms are only suitable for small-scale static scenarios. When faced with an increasing task scale, the computational complexity increases dramatically, making it difficult to meet real-time requirements. At the same time, most algorithms do not fully consider agent load balancing, which can easily lead to some agents receiving too many tasks while others are idle, further reducing the overall system performance.

[0004] Graph coloring and task allocation problems have a natural mapping relationship—nodes can correspond to tasks, edges can correspond to task scheduling conflicts, and colors can correspond to agents. However, traditional graph coloring models cannot adapt to long-term scenarios with increasing or decreasing tasks. Therefore, there is an urgent need for an intelligent optimization algorithm that can adjust the model structure and adapt to scenarios where tasks continuously arrive and are executed, in order to solve the pain points of "inefficient scheduling due to conflicts, poor real-time performance in large-scale scenarios, load imbalance, and incompatibility of traditional models" in long-term multi-agent task allocation. Summary of the Invention

[0005] The purpose of this invention is to provide an elastic graph coloring cultural gene algorithm for long-term multi-agent task allocation. By transforming the long-term multi-agent task allocation problem into an elastic graph coloring problem, and combining the global search and local optimization capabilities of the cultural gene algorithm, efficient task allocation is achieved, thereby solving the problems mentioned in the background art.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] A flexible graph-chromatic cultural gene algorithm for long-term multi-agent task allocation, characterized by the following steps:

[0008] S1. Problem Modeling: Transform the long-running multi-agent task allocation problem into a flexible graph coloring problem and construct the corresponding graph model. , where nodes Representing the task, side This represents the time overlap (scheduling conflict) between tasks. When the planned execution time windows of two tasks intersect, an edge will be generated between the corresponding nodes, and the color corresponds to the agent executing the task. The graph model can be dynamically adjusted as the task state changes, expanding when a new task is added and shrinking when a task is completed, thus adapting to long-term scenarios where tasks are continuously generated and completed.

[0009] S2. Algorithm Design: Design an elastic graph coloring culture gene algorithm, with the following specific steps:

[0010] S2.1 Define the population individuals using integer encoding. Each individual corresponds to a chromosome. The chromosome length is consistent with the current number of tasks. The gene position value represents the agent number assigned to the corresponding task. Based on this encoding, randomly select values ​​within the range of agent numbers to complete the population initialization.

[0011] S2.2 Using the current population as the parent population, randomly select individuals from the current population to join the mating pool;

[0012] S2.3. Subsequently, individuals in the mating pool are randomly paired, and the successfully paired individuals are crossbred to generate offspring.

[0013] S2.4. Then perform Kempe mutation on the generated offspring individuals;

[0014] S2.5 Then, perform a local search to resolve conflicts for the offspring individuals;

[0015] S2.6. Merge the parent and offspring populations, evaluate and select the optimal solution through the objective function, and retain elite individuals;

[0016] S2.7 Repeat steps S2.3 to S2.6 until the maximum number of iterations is reached;

[0017] S3, Output Task Allocation Scheme: Decode the optimal individual and output a conflict-free, low-cost long-term task allocation scheme;

[0018] As a preferred embodiment of the present invention, the specific content of the S1 problem modeling includes the following steps:

[0019] S4.1 Graph Model Definition: Constructing a Dynamic Undirected Graph ,in:

[0020] · Node set Each node For each task, the task attributes include arrival time. Planned start time Actual start time Pick-up location Delivery location Nodes change with the task's lifecycle; new nodes are added when a new task arrives, and nodes are deleted when a task is completed.

[0021] ·Edge set If the task With the task If the planned execution times overlap, then construct an edge. The edge represents a scheduling conflict between tasks;

[0022] • Color-agent mapping: Set of colors and set of agents One-to-one correspondence, coloring function Indicates the task allocation relationship, if ,but Assigned to intelligent agents Furthermore, adjacent nodes must be mapped to different colors to avoid conflicting tasks being executed by the same agent.

[0023] • Graph expansion: New tasks Upon arrival, calculate the time overlap with currently unfinished tasks. If it overlaps with... Add an edge if they overlap. At the same time Add to node set ;

[0024] • Image collapse: After the task is completed, from Delete the node, remove all associated edges, and update the adjacency relationships of the remaining nodes.

[0025] S4.2 Objective Function Construction: In the long-running multi-agent task allocation problem, the objective function is to minimize the task cycle time. It consists of two main parts: transportation cost, representing the time required for the agent to complete the task (from pickup to delivery); and task waiting time cost, representing the waiting time from the task arriving in the system to the agent actually starting to execute it. In summary, the task... Assigned to intelligent agents Transportation costs at that time The calculation formula is as follows:

[0026]

[0027] in This refers to an intelligent agent. In time Current location to task Pick-up point The time required This indicates the pickup to delivery location. The required time. Therefore, the overall objective function The calculation formula is:

[0028]

[0029] in It is a binary variable; if the task... Assigned to intelligent agents If the value is 1, then its value is 1; otherwise, it is 0. Indicates task Arrival time, Indicates task The actual start time. (Set) Indicates at time A set of tasks available for assignment.

[0030] In the transformed graph coloring problem, the optimization objective is to find a solution that minimizes the total cost. This includes task cycle time and time in time. The penalty for assigning conflicting tasks to the same agent, expressed as the transformed objective function, is:

[0031]

[0032] in Indicates time Task cycle time, This indicates a conflict penalty term, used to penalize violations in time. Conflict task and The case where they are assigned to the same agent.

[0033] As a preferred embodiment of the present invention, the random initialization operation of the population in S2 specifically includes the following steps:

[0034] S5.1 First, according to the logical order of time, classify the different Each task is numbered;

[0035] S5.2, Use a set of lengths of one-dimensional array Chromosomes, among which Indicates task The allocation agent;

[0036] S5.3, for each individual Each gene locus is randomly assigned an agent number.

[0037] As a preferred embodiment of the present invention, the backbone crossover operation in S2 is specifically as follows:

[0038] S6.1, For the two parent individuals involved in the crossover. and Extract the color class sets of both respectively, where The color class set is , The color class set is ,and Defined as The agent was assigned to the intelligent agent. The collection of all tasks, Defined as The agent was assigned to the intelligent agent. The collection of all tasks, The total number of agents is represented by the number of tasks, and each task set corresponds one-to-one with an agent (color).

[0039] S6.2 Construct a bipartite graph The two subsets of nodes in the bipartite graph Extracted from step S6.1 respectively Color class collection and The color class set constitutes the composition; for Any color class and Any color class Determine if the intersection of the task sets of the two is non-empty. If the intersection is non-empty, add a connection to the bipartite graph. and edge The weight of this edge is set to the number of tasks in the intersection of the two color classes, thereby quantifying the degree of task sharing between the two color classes;

[0040] S6.3. Apply a greedy algorithm to the bipartite graph constructed in step S6.2. Perform maximum weight matching; for successfully matched color class pairs... The tasks in the intersection of the two color classes are defined as "backbone genes", and the allocation relationship of these tasks is directly inherited to offspring individuals;

[0041] S6.4 For the unmatched task nodes in step S6.3 (i.e., tasks not included in any intersection of matching color class pairs), calculate the number of conflicts between each unmatched task and all current color classes (the number of conflicts is the number of times the task overlaps with existing tasks in the color class); sort the color classes in ascending order of the number of conflicts, and assign the unmatched tasks to the color class with the fewest conflicts, until all unmatched tasks have been assigned, generating a complete offspring individual. .

[0042] As a preferred embodiment of the present invention, the specific steps of the Kempe mutation in S2 are as follows:

[0043] S7.1 Randomly select two different colors from the color set corresponding to the agent, denoted as . and (satisfy ), (This refers to the total number of agents, i.e., the total number of colors).

[0044] S7.2. Randomly select an individual to be mutated from the current population. This individual corresponds to a set of task allocation schemes, the structure of which is a chromosome based on a graph coloring model (nodes represent tasks, and colors represent agent allocation results). Let the graph corresponding to this individual be denoted as . in This refers to the set of task nodes contained in this individual. This is the set of conflicting edges between task nodes (the existence of an edge indicates that the time of two tasks overlaps).

[0045] S7.3, The set of task nodes corresponding to the individuals selected in step S7.2 In the process, a task node is randomly selected as the starting node, denoted as . Check the color of the starting node to ensure it matches the color selected in step S7.1. or If the condition is not met, a new starting node is randomly selected until a node with the specified color is found. or Task nodes;

[0046] S7.4, The starting node determined in step S7.3 Starting from the graph, a depth-first search is used to traverse the graph. During the traversal, only colors are retained. or A node must be a color, and its adjacent nodes (nodes with conflicting edges) must all belong to the same color group. or The connected subgraph formed by all nodes that satisfy the conditions is defined as a Kempe chain, denoted as . Ensure that the color of all nodes within this Kempe chain is only [color]. or The subgraph is connected and has no isolated nodes;

[0047] S7.5, the Kempe chain in step S7.4 Perform a color swap operation on all nodes within the chain: change the color of the nodes in the chain to 1. The nodes are uniformly redistributed as colors. (Corresponding agent switching) (corresponding intelligent agent), will set the color of the chain to The nodes are uniformly redistributed as colors. (The corresponding intelligent agent is switched to) (Corresponding intelligent agent).

[0048] As a preferred embodiment of the present invention: the specific steps of the local search for resolving conflicts in S2 are as follows. This local search integrates three major strategies: tabu search, variable neighborhood descent, and adaptive popping based on perplexity. It optimizes the sub-solutions in stages to reduce the number of conflicts and shorten the task cycle time. Specifically, it includes:

[0049] S8.1 Initialization of the mutated solution Set the maximum number of local search iterations for the current solution. Simultaneously initialize the taboo state matrix. (Dimension is the number of tasks) × Number of agents ), used to record taboo relationships between tasks and agents (nodes and colors).

[0050] S8.2, Traverse the current solution Corresponding graph model Check for conflict edges between all task nodes. Filter out the set of task nodes that have conflicts. That is, the same agent is assigned task nodes that overlap in time; if If the result is empty, proceed directly to step S8.8; otherwise, proceed to step S8.3.

[0051] S8.3, For sets Each conflict node in Perform the following operations: Iterate through all non-taboo agents. (Right now ), calculate the nodes Reassigned to intelligent agents The amount of conflict reduction afterward ( (The difference between the original number of conflicts and the new number of conflicts); select The largest intelligent agent , will node Assigned to Update the current solution Simultaneously update the taboo matrix.

[0052] S8.4 Setting the Neighborhood Operator Sequence ( For relocation operators, For the exchange operator, For dual positioning operators, (For segment exchange operators), initialize the neighborhood index. And record the optimal solution in the current neighborhood. ;

[0053] S8.5, Call the current index Corresponding neighborhood operator pairs Perform a disturbance:

[0054] like (Relocation operator): Randomly selects a task node. Remove it from the current agent's task sequence and insert it into the task sequence of the same or other agents to generate a neighborhood solution. ;

[0055] like (Exchange operator): Randomly select two different task nodes. and By swapping the allocation agents of the two, a neighborhood solution is generated. ;

[0056] like (Dual positioning operator): Randomly select two consecutive task nodes and The two are removed as a whole from the current agent and inserted into the task sequence of the same or other agents to generate a neighborhood solution. ;

[0057] like (Segment exchange operator): Randomly select two sets of consecutive task nodes. and By swapping the allocation agents of the two sets of nodes, a neighborhood solution is generated. ;

[0058] S8.6 Calculate the neighborhood solution fitness value ;like Then update and reset the neighborhood index. Return to step S8.5; if Then the neighborhood index Add 1, if Then return to step S8.5, if Then the current variable neighborhood descent process ends, and Updated to ;

[0059] S8.7 Calculate the current solution Individual perplexity ( For population size, For indicator functions, hour (Otherwise 0), and calculate the bounce rate. If random numbers Then: Calculate the number of tasks for each agent. ( Indicates task Assigned to intelligent agents (otherwise 0), and calculate the gene perplexity. (in , For intelligent agents (Task allocation frequency); filter by task quantity The intelligent agent puts its tasks into a pop-up set. ;right Each task in traverse other intelligent agents Choose the conflict-free option (i.e.) and Existing tasks have no time overlap) and The smallest intelligent agent will Reallocation, Update ;

[0060] S8.8 If the current iteration count reaches Then Updated to Output the result; otherwise, increment the iteration count by 1, return to step S8.2, and continue the local search process.

[0061] Compared with the prior art, the advantages of the present invention are:

[0062] 1. Flexible Graph Modeling Mechanism: Existing technologies often use fixed models to handle multi-agent task allocation, which cannot adapt to the continuous arrival of tasks in long-term scenarios. This easily leads to a disconnect between the model and the actual task state, increasing the risk of scheduling conflicts. This invention innovatively transforms the long-term multi-agent task allocation problem into a flexible graph coloring problem, constructing an undirected graph. Through a bidirectional adjustment mechanism of "graph expansion-graph contraction," it adapts to changes in task state in real time—automatically adding nodes and conflicting edges when a new task arrives, and synchronously deleting nodes and related edges when a task is completed, ensuring that the graph model always accurately matches the current task distribution and conflict relationships. This mechanism does not require re-initializing the model for each task change, significantly improving the algorithm's adaptability to scenarios where long-term tasks continuously arrive and are executed, and solving the inefficiency problem caused by the traditional static model's "one-time modeling, multiple solutions."

[0063] 2. Backbone Crossover-Kempe Mutation Evolutionary Strategy: Existing evolutionary algorithms, when dealing with task allocation problems, either suffer from the loss of superior genes in the parent generation due to blind recombination by the crossover operator, or from the destruction of the legitimacy of the solution due to excessive perturbation by the mutation operator, making it difficult to balance global exploration and local optimization. This invention designs a backbone crossover operator and a Kempe mutation operator: Backbone crossover constructs a bipartite graph of parent color classes, matching and preserving backbone genes with maximum weight, ensuring that offspring inherit the high-quality allocation structure of the parent generation without conflict and with low cycle time. At the same time, it greedily allocates unmatched tasks according to the principle of minimum conflict, balancing population diversity; Kempe mutation identifies connected subgraphs of specific colors and swaps colors within the chain, breaking local optima while maintaining the legitimacy of the solution, thus avoiding premature convergence of the algorithm.

[0064] 3. Multi-strategy integrated local search for conflict resolution: Existing local search algorithms often employ single neighborhood operators or tabu strategies, which are insufficient for resolving task conflicts and prone to problems such as "repeated node conflicts" and "load imbalance." This invention integrates three strategies—tabu search, variable neighborhood descent, and perplexity-based adaptive popping—to construct a local search for conflict resolution: Tabu search avoids repeated searches through tabu tenure, quickly locates conflicting nodes, and optimizes allocation; Variable neighborhood descent sequentially calls four operators—relocation, exchange, dual location, and segment exchange—to explore the solution space in multiple dimensions and gradually reduce the task cycle; The adaptive popping strategy calculates individual perplexity and gene perplexity to identify high-load agents and pop excess tasks, redistributing them to agents without node conflicts and with low load, thus balancing the global load. Attached Figure Description

[0065] Figure 1 A flowchart for the elastic graph coloring culture gene algorithm;

[0066] Figure 2 A schematic diagram of the long-term multi-agent task assignment transition graph coloring problem;

[0067] Figure 3 A schematic diagram of chromosome coloring for the backbone crossing strategy;

[0068] Figure 4 A schematic diagram of chromosome coloring for the Kempe mutation strategy; Detailed Implementation

[0069] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0070] Please see Figure 1 This invention provides an implementation method, taking the task allocation of a certain intelligent warehousing robot as an example:

[0071] This embodiment uses the scheduling of robotic sorting tasks in a large-scale intelligent e-commerce warehouse as an application scenario. Multiple autonomous mobile robots (i.e., agents) are deployed within the warehouse, continuously processing sorting tasks generated by an external order system. Each sorting task includes arrival time, pickup location, delivery location, and estimated execution time. The core constraints are: only one robot is allowed to operate in the same pickup area within the same time window (to avoid spatial conflicts); a robot can only execute one task at a time, and the load on each robot needs to be balanced to avoid local congestion or idleness. Since these tasks may have overlapping execution times, they should be assigned to different agents to improve efficiency. This setup can be abstracted as a graph coloring problem, where each task is represented as a node, and overlapping time portions are the edges between them. Below, we first provide the relevant definitions of this problem.

[0072] • Tasks: Task Collection The task attributes include arrival time. Planned start time Actual start time Pick-up location Delivery location Nodes change with the task's lifecycle; new nodes are added when a new task arrives, and nodes are deleted when a task is completed.

[0073] • Intelligent agent: A collection of intelligent agents When an intelligent agent performs a task First, let's start with the moment. Current location Proceed to the mission Pick-up location Perform the pickup task and then proceed to the delivery location. The task is now complete.

[0074] In the long-running multi-agent task allocation problem, the objective function is to minimize the task cycle time. It consists of two main parts: transportation cost, representing the time required for the agent to complete the task (from pickup to delivery), and task waiting time cost, representing the waiting time from the task arriving in the system to the agent actually starting to execute it. In summary, the task... Assigned to intelligent agents Transportation costs at that time The calculation formula is as follows:

[0075]

[0076] in This refers to an intelligent agent. In time Current location to task Pick-up point The time required This indicates the pickup to delivery location. The required time. Therefore, the overall objective function The calculation formula is:

[0077]

[0078] in It is a binary variable; if the task... Assigned to intelligent agents If the value is 1, then its value is 1; otherwise, it is 0. Indicates task Arrival time, Indicates task The actual start time. (Set) Indicates at time A set of tasks available for assignment.

[0079] In long-term scenarios, tasks arrive sequentially, and the graph structure should be flexible, allowing for the addition of new tasks and the removal of completed ones. Therefore, the long-term multi-agent task assignment problem can be modeled as a flexible graph coloring problem, where new tasks are added based on their temporal overlap with existing tasks, and completed tasks are removed.

[0080] like Figure 2 As shown in (b), at time ,Task and It has arrived and needs to be assigned to an agent for execution. Meanwhile, the task... It has not yet reached its expected start time, and due to the mission... The execution time is extended and related to the task A conflict occurred, therefore the mission A reallocation is required. Below, we provide the definition of the transformed graph coloring problem.

[0081] ·Transformation diagram The long-term multi-agent task assignment problem is formulated as an undirected graph. Each node Represents an edge between two nodes, indicating a task. This indicates the overlap in execution time between tasks. Coloring nodes ensures that adjacent nodes are assigned different colors, which correspond to different agents.

[0082] • Overlapping execution times: If tasks With the task If the planned execution times overlap, then construct an edge. When two tasks are assigned to the same agent and scheduled to be executed within overlapping time periods, it indicates a conflict.

[0083] • Conflicting edges: The edge set contains all pairs of tasks with overlapping execution times. These conflicting tasks should be assigned to different agents. The edge set needs to ensure that no two adjacent nodes (conflicting tasks) are assigned the same color (agent).

[0084] In the transformed graph coloring problem, the optimization objective is to find a solution that minimizes the total cost. This includes task cycle time and time in time. The penalty for assigning conflicting tasks to the same agent, expressed as the transformed objective function, is:

[0085]

[0086] in Indicates time Task cycle time, This indicates a conflict penalty term, used to penalize violations in time. Conflict task and Assigned to the same agent The situation.

[0087] By modeling the LMATA problem as a graph coloring problem, a flexible graph coloring culture gene algorithm for long-term multi-agent task assignment is proposed.

[0088] 1. Population Initialization: Chromosomes in the population are initially generated randomly. Each chromosome encodes a specific task assignment scheme, representing a candidate solution. The size of each chromosome adaptively changes over time, allowing each individual to adapt to the evolving task assignment process. If a task is currently being executed, it remains in the gene location, and the assignment remains unchanged. New tasks are added to the gene location upon arrival and removed once the task is completed.

[0089] 2. Backbone Cross: First, construct a bipartite graph. The two subsets of nodes in the bipartite graph Each from the parent generation and It consists of a set of color classes, where The color class set is , The color class set is ,and Defined as The agent was assigned to the intelligent agent. The collection of all tasks, Defined as The agent was assigned to the intelligent agent. The set of all tasks, for Any color class and Any color class Then, determine if the intersection of the task sets of the two is non-empty. If the intersection is non-empty, add a connection in the bipartite graph. and edge The weight of the edge is set to the number of tasks in the intersection of the two color classes, and a greedy algorithm is used to process the constructed bipartite graph. Perform maximum weight matching; for successfully matched color class pairs... Tasks within the intersection of two color classes are defined as "backbone genes," and their assignment relationships are directly inherited to offspring individuals. For unmatched task nodes (i.e., tasks not included in any matching color class intersection), the number of conflicts between each unmatched task and all current color classes is calculated (the number of conflicts is the number of times the task overlaps with existing tasks in the color class). Color classes are sorted in ascending order of conflict count, and unmatched tasks are assigned to the color class with the fewest conflicts until all unmatched tasks are assigned, generating complete offspring individuals. The specific implementation process of the above-mentioned core cross-training strategy is as follows: Figure 3 As shown.

[0090] 3. Kempe Mutation: Randomly select two different colors from the set of colors corresponding to the agent, denoted as Kempe. and (satisfy ), (The total number of agents, i.e., the total number of colors); randomly select an individual to be mutated from the current population. This individual corresponds to a set of task allocation schemes, the structure of which is a chromosome based on a graph coloring model (nodes are tasks, colors are agent allocation results). The graph corresponding to this individual is denoted as . in This refers to the set of task nodes contained in this individual. The set of conflicting edges between task nodes (the existence of an edge indicates that the time of two tasks overlaps), and the set of task nodes corresponding to an individual. In the process, a task node is randomly selected as the starting node, denoted as . Check the color of the starting node; ensure its color is [color to be specified]. or If the condition is not met, a new starting node is randomly selected until a node with the specified color is found. or The task nodes are then traversed using a depth-first search. During the traversal, only colors are retained. or A node must be a color, and its adjacent nodes (nodes with conflicting edges) must all belong to the same color group. or The connected subgraph formed by all nodes that satisfy the conditions is defined as a Kempe chain, denoted as . Ensure that the color of all nodes within this Kempe chain is only [color]. or Then to Perform a color swap operation on all nodes within the chain: change the color of the nodes in the chain to 1. The nodes are uniformly redistributed as colors. (Corresponding agent switching) (corresponding intelligent agent), will set the color of the chain to The nodes are uniformly redistributed as colors. (The corresponding intelligent agent is switched to) (The corresponding agent). The specific implementation process of the above Kempe mutation strategy is as follows: Figure 4 As shown.

[0091] 4. Local Search for Conflict Resolution: This local search integrates three strategies: tabu search, variable neighborhood descent, and perplexity-based adaptive popping. It optimizes sub-solutions in stages to reduce the number of conflicts and shorten task cycle time. Specifically, it includes:

[0092] Tabu search: Solution after initialization and mutation Set the maximum number of local search iterations for the current solution. Simultaneously initialize the taboo state matrix. (Dimension is the number of tasks) × Number of agents This is used to record the taboo relationships between tasks and agents (nodes and colors). Traverse the current solution. Corresponding graph model Check for conflict edges between all task nodes. Filter out the set of task nodes that have conflicts. That is, the same agent is assigned task nodes that overlap in time; if If the set is empty, proceed to the next iteration; otherwise, check the set. Each conflict node in Perform the following operations: Iterate through all non-taboo agents. (Right now ), calculate the nodes Reassigned to intelligent agents The amount of conflict reduction afterward ( (The difference between the original number of conflicts and the new number of conflicts); select The largest intelligent agent , will node Assigned to Update the current solution Simultaneously update the taboo matrix.

[0093] Variable neighborhood descent: Then set the neighborhood operator sequence ( For relocation operators, For the exchange operator, For dual positioning operators, (For segment exchange operators), initialize the neighborhood index. And record the optimal solution in the current neighborhood. Call the current index Corresponding neighborhood operator pairs Perform a disturbance:

[0094] like (Relocation operator): Randomly selects a task node. Remove it from the current agent's task sequence and insert it into the task sequence of the same or other agents to generate a neighborhood solution. ;

[0095] like (Exchange operator): Randomly select two different task nodes. and By swapping the allocation agents of the two, a neighborhood solution is generated. ;

[0096] like (Dual positioning operator): Randomly select two consecutive task nodes and The two are removed as a whole from the current agent and inserted into the task sequence of the same or other agents to generate a neighborhood solution. ;

[0097] like (Segment exchange operator): Randomly select two sets of consecutive task nodes. and By swapping the allocation agents of the two sets of nodes, a neighborhood solution is generated. ;

[0098] Calculate neighborhood solutions fitness value ;like Then update and reset the neighborhood index. ;like Then the neighborhood index Add 1, if Then the current variable neighborhood descent process ends, and Updated to ;

[0099] Perplexity-based adaptive pop: Calculate the current solution Individual perplexity ( For population size, For indicator functions, hour (Otherwise 0), and calculate the bounce rate. If random numbers Then: Calculate the number of tasks for each agent. ( Indicates task Assigned to intelligent agents (otherwise 0), and calculate the gene perplexity. (in , For intelligent agents (Task allocation frequency); filter by task quantity The intelligent agent puts its tasks into a pop-up set. ;right Each task in traverse other intelligent agents Choose the conflict-free option (i.e.) and Existing tasks have no time overlap) and The smallest intelligent agent will Reallocation, Update If the current iteration count reaches Then Updated to Output the result; otherwise, increment the iteration count by 1 and continue the local search process.

Claims

1. A flexible graph coloring culture gene algorithm for long-term multi-agent task allocation, characterized in that, Specifically, the following steps are included: S1. Problem Modeling: The long-term multi-agent task allocation problem is transformed into a flexible graph coloring problem, and the corresponding graph model is constructed. , where nodes Representing the task, side This represents the time overlap (scheduling conflict) between tasks. When the planned execution time windows of two tasks intersect, an edge will be generated between the corresponding nodes, and the color corresponds to the agent executing the task. The graph model can be dynamically adjusted as the task state changes, expanding when a new task is added and shrinking when a task is completed, thus adapting to long-term scenarios where tasks are continuously generated and completed. S2. Algorithm Design: Design an elastic graph coloring culture gene algorithm, with the following specific steps: S2.1 Define the population individuals using integer encoding. Each individual corresponds to a chromosome. The chromosome length is consistent with the current number of tasks. The gene position value represents the agent sequence number assigned to the corresponding task. Based on this encoding, values ​​are randomly selected from the range of agent numbers to complete population initialization; S2.2 Using the current population as the parent population, randomly select individuals from the current population to join the mating pool; S2.

3. Subsequently, individuals in the mating pool are randomly paired, and the successfully paired individuals are crossbred to generate offspring. S2.

4. Then perform Kempe mutation on the generated offspring individuals; S2.5 Then, perform a local search to resolve conflicts for the offspring individuals; S2.

6. Merge the parent and offspring populations, evaluate and select the optimal solution through the objective function, and retain elite individuals; S2.7 Repeat steps S2.3 to S2.6 until the maximum number of iterations is reached; S3, Output Task Allocation Scheme: Decode the optimal individual and output a conflict-free, low-cost long-term task allocation scheme.

2. The elastic graph coloring culture gene algorithm for long-term multi-agent task allocation according to claim 1, characterized in that: The specific steps involved in modeling the S1 problem are as follows: S4.1 Graph Model Definition: Constructing a Dynamic Undirected Graph ,in: · Node set Each node For each task, the task attributes include arrival time. Planned start time Actual start time Pick-up location Delivery location Nodes change with the task's lifecycle; new nodes are added when a new task arrives, and nodes are deleted when a task is completed. ·Edge set If the task With the task If the planned execution times overlap, then construct an edge. The edge represents a scheduling conflict between tasks; • Color-agent mapping: Set of colors and set of agents One-to-one correspondence, coloring function Indicates the task allocation relationship, if ,but Assigned to intelligent agents Furthermore, adjacent nodes must be mapped to different colors to avoid conflicting tasks being executed by the same agent. • Graph expansion: New tasks Upon arrival, calculate the time overlap with currently unfinished tasks. If it overlaps with... Add an edge if they overlap. At the same time Add to node set ; • Image collapse: After the task is completed, from Delete the node, remove all associated edges, and update the adjacency relationships of the remaining nodes. S4.2 Objective Function Construction: In the long-running multi-agent task allocation problem, the objective function is to minimize the task cycle time. It consists of two main parts: transportation cost, representing the time required for the agent to complete the task (from pickup to delivery); and task waiting time cost, representing the waiting time from the task arriving in the system to the agent actually starting to execute it. In summary, the task... Assigned to intelligent agents Transportation costs at that time The calculation formula is as follows: in This refers to an intelligent agent. In time Current location to task Pick-up point The time required This indicates the pickup to delivery location. The required time. Therefore, the overall objective function The calculation formula is: in It is a binary variable; if the task... Assigned to intelligent agents If the value is 1, then its value is 1; otherwise, it is 0. Indicates task Arrival time, Indicates task The actual start time. (Set) Indicates at time A set of tasks available for assignment. In the transformed graph coloring problem, the optimization objective is to find a solution that minimizes the total cost. This includes task cycle time and time in time. The penalty for assigning conflicting tasks to the same agent, expressed as the transformed objective function, is: in Indicates time Task cycle time, This indicates a conflict penalty term, used to penalize violations in time. Conflict task and The case where they are assigned to the same agent.

3. The elastic graph coloring culture gene algorithm for long-term multi-agent task allocation according to claim 1, characterized in that: The random initialization operation of the population in S2 specifically includes the following steps: S5.1 First, according to the logical order of time, classify the different Each task is numbered; S5.2, Use a set of lengths of one-dimensional array Chromosomes, among which Indicates task The allocation agent; S5.3, for each individual Each gene locus is randomly assigned an agent number.

4. The elastic graph coloring culture gene algorithm for long-term multi-agent task allocation according to claim 1, characterized in that: The specific backbone crossing operation in S2 is as follows: S6.1, For the two parent individuals involved in the crossover. and Extract the color class sets of both respectively, where The color class set is , The color class set is ,and Defined as The agent was assigned to the intelligent agent. The collection of all tasks, Defined as The agent was assigned to the intelligent agent. The collection of all tasks, The total number of agents is represented by the number of tasks, and each task set corresponds one-to-one with an agent (color). S6.2 Construct a bipartite graph The two subsets of nodes in the bipartite graph Extracted from step S6.1 respectively Color class collection and The color class set constitutes the composition; for Any color class and Any color class Determine if the intersection of the task sets of the two is non-empty. If the intersection is non-empty, add a connection to the bipartite graph. and edge The weight of this edge is set to the number of tasks in the intersection of the two color classes, thereby quantifying the degree of task sharing between the two color classes; S6.

3. Apply a greedy algorithm to the bipartite graph constructed in step S6.

2. Perform maximum weight matching; for successfully matched color class pairs... The tasks in the intersection of the two color classes are defined as "backbone genes", and the allocation relationship of these tasks is directly inherited to offspring individuals; S6.4 For the unmatched task nodes in step S6.3 (i.e., tasks not included in any intersection of matching color class pairs), calculate the number of conflicts between each unmatched task and all current color classes (the number of conflicts is the number of times the task overlaps with existing tasks in the color class); sort the color classes in ascending order of the number of conflicts, and assign the unmatched tasks to the color class with the fewest conflicts, until all unmatched tasks have been assigned, generating a complete offspring individual. .

5. The elastic graph coloring culture gene algorithm for long-term multi-agent task allocation according to claim 1, characterized in that: The specific steps of the Kempe mutation in S2 are as follows: S7.1 Randomly select two different colors from the color set corresponding to the agent, denoted as . and (satisfy ), (This refers to the total number of agents, i.e., the total number of colors). S7.

2. Randomly select an individual to be mutated from the current population. This individual corresponds to a set of task allocation schemes, the structure of which is a chromosome based on a graph coloring model (nodes represent tasks, and colors represent agent allocation results). Let the graph corresponding to this individual be denoted as . in This refers to the set of task nodes contained in this individual. This is the set of conflicting edges between task nodes (the existence of an edge indicates that the time of two tasks overlaps). S7.3, The set of task nodes corresponding to the individuals selected in step S7.2 In the process, a task node is randomly selected as the starting node, denoted as . Check the color of the starting node to ensure it matches the color selected in step S7.

1. or If the condition is not met, a new starting node is randomly selected until a node with the specified color is found. or Task nodes; S7.4, The starting node determined in step S7.3 Starting from the graph, a depth-first search is used to traverse the graph. During the traversal, only colors are retained. or A node must be a color, and its adjacent nodes (nodes with conflicting edges) must all belong to the same color group. or The connected subgraph formed by all nodes that satisfy the conditions is defined as a Kempe chain, denoted as . Ensure that the color of all nodes within this Kempe chain is only [color]. or The subgraph is connected and has no isolated nodes; S7.5, the Kempe chain in step S7.4 Perform a color swap operation on all nodes within the chain: change the color of the nodes in the chain to 1. The nodes are uniformly redistributed as colors. (Corresponding agent switching) (corresponding intelligent agent), will set the color of the chain to The nodes are uniformly redistributed as colors. (The corresponding intelligent agent is switched to) (Corresponding intelligent agent).

6. The elastic graph coloring culture gene algorithm for long-term multi-agent task allocation according to claim 1, characterized in that: The specific steps of the local search for conflict resolution in S2 are as follows: This local search integrates three major strategies: tabu search, variable neighborhood descent, and adaptive popping based on perplexity. It optimizes the sub-solutions in stages to reduce the number of conflicts and shorten the task cycle time. Specifically, it includes: S8.1 Initialization of the mutated solution Set the maximum number of local search iterations for the current solution. Simultaneously initialize the taboo state matrix. (Dimension is the number of tasks) × Number of agents ), used to record taboo relationships between tasks and agents (nodes and colors). S8.2, Traverse the current solution Corresponding graph model Check for conflict edges between all task nodes. Filter out the set of task nodes that have conflicts. That is, the same agent is assigned task nodes that overlap in time; if If the result is empty, proceed directly to step S8.8; otherwise, proceed to step S8.

3. S8.3, For sets Each conflict node in Perform the following operations: Iterate through all non-taboo agents. (Right now ), calculate the nodes Reassigned to intelligent agents The amount of conflict reduction afterward ( (The difference between the original number of conflicts and the new number of conflicts); select The largest intelligent agent , will node Assigned to Update the current solution Simultaneously update the taboo matrix. S8.4 Setting the Neighborhood Operator Sequence ( For relocation operators, For the exchange operator, For dual positioning operators, (For segment exchange operators), initialize the neighborhood index. And record the optimal solution in the current neighborhood. ; S8.5, Call the current index Corresponding neighborhood operator pairs Perform a disturbance: like (Relocation operator): Randomly selects a task node. Remove it from the current agent's task sequence and insert it into the task sequence of the same or other agents to generate a neighborhood solution. ; like (Exchange operator): Randomly select two different task nodes. and By swapping the allocation agents of the two, a neighborhood solution is generated. ; like (Dual positioning operator): Randomly select two consecutive task nodes and The two are removed as a whole from the current agent and inserted into the task sequence of the same or other agents to generate a neighborhood solution. ; like (Segment exchange operator): Randomly select two sets of consecutive task nodes. and By swapping the allocation agents of the two sets of nodes, a neighborhood solution is generated. ; S8.6 Calculate the neighborhood solution fitness value ;like Then update and reset the neighborhood index. Return to step S8.5; if Then the neighborhood index Add 1, if Then return to step S8.5, if Then the current variable neighborhood descent process ends, and Updated to ; S8.7 Calculate the current solution Individual perplexity ( For population size, For indicator functions, hour (Otherwise 0), and calculate the bounce rate. If random numbers Then: Calculate the number of tasks for each agent. ( Indicates task Assigned to intelligent agents (otherwise 0), and calculate the gene perplexity. (in , For intelligent agents (Task allocation frequency); filter by task quantity The intelligent agent puts its tasks into a pop-up set. ;right Each task in traverse other intelligent agents Choose the conflict-free option (i.e.) and Existing tasks have no time overlap) and The smallest intelligent agent will Reallocation, Update ; S8.8 If the current iteration count reaches Then Updated to Output the result; otherwise, increment the iteration count by 1, return to step S8.2, and continue the local search process.

Images