Multi-star task assignment method based on conflict graph minimum weight vertex cover

Abstract

The present application relates to a kind of multi-star task allocation method based on conflict graph minimum weight vertex cover, for the multi-star task allocation problem with filtering constraint, pair constraint and cumulative constraint, utilize the minimum weight vertex cover in graph theory and neighborhood search design a kind of centralized optimization algorithm.Satellite's feasible observation window is regarded as vertex, pair constraint conflict is regarded as edge, observation benefit is regarded as vertex weight, constructs pair constraint conflict graph, the original problem is converted into the iterative optimization solution containing conflict graph vertex cover and cumulative constraint satisfaction;Based on neighborhood search technology, minimum weight vertex cover solving algorithm and cumulative constraint elimination operator are designed, can effectively guarantee the fast calculation of task allocation scheme.

Description

Technical Field

[0001] This invention relates to the field of multi-star task allocation, and more particularly to a multi-star task allocation method based on the minimum weight vertex cover of a conflict graph. Background Technology

[0002] With the ever-increasing demand for Earth observation, the paradigm for space satellite remote sensing operations has shifted from single large spacecraft to distributed satellite constellations. A group of satellite platforms operating in different orbits carry heterogeneous remote sensing equipment to collect specific observation target information based on customer observation requests. Distributed remote sensing systems offer significant advantages, including shorter revisit cycles, wider coverage, better robustness, and greater flexibility in response to changes in the environment and requests. However, they also present numerous challenges to mission allocation and scheduling.

[0003] Task allocation and scheduling aims to assign appropriate observation task sequences to a group of remote sensing satellites, maximizing global evaluation metrics while adhering to a series of pairwise and cumulative constraints, thereby maximizing the utilization of limited resources. Since this problem is essentially an NP-hard combinatorial optimization with complex space constraints, centralized optimization methods provide a powerful solution. In this approach, a centralized control node acquires information about all individual satellites via network communication and calculates feasible solutions or globally approximate optimal solutions based on centralized optimization or search strategies. For example, This paper studies the observation scheduling problem for agile satellites, models it as a constraint satisfaction problem (CSP), and compares the performance of typical solvers. While this method can well describe constraints and evaluation metrics, different constraint satisfaction models need to be constructed for different specific mission scenarios. Gabrel focuses on task allocation for a single Earth observation satellite, describing it as a multi-criteria path finding process of acyclic paths in a directed graph, and proposes a two-stage algorithm to compute a satisfactory global task allocation scheme. Although these graphs can adequately represent the temporal and conflict relationships between multiple observations, existing models struggle to describe the constraints and optimization objectives among multiple satellites. Furthermore, satellite task allocation is often simplified into various classical problems. For example, some scholars have proposed a 0-1 knapsack model for satellite task scheduling. Barkaouia and Berger proposed a VRPTW-inspired hybrid genetic algorithm using the Vehicle Path Problem with Time Windows (VRPTW). While many methods can be used for modeling and algorithm design, existing work has poor scalability and struggles to handle more complex observation scenarios. Furthermore, although metaheuristic swarm intelligence has made some improvements in handling NP-hard problems, including evolutionary algorithms, ant colony algorithms, and particle swarm algorithms, most existing methods only include simple or even naive generalizations of basic operators, failing to fully utilize the problem structure and related domain knowledge. This results in drawbacks such as computational time consumption and poor optimization performance when solving large-scale satellite mission allocation problems.

[0004] Minimum Weight Vertex Cover (MWVC) is a classic NP-hard combinatorial optimization problem in graph theory. Consider any given simple undirected graph G = {V, E}, where each node v i It has a positive weight ω i A vertex cover is a vertex set S that contains at least one vertex for all edges. The goal of this problem is to find the vertex cover scheme with the minimum sum of weights. If each feasible observation window is considered as a vertex, the pairwise constraints between feasible observation windows are considered as undirected edges, and the observation reward of the task corresponding to the feasible observation window is considered as the vertex weight, then a global pairwise constraint conflict graph can be constructed, and a task allocation scheme that satisfies the pairwise constraints can be obtained through MWVC computation.

[0005] In summary, most existing satellite mission allocation methods suffer from difficulties in describing inter-satellite constraints and optimization objectives, exhibit poor scalability, and struggle to handle complex observation scenarios. Furthermore, the optimization algorithms employed fail to fully utilize the problem structure and relevant domain knowledge, resulting in computational overhead and poor optimization performance, making them unsuitable for solving large-scale constellation mission allocation problems. The Multi-Way Satellite Mission Control (MWVC) problem offers a novel perspective for modeling and algorithm design in satellite mission allocation, particularly for large-scale constellations. Summary of the Invention

[0006] To address the technical problems existing in the prior art, the present invention aims to provide a multi-star task allocation method based on the minimum weight vertex coverage of the conflict graph, so as to solve the problem of large-scale star cluster task allocation.

[0007] To achieve the above-mentioned objectives, this invention provides a multi-star task allocation method based on the minimum weight vertex cover of a conflict graph, comprising the following steps:

[0008] Step S1: Calculate the set of visible windows for each satellite within the planned time period based on the observation meta-task attributes and requirements, satellite parameters, and platform / payload constraints;

[0009] Step S2: Considering filtering constraints, pairwise constraints, and cumulative constraints, construct a constrained global optimization model for multi-star task allocation;

[0010] Step S3: Treat feasible observation windows as vertices, pairwise constraints between feasible observation windows as undirected edges, and observation rewards of tasks corresponding to visible windows as weights to construct a global pairwise constraint conflict graph.

[0011] Step S4: Divide the conflict graph into actual conflict subgraphs and non-conflict subgraphs, initialize the vertex cover solution of the actual conflict subgraphs, and convert it into a global task allocation scheme.

[0012] Step S5: Using the cumulative constraint satisfaction operator, generate an initial globally feasible allocation scheme that satisfies the cumulative constraints, and define it as the current optimal solution;

[0013] Step S6: For the vertex cover solution of the current actual conflict subgraph, remove the two selected nodes in sequence and update the attribute values ​​of the corresponding vertices and edges.

[0014] Step S7: Add nodes for the current vertex coverage scheme until all edges are covered, and update the corresponding parameters.

[0015] Step S8: Remove redundant nodes to obtain a new vertex cover solution, and update the attribute parameters of the corresponding vertices and edges;

[0016] Step S9: Transform the vertex cover scheme into a global task allocation scheme, and use the cumulative constraint satisfaction operator to obtain a new feasible allocation scheme;

[0017] Step S10: Use the elite strategy to obtain the current optimal global task allocation scheme. Based on the vertex cover solution in step S8, jump back to step S6 and iterate until the stopping criterion is met, and output the centralized task allocation result.

[0018] According to a technical solution of the present invention, in step S1, the remote sensing system S = {s}, composed of n Earth observation satellites, is... i} i∈N Where N = {1, 2, ..., n}, and each satellite s i Defined as:

[0019] s i ={o i δ i oc i msa i ,rt i sp i ,ast i , sut i , ρ i , br i},

[0020] Among them, o i Indicates satellite orbit, δ i Indicates the load field of view, oc i Indicates load type, MSA i Indicates the maximum lateral sway angle, rt i Indicates shutdown delay time, SP i Indicates attitude yaw rate, ast i Indicates attitude stabilization time, sut i Indicates the load start-up preset time, ρ iThis represents the storage space consumed by the load per unit of working time. i Indicates the optimal observation resolution;

[0021] The observation task space R = {r} consists of m meta-tasks. j} j∈M M = {1, 2, ..., m}, each meta-task r j Defined as

[0022] r j ={ω j lc j roc j st j et j ,lr j},

[0023] Where, ω j Indicates the weight or priority of the task, lc j Represents the latitude and longitude coordinates of the mission, ROC j Indicates the observation type, st j Indicates the observation start time, et j Indicates the observation end time, lr j Indicates the minimum resolution;

[0024] Then for each satellite and meta-mission group {s i r j Based on the satellite orbital parameters and the mission's geographical location, calculate the set of visible windows;

[0025] Let the k-th observation window be aow. ijk ={[ws ijk we ijk ], θ ijk}, where [ws ijk we ijk ] indicates satellite s i For target r j Observation time, θ ijk This indicates the observed lateral swing angle.

[0026] According to one technical solution of the present invention, in step S2, the filtering constraints at least include observation type, time, lateral tilt angle, and resolution, denoted by C1-C4 respectively, then:

[0027] C1:oc i =roc j

[0028] C2:st j <ws ijk we ijk <et j

[0029] C3:θ ijk ∈[-msa i msa i ]

[0030] C4:bs i ·cos(θ ijk )>lr j

[0031] If all constraints C1-C4 are satisfied, then the time window ow ijk This is called a feasible observation window; denoted by K. ij For satellites s i For meta-task r j The number of feasible observation windows, then This is the sum of the number of feasible observation windows for all satellites;

[0032] For each feasible observation window ow ijk Let a ijk Let a be the corresponding decision variable. ijk =1 indicates satellite s i Select in the observation window ow ijk Execute observation task r j Otherwise a ijk =0;

[0033] All observation windows are arranged in order of satellite index and start time, where each feasible observation window has an overlay of 0. ijk If the index i and {i, j, k} can be converted to each other, then ow ijk Abbreviated as

[0034] Define the global task allocation result as a string of length 1. binary vector in This represents the feasible search space. With a ijk Equivalent, indicating whether the i-th feasible observation window is selected;

[0035] Paired constraints are constraints related to the attributes of two adjacent observation windows. and The observation start time meets the requirements.

[0036] If i1 = i2 = i, then both windows belong to satellite s. i Then the time interval between windows must satisfy the following pairwise constraint C5:

[0037]

[0038] Considering that each meta-task only needs to be executed once, when j1 = j2, that is, when both windows are targeting the same objective task, the following pairwise constraint C6 must be satisfied:

[0039]

[0040] Cumulative constraints are constraints associated with the historical mission sequence, for each satellite s i All must satisfy the following cumulative constraint C7:

[0041]

[0042] When all constraints C1-C7 are satisfied, a is called a feasible task allocation scheme;

[0043] Then, a constrained global optimization model for multi-star task allocation is constructed, which is represented as the feasible search space. The goal of finding the optimal feasible task allocation scheme that satisfies all constraints is to maximize the following global objective function:

[0044]

[0045] Where η is the number of constraints that are not satisfied among the three constraints C5-C7, b j (a) Function indicating successful task assignment: When metatask r j When successfully assigned, b j (a) = 1; otherwise, b j (a) = 0.

[0046] According to one technical solution of the present invention, step S3 specifically includes:

[0047] ow for each feasible observation window ijk Treating vertices as vertices, pairwise constraints between feasible observation windows as undirected edges, and observation rewards of tasks corresponding to feasible observation windows as weights, a global pairwise constraint conflict graph G = {V, E} is constructed.

[0048] Vertex v i Corresponding to the i-th feasible observation window in the permutation, its weight is the weight or priority of the corresponding observation task. For each vertex pair {v i v j If neither constraint C5 nor constraint C6 can be satisfied, then there exists a conflicting edge e. ij ∈E; for each vertex v i ∈V, Ω i ={v j ∈V|e ij ∈E} represents its neighbor set, d i The number of its neighbors.

[0049] According to one technical solution of the present invention, step S4 specifically includes:

[0050] By removing the set of nodes V0 with zero neighbors, we obtain the actual conflict subgraph G. r ={V r E r};

[0051] For G r ={V r E r Let K be the number of nodes, and the degree weight of each node be K.

[0052] In G r ={V r E r In}, consider V r A subset S;

[0053] opposite edge e ij In other words, if S contains at least one of its vertices, then edge e ij Covered;

[0054] If G r If all edges of a vertex are covered, then S is a vertex cover.

[0055] Based on the calculation process of the weighted vertex cover solution, an initial feasible task allocation scheme is obtained.

[0056] According to one technical solution of the present invention, step S5 specifically includes:

[0057] Step S51: Calculate the cumulative constraint satisfaction index of the current allocation scheme. If it is not satisfied, proceed with the loop in steps S52-S53; otherwise, jump to step S54.

[0058] Step S52: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in ascending order;

[0059] Step S53: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S5;

[0060] Step S54: Record the processed global task allocation scheme a 1 For x 1 And record the current optimal solution o 1 =x 1 ;

[0061] x 1 This indicates a feasible allocation scheme.

[0062] According to one technical solution of the present invention, step S6 specifically includes:

[0063] Step S61: Let E be the set of uncovered edges. U Set it to an empty set, denote the tabu node set as tabu and set it to an empty set, and set the config value of all nodes to 1;

[0064] Step S62: For each node v i , denote δ i Calculate its score function value by summing the weights of the edges formed by it and its zero neighbors. i ;like but otherwise,

[0065] Step S63: When removing the first node, let the set of nodes that can be removed, onf, be all the currently 1 nodes, where... Nodes with a value of 1; otherwise, all Randomly select half of the nodes with a value of 1 and a taboo value of 0 to form the set of nodes that can be removed, onf;

[0066] Step S64: Denote the node with the largest evaluation function value and the oldest age as "remove", remove it, and update its status. The value is 0;

[0067] Step S65: Set the evaluation function value of the removed node to the negative of its original value, and update the evaluation function values ​​of its neighbors;

[0068] Step S66: Update the config value of the removed node to 0, and update the config value of the neighbor to 1;

[0069] Step S67: Add the set of nodes consisting of node remove and its 0 neighbors to E. U To update the set of uncovered edges E U ;

[0070] Step S68: After removing two nodes sequentially based on steps S63 to S67, reset the tabu node set tabu to an empty set.

[0071] According to one technical solution of the present invention, step S7 specifically includes:

[0072] Step S71, record The set of nodes with a value of 0 and a config value of 1 is called fnode, and the node with the largest evaluation function value is add;

[0073] Step S72: Add the node Set it to 1, and update its tabu value to 1;

[0074] Step S73: Update the config value of all neighbors of node add to 1;

[0075] Step S74: Remove the edges containing node add to update the set of uncovered edges E. U ;

[0076] Step S75: For each uncovered edge, increase its weight by 1 and set the config value of its two endpoints to 1;

[0077] Step S76: Update the evaluation function values ​​of node add and its neighbors;

[0078] Step S77: For all endpoints of uncovered edges, update their evaluation function values ​​using the updated uncovered edge weights;

[0079] Step S78: If all edges are covered, then end; otherwise, go to step S71 and loop.

[0080] Step S79: Denote the newly obtained vertex coverage scheme as...

[0081] According to one technical solution of the present invention, step S8 specifically includes:

[0082] Step S81: Randomly select a redundant node v each time. i ;

[0083] Step S82, transfer the redundant node to the redundancy node. Set the value to 0, set its evaluation function to the opposite of the original value, and update the evaluation function values ​​of its neighbors;

[0084] Step S83: Update the selected node v i If the config value is 0, update the neighbor's config value to 1;

[0085] Step S84: If redundant nodes exist, proceed to step S81; otherwise, output the current vertex cover solution.

[0086] Step S85: Compare with the original vertex cover solution With the new vertex coverage scheme Increase the age of all nodes whose strategies have not changed by 1, i.e. The ages of the remaining nodes are set to zero, i.e.

[0087] According to one technical solution of the present invention, step S9 specifically includes:

[0088] Step S91: Construct a structure with a length of binary vector The representation is a global task allocation scheme, where the node policy in V0 is 1, and V r Mid-node strategy and on the contrary;

[0089] Step S92: Calculate the cumulative constraint satisfaction index of the current allocation scheme; if not satisfied, perform the loop in steps S93-S94 until all cumulative constraints are satisfied; if all indicators are satisfied, proceed to step S95.

[0090] Step S93: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in descending order;

[0091] Step S94: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S92;

[0092] Step S95: Denote the solution that satisfies the new constraints as...

[0093] According to one technical solution of the present invention, step S10 specifically includes:

[0094] Step S101, if but Otherwise, o t+1 =o t ;

[0095] Step S102: If the stopping criterion is met, output the current global optimal solution; otherwise, let... t = t + 1, then proceed to step f for iterative loop.

[0096] Compared with the prior art, the present invention has the following advantages:

[0097] This invention proposes a multi-satellite task allocation method based on minimum weight vertex cover of a conflict graph. Addressing the multi-satellite task allocation problem with filtering constraints, pairwise constraints, and cumulative constraints, a centralized optimization algorithm is designed using minimum weight vertex cover and neighborhood search from graph theory. Feasible observation windows of satellites are treated as vertices, pairwise constraint conflicts as edges, and observation gains as vertex weights, constructing a pairwise constraint conflict graph. This transforms the original problem into an iterative optimization solution involving conflict graph vertex cover and cumulative constraint satisfaction. Based on neighborhood search technology, a minimum weight vertex cover solution algorithm and a cumulative constraint resolution operator are designed, effectively ensuring rapid computation of the task allocation scheme.

[0098] This invention overcomes the shortcomings of traditional optimization algorithms, such as long computation time and poor optimization performance due to the presence of multiple hard constraints. Through vertex cover solving and cumulative constraint satisfaction operations, it enables rapid calculation of feasible task allocation schemes, significantly improving the optimization performance of global indicators and the utilization efficiency of limited observation resources. Furthermore, this invention can not only be used to solve satellite task allocation problems, but its modeling method and solution mechanism can also be applied to task allocation and decision-making problems in other fields, such as unmanned vehicle path planning and multi-robot task allocation. Attached Figure Description

[0099] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the embodiments will be briefly described below. Obviously, the drawings described below are merely some embodiments of the present invention, and those skilled in the art can obtain other drawings based on these drawings without creative effort.

[0100] Figure 1 This schematic diagram illustrates a flowchart of a multi-star task allocation method based on minimum weight vertex coverage of a conflict graph, provided in one embodiment of the present invention.

[0101] Figure 2 This diagram illustrates an example of pairwise constraint resolution based on vertex cover according to an embodiment of the present invention.

[0102] Figure 3 This illustration shows the convergence curve of the global evaluation function f in one embodiment of the present invention;

[0103] Figure 4 This illustration illustrates the task allocation result of multiple stars in one embodiment of the present invention;

[0104] Figure 5 This illustration shows the allocation result of each task in one embodiment of the present invention;

[0105] Figure 6 This illustration represents the cumulative constraint satisfaction result of each satellite in one embodiment of the present invention. Detailed Implementation

[0106] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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, 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.

[0107] like Figures 1 to 6 As shown, t represents the number of iterations, Y represents that the condition is met (yes), and N represents that the condition is not met (no). A, B, C, D, E, and F are node names, corresponding one-to-one with feasible observation time windows, and the numbers on the right are the observation gains for the corresponding observation window; S represents the set of candidate points for vertex coverage, a i =1 indicates node a i Belongs to set S, a i =0 indicates the opposite; an edge indicates a pairwise constraint conflict between windows. f represents the global evaluation index of task allocation, which represents the sum of observation benefits corresponding to task allocation when all constraints are satisfied. The X-axis coordinate corresponding to the left of the rectangle is the start time of the observation time window, and the X-axis coordinate corresponding to the right is the end time of the observation time window. The numbers in the box represent the observation target ID and the visible window number of the satellite to the target, respectively; T represents the actual time, Cpct represents the cumulative observation time of the satellite, full represents the upper limit of the cumulative observation time, and actual represents the actual cumulative observation time corresponding to the allocation result.

[0108] This invention relates to a multi-satellite task allocation method based on minimum weight vertex cover in a conflict graph, belonging to the interdisciplinary field of graph theory, operations research, and aerospace. It utilizes minimum weight vertex cover and local search optimization theory. The method first constructs a global pairwise constraint conflict graph using the feasible observation window set of each satellite. Then, it iteratively optimizes the minimum weight vertex cover solution through steps such as random node removal, adding uncovered nodes, and removing redundant nodes, generating a global task allocation scheme based on this. Subsequently, it uses a cumulative constraint satisfaction operator to obtain feasible allocation schemes. Finally, it jumps back to the node removal step for iterative iteration until the termination condition is met, outputting the task allocation scheme.

[0109] The method of the present invention will be described in detail below with a specific implementation. The experimental scenario includes n = 10 satellites and m = 279 observation tasks, with the priority of each observation task being an integer between 1 and 100. The experimental environment is MATLAB 2016a, with Win10.0 operating system, 3.07GHz, and 4GB of memory.

[0110] like Figure 1 As shown, a multi-star task allocation method based on minimum weight vertex coverage in a conflict graph according to the present invention includes the following steps:

[0111] Step S1: Calculate the visible window of each star.

[0112] Based on the observation meta-mission attributes and requirements, satellite parameters, and platform / payload constraints, calculate the set of visible windows for each satellite within the planned time period; the sum of all feasible observation windows. It is 1548.

[0113] A remote sensing system S = {s} consisting of n Earth observation satellites i} i∈N Where N = {1, 2, ..., n}, and each satellite s i Defined as:

[0114] s i ={o i δ i oc i msa i ,rt i sp i ,ast i , sut i , ρ i , br i},

[0115] Among them, o i Indicates satellite orbit, δ i Indicates the load field of view, oc i Indicates load type, MSA i Indicates the maximum lateral sway angle, rt i Indicates shutdown delay time, SP i Indicates attitude yaw rate, ast i Indicates attitude stabilization time, sut i Indicates the load start-up preset time, ρ i This represents the storage space consumed by the load per unit of working time. i Indicates the optimal observation resolution;

[0116] The observation task space R = {r} consists of m meta-tasks. j} j∈M M = {1, 2, ..., m}, each meta-task r j Defined as

[0117] r j ={ω j lc j roc j st j et j ,lr j},

[0118] Where, ω j Indicates the weight or priority of the task, lc j Represents the latitude and longitude coordinates of the mission, ROC j Indicates the observation type, st j Indicates the observation start time, et j Indicates the observation end time, lr j Indicates the minimum resolution;

[0119] Then for each satellite and meta-mission group {s i r j Based on the satellite orbital parameters and the mission's geographical location, calculate the set of visible windows;

[0120] Let the k-th observation window be aow. ijk ={[ws ijk we ijk ], θ ijk}, where [ws ijk we ijk ] indicates satellite s i For target r j Observation time, θ ijk This indicates the observed lateral swing angle.

[0121] Step S2: Establish a global optimization model

[0122] Considering filtering constraints, pairwise constraints, and cumulative constraints, a constrained global optimization model for multi-star task allocation is constructed.

[0123] The filtering constraints include at least the observation type, time, side swing angle, and resolution, denoted by C1-C4 respectively, then:

[0124] C1:oc i =roc j

[0125] C2:st j <ws ijk we ijk <et j

[0126] C3:θ ijk ∈[-msa i msa i ]

[0127] C4:bs i ·cos(θ ijk )>lr j

[0128] If all constraints C1-C4 are satisfied, then the time window ow ijk This is called a feasible observation window; denoted by K. ij For satellites s i For meta-task r j The number of feasible observation windows, then This is the sum of the number of feasible observation windows for all satellites;

[0129] For each feasible observation window ow ijk Let a ijk Let a be the corresponding decision variable.ijk =1 indicates satellite s i Select in the observation window ow ijk Execute observation task r j Otherwise a ijk =0;

[0130] All observation windows are arranged in order of satellite index and start time, where each feasible observation window has an overlay of 0. ijk Serial number If {i, j, k} are interchangeable, then ow ijk Abbreviated as

[0131] Define the global task allocation result as a string of length 1. binary vector in This represents the feasible search space. With a ijk Equivalent, indicating whether the i-th feasible observation window is selected;

[0132] Paired constraints are constraints related to the attributes of two adjacent observation windows. and The observation start time meets the requirements.

[0133] If i1 = i2 = i, then both windows belong to satellite s. i Then the time interval between windows must satisfy the following pairwise constraint C5:

[0134]

[0135] Considering that each meta-task only needs to be executed once, when j1 = j2, that is, when both windows are targeting the same objective task, the following pairwise constraint C6 must be satisfied:

[0136]

[0137] Cumulative constraints are constraints associated with the historical mission sequence, for each satellite s i All must satisfy the following cumulative constraint C7:

[0138]

[0139] When all constraints C1-C7 are satisfied, a is called a feasible task allocation scheme;

[0140] Then, a constrained global optimization model for multi-star task allocation is constructed, which is represented as the feasible search space. The goal of finding the optimal feasible task allocation scheme that satisfies all constraints is to maximize the following global objective function:

[0141]

[0142] Where η is the number of constraints that are not satisfied among the three constraints C5-C7, b j (a) Function indicating successful task assignment: When metatask r j When successfully assigned, b j (a) = 1; otherwise, b j (a) = 0.

[0143] Step S3: Construct a global pairwise constraint conflict graph

[0144] A global pairwise constraint conflict graph is constructed by treating feasible observation windows as vertices, pairwise constraints between feasible observation windows as undirected edges, and the observation rewards of the tasks corresponding to visible windows as weights. Specifically, this graph includes:

[0145] ow for each feasible observation window ijk Treating vertices as vertices, pairwise constraints between feasible observation windows as undirected edges, and observation rewards of tasks corresponding to feasible observation windows as weights, a global pairwise constraint conflict graph G = {V, E} is constructed.

[0146] Vertex v i Corresponding to the i-th feasible observation window in the permutation, its weight is the weight or priority of the corresponding observation task. For each vertex pair {v i v j If neither constraint C5 nor constraint C6 can be satisfied, then there exists a conflicting edge e. ij ∈E; for each vertex v i ∈V, Ω i ={v j ∈V|e ij ∈e} represents its neighbor set, d i The number of its neighbors.

[0147] Step S4: Initialize the task allocation scheme

[0148] The conflict graph is divided into a conflict-free subgraph and a non-conflict subgraph. The vertex cover solution of the conflict-free subgraph is initialized and then converted into a global task allocation scheme, specifically including:

[0149] By removing the set of nodes V0 with zero neighbors, we obtain the actual conflict subgraph G. r ={V r E r};

[0150] For G r ={V r E r Let K be the number of nodes, and the degree weight of each node be K.

[0151] In G r ={V v E r In}, consider V r A subset S;

[0152] opposite edge e ij In other words, if S contains at least one of its vertices, then edge e ij Covered;

[0153] If G r If all edges of a vertex are covered, then S is a vertex cover.

[0154] Based on the calculation process of the weighted vertex cover solution, an initial feasible task allocation scheme is obtained, which specifically includes:

[0155] Step S401: Initialize V r vertex cover solution

[0156] Step S402, in G r In the middle, randomly select an uncovered edge e. ij Select nodes with higher degree weights to join S;

[0157] Step S403: Repeat step S402 until all edges are covered;

[0158] Step S404: Randomly select redundant nodes and remove them until there are no redundant nodes left;

[0159] Step S405: Encode S into a binary vector of length 1548.

[0160] Step S406, Invert the policies of all nodes to obtain a global task allocation scheme a that satisfies pairwise constraints. 1 ;

[0161] Step S407, Define G r The weights of all edges in the middle are The age of all nodes is

[0162] Step S5: Initialize the current optimal solution

[0163] Using the cumulative constraint satisfaction operator, an initial globally feasible allocation scheme satisfying the cumulative constraints is generated and defined as the current optimal solution, specifically including:

[0164] Step S51: Calculate the cumulative constraint satisfaction index of the current allocation scheme. If it is not satisfied, proceed with the loop in steps S52-S53; otherwise, jump to step S54.

[0165] Step S52: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in ascending order;

[0166] Step S53: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S5;

[0167] Step S54: Record the processed global task allocation scheme a 1 For x 1 And record the current optimal solution o 1 =x 1 ;

[0168] x 1 This indicates a feasible allocation scheme.

[0169] Step S6: Remove conflicting subgraph nodes

[0170] For the vertex cover solution of the current actual conflict subgraph, remove the two selected nodes in sequence and update the corresponding vertex and edge attribute values, specifically including:

[0171] Step S61: Let E be the set of uncovered edges. U Set it to an empty set, denote the tabu node set as tabu and set it to an empty set, and set the config value of all nodes to 1;

[0172] Step S62: For each node v i , denote δ i Calculate its score function value by summing the weights of the edges formed by it and its zero neighbors. i ;like but otherwise,

[0173] Step S63: When removing the first node, let the set of nodes that can be removed, onf, be all the currently 1 nodes, where... Nodes with a value of 1; otherwise, all Randomly select half of the nodes with a value of 1 and a taboo value of 0 to form the set of nodes that can be removed, onf;

[0174] Step S64: Denote the node with the largest evaluation function value and the oldest age as "remove", remove it, and update its status. The value is 0;

[0175] Step S65: Set the evaluation function value of the removed node to the negative of its original value, and update the evaluation function values ​​of its neighbors;

[0176] Step S66: Update the config value of the removed node to 0, and update the config value of the neighbor to 1;

[0177] Step S67: Add the set of nodes consisting of node remove and its 0 neighbors to E. U To update the set of uncovered edges E U ;

[0178] Step S68: After removing two nodes in sequence based on steps S63 to S67, reset the tabu node set tabu to an empty set.

[0179] Step S7: Add conflict subgraph nodes

[0180] For the current vertex coverage scheme, add nodes until all edges are covered, and update the corresponding parameters. Specifically, this includes:

[0181] Step S71, record The set of nodes with a value of 0 and a config value of 1 is called fnode, and the node with the largest evaluation function value is add;

[0182] Step S72: Add the node Set it to 1, and update its tabu value to 1;

[0183] Step S73: Update the config value of all neighbors of node add to 1;

[0184] Step S74: Remove the edges containing node add to update the set of uncovered edges E. U ;

[0185] Step S75: For each uncovered edge, increase its weight by 1 and set the config value of its two endpoints to 1;

[0186] Step S76: Update the evaluation function values ​​of node add and its neighbors;

[0187] Step S77: For all endpoints of uncovered edges, update their evaluation function values ​​using the updated uncovered edge weights;

[0188] Step S78: If all edges are covered, then end; otherwise, go to step S71 and loop.

[0189] Step S79: Denote the newly obtained vertex coverage scheme as...

[0190] Step S8: Remove redundant nodes from the conflicting subgraph

[0191] Remove redundant nodes to obtain a new vertex cover solution, and update the attribute parameters of the corresponding vertices and edges, specifically including:

[0192] Step S81: Randomly select a redundant node v each time. i ;

[0193] Step S82, transfer the redundant node to the redundancy node. Set the value to 0, set its evaluation function to the opposite of the original value, and update the evaluation function values ​​of its neighbors;

[0194] Step S83: Update the selected node v i If the config value is 0, update the neighbor's config value to 1;

[0195] Step S84: If redundant nodes exist, proceed to step S81; otherwise, output the current vertex cover solution.

[0196] Step S85: Compare with the original vertex cover solution With the new vertex coverage scheme Increase the age of all nodes whose strategies have not changed by 1, i.e. The ages of the remaining nodes are set to zero, i.e.

[0197] Step S9: Generation of new feasible allocation schemes

[0198] The vertex cover scheme is transformed into a global task allocation scheme, and a new feasible allocation scheme is obtained by using the cumulative constraint satisfaction operator, specifically including:

[0199] Step S91: Construct a structure with a length of binary vector The representation is a global task allocation scheme, where the node policy in V0 is 1, and V r Mid-node strategy and on the contrary;

[0200] Step S92: Calculate the cumulative constraint satisfaction index of the current allocation scheme; if not satisfied, perform the loop in steps S93-S94 until all cumulative constraints are satisfied; if all indicators are satisfied, proceed to step S95.

[0201] Step S93: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in descending order;

[0202] Step S94: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S92;

[0203] Step S95: Denote the solution that satisfies the new constraints as...

[0204] Step S10: Update the current global optimal solution

[0205] The optimal global task allocation scheme is obtained using an elite strategy. Based on the vertex cover solution in step S8, the process jumps back to step S6 and iterates until the stopping criterion is met. The centralized task allocation result is then output, specifically including:

[0206] Step S101, if but Otherwise, o t+1 =o t ;

[0207] Step S102: If the stopping criterion is met, output the current global optimal solution; otherwise, let... t = t + 1, then proceed to step f for iterative loop.

[0208] Figure 2 This example illustrates pairwise constraint resolution based on vertex covers, where each node corresponds to a feasible observation window, and edges represent pairwise constraint conflicts between windows. The red nodes form a minimum-weight vertex cover. By removing nodes A, C, and D, we obtain task assignment results B, E, and F that satisfy the pairwise constraints. If these results also satisfy the cumulative constraint, then it represents the globally optimal task assignment scheme.

[0209] Figure 3 The convergence curve is the global evaluation metric generated by the algorithm. Figure 4 The results of the mission allocation for each satellite, Figure 5 The allocation results for each observation task, Figure 6 The output task allocation results show the cumulative constraint satisfaction of each star. Experimental results demonstrate that the multi-star task allocation method algorithm based on minimum weight vertex coverage of the conflict graph proposed in this invention can quickly solve for the nearest optimal task allocation scheme that satisfies both pairwise and cumulative constraints.

[0210] According to one aspect of the present invention, an electronic device is provided, comprising: one or more processors, one or more memories, and one or more computer programs; wherein the processor is connected to the memory, and the one or more computer programs are stored in the memory; when the electronic device is running, the processor executes the one or more computer programs stored in the memory to cause the electronic device to perform a multi-star task allocation method based on minimum weight vertex coverage of a conflict graph, as described in any of the above technical solutions.

[0211] According to one aspect of the present invention, a computer-readable storage medium is provided for storing computer instructions, which, when executed by a processor, implement a multi-star task allocation method based on minimum weight vertex coverage of a conflict graph, as described in any of the above technical solutions.

[0212] Computer-readable storage media can include any medium capable of storing or transmitting information. Examples of computer-readable storage media include electronic circuits, semiconductor memory devices, ROM, flash memory, erasable ROM (EROM), floppy disks, CD-ROMs, optical disks, hard disks, fiber optic media, radio frequency (RF) links, and so on. Code segments can be downloaded via computer networks such as the Internet and intranets.

[0213] This invention provides a multi-star task allocation method based on minimum weight vertex cover in a conflict graph. The method utilizes minimum weight vertex cover to solve the multi-star task allocation problem, with the main objective being:

[0214] Firstly, in the multi-satellite, multi-task allocation process, due to the sliding nature of the observation window, each satellite has a large number of feasible observation windows. Simultaneously, due to physical constraints such as yaw rate and shutdown delay time, tasks corresponding to some feasible observation windows cannot be executed sequentially, resulting in numerous pairwise constraint conflicts. These conflicts can be represented using a simple undirected graph, and by removing any vertex covering the solution, the pairwise conflict constraints can be quickly satisfied.

[0215] Therefore, vertex covering provides an effective model representation for the rapid resolution of pairwise conflicts;

[0216] Secondly, as a classic NP-hard problem in graph theory, the minimum weight vertex cover can be solved quickly and efficiently using various heuristics or local search algorithms. Meanwhile, considering physical constraints such as the number of machine cycles, startup time, and storage space, a given task sequence may not be able to be executed simultaneously. Therefore, by designing a cumulative constraint satisfaction operator, feasible task allocation schemes can be efficiently solved based on pairwise conflict resolution.

[0217] Based on the above reasons, this invention uses minimum weight vertex cover as a modeling tool, transforms multi-satellite task allocation into a vertex cover scheme optimization and cumulative constraint satisfaction process, constructs a pairwise constraint conflict graph, designs a vertex cover optimization algorithm based on neighborhood search, and provides a calculation process for feasible task allocation schemes based on cumulative constraint satisfaction, thus providing a more efficient solution for large-scale satellite mission planning.

[0218] This invention enables rapid resolution of pairwise constraint conflicts. Since any vertex covering scheme touches all pairs of conflicting edges, by removing the vertex covering window set from all feasible observation windows, the resulting task set and sequence are free of pairwise conflicts.

[0219] This invention enables the resolution of cumulative constraint conflicts. For any task allocation scheme that satisfies paired constraints, by using the cumulative constraint satisfaction operator and sequentially removing the corresponding feasible observation windows, a feasible task allocation scheme that satisfies all constraints can be quickly obtained.

[0220] This invention enables efficient solutions for near-optimal task allocation schemes. Since the sum of the weights of all observation windows is fixed, the nearest optimal solution can be computed within the feasible solution space that satisfies the constraints by solving for the vertex cover of the approximate minimum weight and accumulating constraint satisfaction operations. Furthermore, by utilizing problem-related heuristic information, this method is particularly suitable for computing large-scale multi-satellite multi-task allocation problems.

[0221] This invention can also be applied to other task allocation problems that include pairwise constraints and cumulative constraints, including but not limited to logistics order delivery.

[0222] Furthermore, it should be noted that the present invention can be provided as a method, apparatus, or computer program product. Therefore, embodiments of the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Moreover, embodiments of the present invention can take the form of a computer program product implemented on one or more computer-usable storage media containing computer-usable program code.

[0223] Embodiments of the present invention are described with reference to flowchart illustrations and / or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, embedded processor, or other programmable data processing terminal device to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal device, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0224] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing terminal device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1One or more processes and / or boxes Figure 1 The functions specified in one or more boxes. These computer program instructions may also be loaded onto a computer or other programmable data processing terminal equipment to cause a series of operational steps to be performed on the computer or other programmable terminal equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable terminal equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0225] It should also be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.

[0226] Finally, it should be noted that the above description represents a preferred embodiment of the present invention. It should be pointed out that although preferred embodiments have been described, those skilled in the art, once they understand the basic inventive concept of the present invention, can make various improvements and modifications without departing from the principles described herein. These improvements and modifications should also be considered within the scope of protection of the present invention. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the embodiments of the present invention.

Claims

1. A multi-star task allocation method based on minimum weight vertex cover in a conflict graph, characterized in that, Includes the following steps: Step S1: Calculate the set of visible windows for each satellite within the planned time period based on the observation meta-task attributes and requirements, satellite parameters, and platform / payload constraints; Step S2: Considering filtering constraints, pairwise constraints, and cumulative constraints, construct a constrained global optimization model for multi-star task allocation; Step S3: Treat feasible observation windows as vertices, pairwise constraints between feasible observation windows as undirected edges, and observation rewards of tasks corresponding to visible windows as weights to construct a global pairwise constraint conflict graph. Step S4: Divide the conflict graph into actual conflict subgraphs and non-conflict subgraphs, initialize the vertex cover solution of the actual conflict subgraphs, and convert it into a global task allocation scheme. Step S5: Using the cumulative constraint satisfaction operator, generate an initial globally feasible allocation scheme that satisfies the cumulative constraints, and define it as the current optimal solution; Step S6: For the vertex cover solution of the current actual conflict subgraph, remove the two selected nodes in sequence and update the attribute values ​​of the corresponding vertices and edges. Step S7: Add nodes for the current vertex coverage scheme until all edges are covered, and update the corresponding parameters. Step S8: Remove redundant nodes to obtain a new vertex cover solution, and update the attribute parameters of the corresponding vertices and edges; Step S9: Transform the vertex cover scheme into a global task allocation scheme, and use the cumulative constraint satisfaction operator to obtain a new feasible allocation scheme; Step S10: Use the elite strategy to obtain the current optimal global task allocation scheme. Based on the vertex cover solution in step S8, jump back to step S6 and iterate until the stopping criterion is met, and output the centralized task allocation result.

2. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 1, characterized in that, In step S1, the remote sensing system S = {s}, consisting of n Earth observation satellites, is described. i } i∈N Where N = {1, 2, ..., n}, and each satellite s i Defined as: s i ={o i ,d i ,oc i ,msa i ,rt i ,sp i , ast i ,sut i ,r i ,br i }, Among them, o i Indicates satellite orbit, δ i Indicates the load field of view, oc i Indicates load type, MSA i Indicates the maximum lateral sway angle, rt i Indicates shutdown delay time, SP i Indicates attitude yaw rate, ast i Indicates attitude stabilization time, sut i Indicates the load start-up preset time, ρ i This represents the storage space consumed by the load per unit of working time. i Indicates the optimal observation resolution; The observation task space R = {r} consists of m meta-tasks. j } j∈M M = {1, 2, ..., m}, each meta-task r j Defined as r j ={ω j lc j roc j st j et j ,lr j }, Where, ω j Indicates the weight or priority of the task, lc j Represents the latitude and longitude coordinates of the mission, ROC j Indicates the observation type, st j Indicates the observation start time, et j Indicates the observation end time, lr j Indicates the minimum resolution; Then for each satellite and meta-mission group {s i r j Based on the satellite orbital parameters and the mission's geographical location, calculate the set of visible windows; Let the k-th observation window be aow. ijk ={[ws ijk we ijk ], θ ijk }, where [ws ijk we ijk ] indicates satellite s i For target r j Observation time, θ ijk This indicates the observed lateral swing angle.

3. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 2, characterized in that, In step S2, the filtering constraints include at least observation type, time, yaw angle, and resolution, denoted by C1-C4 respectively. Therefore: C1:oc i =roc j C2:st j <ws ijk ,we ijk <et j C3:θ ijk ∈[-msa i ,msa i ] C4:bs i ·cos(θ ijk )>lr j If all constraints C1-C4 are satisfied, then the time window ow ijk This is called a feasible observation window; denoted by K. ij For satellites s i For meta-task r j The number of feasible observation windows, then This is the sum of the number of feasible observation windows for all satellites; For each feasible observation window ow ijk Let a ijk Let a be the corresponding decision variable. ijk =1 indicates satellite s i Select in the observation window ow ijk Execute observation task r j Otherwise a ijk =0; All observation windows are arranged in order of satellite index and start time, where each feasible observation window has an overlay of 0. ijk Serial number If {i, j, k} are interchangeable, then ow ijk Abbreviated as Define the global task allocation result as a string of length . binary vector in This represents the feasible search space. With a ijk Equivalent, indicating whether the i-th feasible observation window is selected; Paired constraints are constraints related to the attributes of two adjacent observation windows. and The observation start time meets the requirements. If i1 = i2 = i, then both windows belong to satellite s. i Then the time interval between windows must satisfy the following pairwise constraint C5: C5: Considering that each meta-task only needs to be executed once, when j1 = j2, that is, when both windows are targeting the same objective task, the following pairwise constraint C6 must be satisfied: C6: Cumulative constraints are constraints associated with the historical mission sequence, for each satellite s i All must satisfy the following cumulative constraint C7: C7: When all constraints C1-C7 are satisfied, a is called a feasible task allocation scheme; Then, a constrained global optimization model for multi-star task allocation is constructed, which is represented as the feasible search space. The goal of finding the optimal feasible task allocation scheme that satisfies all constraints is to maximize the following global objective function: Where η is the number of constraints that are not satisfied among the three constraints C5-C7, b j (a) Function indicating successful task assignment: When metatask r j When successfully assigned, b j (a) = 1; otherwise, b j (a) = 0.

4. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 3, characterized in that, Step S3 specifically includes: ow for each feasible observation window ijk Treating vertices as vertices, pairwise constraints between feasible observation windows as undirected edges, and observation rewards of tasks corresponding to feasible observation windows as weights, a global pairwise constraint conflict graph G = {V, E} is constructed. Vertex v i Corresponding to the i-th feasible observation window in the permutation, its weight is the weight or priority of the corresponding observation task. For each vertex pair {v i v j If neither constraint C5 nor constraint C6 can be satisfied, then there exists a conflicting edge e. ij ∈E; for each vertex v i ∈V, Ω i ={v j ∈V|e ij ∈E} represents its neighbor set, d i The number of its neighbors.

5. The multi-star task allocation method based on minimum weight vertex coverage of a conflict graph according to claim 3, characterized in that, Step S4 specifically includes: By removing the set of nodes V0 with zero neighbors, we obtain the actual conflict subgraph G. r ={V r E r }; For G r ={V r E r Let K be the number of nodes, and the degree weight of each node be K. In G r ={V r E r In}, consider V r A subset S; opposite edge e ij In other words, if S contains at least one of its vertices, then edge e ij Covered; If G r If all edges of a vertex are covered, then S is a vertex cover. Based on the calculation process of the weighted vertex cover solution, an initial feasible task allocation scheme is obtained.

6. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 3, characterized in that, Step S5 specifically includes: Step S51: Calculate the cumulative constraint satisfaction index of the current allocation scheme. If it is not satisfied, proceed with the loop in steps S52-S53; otherwise, jump to step S54. Step S52: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in ascending order; Step S53: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S5; Step S54: Record the processed global task allocation scheme a 1 For x 1 And record the current optimal solution o 1 =x 1 ; x 1 This indicates a feasible allocation scheme.

7. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 4, characterized in that, Step S6 specifically includes: Step S61: Let E be the set of uncovered edges. U Set it to an empty set, denote the tabu node set as tabu and set it to an empty set, and set the config value of all nodes to 1; Step S62: For each node v i , denote δ i Calculate its score function value by summing the weights of the edges formed by it and its zero neighbors. i ;like but otherwise, Step S63: When removing the first node, let the set of nodes that can be removed, onf, be all the currently 1 nodes, where... Nodes with a value of 1; otherwise, all Randomly select half of the nodes with a value of 1 and a taboo value of 0 to form the set of nodes that can be removed, onf; Step S64: Denote the node with the largest evaluation function value and the oldest age as "remove", remove it, and update its status. The value is 0; Step S65: Set the evaluation function value of the removed node to the negative of its original value, and update the evaluation function values ​​of its neighbors; Step S66: Update the config value of the removed node to 0, and update the config value of the neighbor to 1; Step S67: Add the set of nodes consisting of node remove and its 0 neighbors to E. U To update the set of uncovered edges E U ; Step S68: After removing two nodes sequentially based on steps S63 to S67, reset the tabu node set tabu to an empty set.

8. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 4, characterized in that, Step S7 specifically includes: Step S71, record The set of nodes with a value of 0 and a config value of 1 is called fnode, and the node with the largest evaluation function value is add; Step S72: Add the node Set it to 1, and update its tabu value to 1; Step S73: Update the config value of all neighbors of node add to 1; Step S74: Remove the edges containing node add to update the set of uncovered edges E. U ; Step S75: For each uncovered edge, increase its weight by 1 and set the config value of its two endpoints to 1; Step S76: Update the evaluation function values ​​of node add and its neighbors; Step S77: For all endpoints of uncovered edges, update their evaluation function values ​​using the updated uncovered edge weights; Step S78: If all edges are covered, then end; otherwise, go to step S71 and loop. Step S79: Denote the newly obtained vertex coverage scheme as...

9. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 4, characterized in that, Step S8 specifically includes: Step S81: Randomly select a redundant node v each time. i ; Step S82, transfer the redundant node to the redundancy node. Set the value to 0, set its evaluation function to the opposite of the original value, and update the evaluation function values ​​of its neighbors; Step S83: Update the selected node v i If the config value is 0, update the neighbor's config value to 1; Step S84: If redundant nodes exist, proceed to step S81; otherwise, output the current vertex cover solution. Step S85: Compare with the original vertex cover solution With the new vertex coverage scheme Increase the age of all nodes whose strategies have not changed by 1, i.e. The ages of the remaining nodes are set to zero, i.e. Step S9 specifically includes: Step S91: Construct a structure with a length of binary vector The representation is a global task allocation scheme, where the node policy in V0 is 1, and V r Mid-node strategy and on the contrary; Step S92: Calculate the cumulative constraint satisfaction index of the current allocation scheme; if not satisfied, perform the loop in steps S93-S94 until all cumulative constraints are satisfied; if all indicators are satisfied, proceed to step S95. Step S93: For each observation window with strategy 1, calculate the cumulative constraint increment it generates and arrange them in descending order; Step S94: Select the observation window with the smallest cumulative constraint increment, set its decision variable to 0, and jump to step S92; Step S95: Denote the solution that satisfies the new constraints as...

10. The multi-star task allocation method based on minimum weight vertex cover of a conflict graph according to claim 4, characterized in that, Step S10 specifically includes: Step S101, if but Otherwise, o t+1 =o t ; Step S102: If the stopping criterion is met, output the current global optimal solution; otherwise, let... t = t + 1, then proceed to step f for iterative loop.

Images