A Flexible Combinatorial Auction Algorithm (FCAA) for Multi-Task Collaborative Scheduling of Heterogeneous UAVs

Highlights

What are the main findings?

• A Flexible Combinatorial Auction Algorithm (FCAA) is proposed, which is designed with a candidate solution generation mechanism and a candidate solution addition mechanism to reduce the number of candidate solutions prior to combinatorial auctions. By calculating the benefits of candidate solutions based on real-time resource prices, the algorithm can dynamically adjust its priorities, thereby breaking the limitation that existing auction algorithms fail to efficiently and flexibly combine heterogeneous UAV resources for multi-task completion.
• Simulations show that the FCAA achieves a scheduling success rate of over 88% (with a maximum solution benefit proportion of 83.9%) in small-scale multi-tasking scenarios and a scheduling success rate of 98% (with a maximum solution benefit proportion of 93%) in multi-tasking scenarios, with significantly better time efficiency and solution quality than traditional algorithms.

What are the implications of the main findings?

• It provides an efficient solution to heterogeneous UAV resource scheduling in scenarios such as emergency rescue and intelligent logistics, addressing the low efficiency of traditional algorithms in large-scale tasks and improving the stability of resource allocation in complex environments.
• Its candidate solution mechanism supports adjusting solution valuations based on practical experience, enabling it to adapt to human–machine collaborative scenarios.

Abstract

To address the inefficiency of collaborative scheduling of heterogeneous Unmanned Aerial Vehicles under resource constraints, particularly in large-scale multi-tasking scenarios, an improved Flexible Combinatorial Auction Algorithm is proposed, leveraging the bidding mechanism of simultaneous ascending auctions. This algorithm is designed with a candidate solution generation mechanism and an addition mechanism, which collectively reduce the number of candidate solutions generated prior to combinatorial auctions. It allows tasks to flexibly combine resources and submit bids. By calculating each candidate solution’s benefit based on real-time resource prices, it dynamically adjusts their priorities to search for the overall optimal multi-task scheduling scheme. It effectively addresses the inability of traditional auction algorithms to dynamically form resource clusters via flexible resource combination to collaboratively complete tasks. Meanwhile, it overcomes the technical bottleneck that existing heuristic algorithms struggle to handle highly complex heterogeneous resource scheduling cases. Simulation experiments show that in small-scale multi-tasking scenarios, the FCAA achieves a scheduling success rate of over 88%, with the maximum solution benefit proportion reaching 83.9%; in multi-tasking scenarios, it achieves a scheduling success rate of 98%, with the maximum solution benefit proportion reaching 93%. Its time efficiency and solution quality are significantly superior to those of traditional algorithms, providing an efficient and stable solution for heterogeneous resource scheduling problems in complex operational environments.

1. Introduction

As Unmanned Aerial Vehicle (UAV) technology advances towards multi-type and multi-functional capabilities, heterogeneous UAV systems have become a core enabling technology. By integrating devices with complementary performances to adapt to varied tasks, heterogeneous UAV systems have become essential in fields like emergency rescue, environmental monitoring, and intelligent logistics. However, resource scheduling for these systems faces three core challenges: device heterogeneity, task dynamism, and environmental uncertainty, which have thus rendered the limitations of traditional scheduling methods increasingly prominent. Consequently, recent research has increasingly focused on resource scheduling in complex environments [1,2,3,4,5].

The most common operational resource scheduling processes employ rule-based methods, which are typically developed based on domain-specific principles and expert experience. Researchers model these rules into general frameworks and conduct relevant computations. Resource scheduling problems are mostly combinatorial optimization problems, with common mathematical models including the traveling salesman problem (TSP) [6,7,8], mixed-integer linear programming (MILP) [9,10,11,12], and the cooperative multi-task allocation problem (CMTAP) [13]. Traditional optimization methods for these problems (e.g., linear programming, integer programming, dynamic programming, and branch-and-bound) often suffer from low scheduling efficiency, rendering them unsuitable for large-scale resource scheduling.

For complex resource-task scheduling problems, the current mainstream research focuses on heuristic algorithms. For instance, Jia et al. [14] used an improved genetic algorithm (GA) to solve the task allocation problem of heterogeneous UAVs under multiple constraints. Wang et al. [15] improved the GA, developed a contract net protocol based on it, and applied it to solve the multi-objective task planning problem of UAVs. Zhu et al. [16] proposed the concept of constraint tolerance to identify constraint-violating individuals and improved the second-generation non-dominated sorting genetic algorithm (NSGA-II), thereby improving the solution efficiency of heterogeneous UAV task allocation. Yang et al. [2] introduced a hybrid task allocation method for complex constraints, and combined it with a UAV coalition mechanism and the improved third-generation non-dominated sorting genetic algorithm (NSGA-III) to solve the multi-objective optimization problem of UAV task allocation. Dong et al. [5] integrated the roulette wheel selection principle and the elitist strategy into the ant colony optimization (ACO) to solve the joint optimization problem of UAV swarm task allocation and trajectory planning. Khosiawan et al. [17] applied particle swarm optimization (PSO) to solve the UAV task scheduling problem in indoor scenarios. Yan et al. [18] proposed the LR-PI algorithm to enhance multi-UAV task allocation. It features an improved task inclusion phase, a novel communication protocol, and a systematic reassignment method, addressing issues like non-ideal communication, low allocation rates, and poor cooperative adaptability. In recent years, researchers have also proposed novel intelligent algorithms such as the zebra optimization algorithm (ZOA) [19], social learning discrete particle swarm optimization (SLD-PSO) [20], and growth optimization (GO) [21]. Although these methods enhance computational efficiency moderately, they still cannot balance convergence speed and search scope in multi-task scheduling scenarios. Consequently, key issues, including inefficient search, unstable solutions, and high computational costs, persist.

For such resource scheduling problems, various solutions, including auction algorithms, reinforcement learning methods, and fuzzy control techniques, have also been studied. Li et al. [22] used heuristic algorithms for local computation, designed a performance impact algorithm (PI), and integrated an auction process derived from game theory. They solved conflicts through distributed bidding and negotiation, thereby developing a UAV swarm scheduling method based on conflict prediction. Duan et al. [23] proposed a hybrid two-stage auction algorithm with a hierarchical decision-making mechanism and an improved objective function to address UAV task allocation and path planning. Cho et al. [24] proposed a bidding model for endogenous coalition formation under budget constraints, revealing that the two-coalition equilibrium structure can approximately maximize the seller’s revenue; Ng et al. [25] designed a framework that integrates UAV coalitions with auctions, solved problems related to communication optimization and coalition allocation in IoV-based federated learning via a merge-and-split algorithm and a second-price auction, and verified that the grand coalition is not always stable. Choi et al. [26] proposed the Consensus-Based Auction Algorithm (CBAA) and its extended multi-task version, the Consensus-Based Bundle Algorithm (CBBA), which provide conflict-free and robust solutions for distributed robotic task allocation with a 50% optimality guarantee. Zhang et al. [27] further improved CBBA via dynamic task generation, asynchronous allocation, and partial path reconstruction, enabling it to adapt to complex tasks for heterogeneous UAVs in dynamic environments characterized by temporal and resource constraints. Zhang et al. [28] addressed the problems of emergency tasks, pop-up obstacles, and UAV failures in multi-UAV dynamic scheduling. They constructed a multi-constraint optimization model and proposed a hybrid Contract Net Protocol (CNP) integrating buy-sell, swap, and replacement contracts. Simulations verified that the generation delay of the scheduling scheme reaches the millisecond level. Liang et al. [29] proposed the Sensing-Communication-Control Co-Design Scheme, integrating algorithms such as Deep Q-Network (DQN) to maximize UAV energy efficiency, addressing the problems of low energy efficiency and inadequate communication reliability in satellite-aided UAV remote data collection. Tian et al. [30] proposed the Hierarchical Multi-Agent Parameterized Deep Q-Network (H-MA-PDQN), which integrates a dual-component structure for long-term coding and immediate resource allocation, to address the problems of low success rate and high transmission cost in UAV-assisted coded caching. Li et al. [31] addressed the heterogeneous task and service requirements in multi-UAV cooperative Mobile Edge Computing (MEC) networks, and proposed the Soft Actor-Critic (SAC)-Based Trajectory Optimization and Resource Allocation (SAC-TORA) algorithm based on the SAC framework. This algorithm jointly optimizes computational resource allocation, task scheduling, service placement, and UAV 3D trajectories, reducing system energy consumption and providing an efficient solution for low-carbon edge computing. Hao et al. [32] proposed a task-driven reliability-aware offloading (TRO) scheme to address the issues of insufficient reliability and decision delay in UAV-assisted edge computing task offloading. This scheme leverages the twin delayed deep deterministic policy gradient (TD3) to develop a deep reinforcement learning algorithm aimed at maximizing the long-term average task success rate. Performance assessment via both extensive simulations and a Kubernetes testbed demonstrates that the TRO scheme outperforms existing benchmark algorithms. Emami et al. [33] proposed an AI-enhanced mean-field resource allocation scheme, mean field hybrid proximal policy optimization (MF-HPPO), incorporating a Long Short-Term Memory (LSTM) to predict time-varying network states, to address the age of information (AoI) optimization problem in data collection by UAV. Ding et al. [34] proposed the Proximal Policy Optimization (PPO) algorithm that integrates threat assessment and a multi-head attention mechanism (TAPPO), solving the problems of traditional distributed target assignment algorithms for UAVs, including the lack of target strategic priority, poor scalability, and insufficient robustness. Alam et al. [1] developed a framework featuring a multi-agent gated recurrent unit (GRU)-based actor network and a multi-head attention-based critic network, which is inspired by swarm behavior, for joint air-ground resource scheduling. Li et al. [35] combined the fuzzy control theory with genetic algorithms to tackle resource scheduling problems.

This paper proposes a flexible combinatorial auction algorithm (FCAA) to address the resource scheduling problem of coordinating multiple groups of heterogeneous resources to collaboratively complete multiple tasks with the same priority. Compared with heuristic algorithms that are architecturally capable of handling such tasks, the proposed algorithm significantly reduces the search space and improves both search efficiency and solution quality. Existing auction algorithms also fail to effectively address this problem. In coalition-based auction frameworks for this type of scheduling, resources must form coalitions to bid on specific tasks. However, these methods overlook the adaptability between resources and tasks at the auction’s initial stage, lowering optimization efficiency. Furthermore, the algorithm’s stopping logic results in the output solution being closer to a low-quality feasible solution rather than the optimal one. The CBBA’s advantage is its decentralized nature: resources rank tasks based on local information and reach a consensus via local communication to generate a scheduling solution. However, this algorithm architecture can typically only handle single-resource-single-task scenarios. To incorporate resource collaboration, it still needs to be combined with coalition-based auctions, leading to a significant increase in time complexity. Although some improved auction algorithms based on the CNP can consider inter-resource collaboration during scheduling, their algorithmic architecture dictates that the priorities of all tasks must be determined before the auction commences.

Overall, although some existing scheduling algorithms have been widely applied and can handle heterogeneous resource scheduling problems with a small scale of resources and tasks, they exhibit poor performance in addressing large-scale resource-collaborative scheduling issues.

The remainder of this work is organized as follows. Section 2 presents the definition of the basic problem. Section 3 presents the flexible combinatorial auction algorithm. Section 4 presents ablation studies and comparative simulation experiments.

2. Problem Description and Model Construction

In the resource scheduling problem for coordinating multiple heterogeneous resources to complete tasks collaboratively, we model task processes, calculate the matching degree between resources and task processes, and select key metrics to define the mission effectiveness as the objective function. The overall goal of the problem is to schedule resources under the constraint of limited resources during task execution to ensure the completion of tasks and meet the optimization objectives, such as minimizing resource usage, minimizing total task duration, and balancing resource usage against task duration.

2.1. Resource-Task Modeling

We classified heterogeneous UAV resources into three types: search-specific resources, delivery-specific resources, and dual-capable UAV resources (i.e., those capable of both search and delivery tasks), whereas tasks are categorized into search tasks and delivery tasks. For search tasks, the optimization objective function is constructed with the coverage rate of the search area within the target zone, the number of deployed resources, and task completion time as key metrics. For delivery tasks, the optimization objective function incorporates the delivery success probability, the number of scheduled resources, and task completion time as key metrics.

2.2. Task Requirement Constraints

We established the matching constraints between the task requirements and the resource capabilities, covering both search and delivery tasks. The core capabilities of UAVs encompass multiple dimensions, such as radar, infrared, and electro-optical, with specific notations and descriptions provided in

Table 1. Definitions and ranges of UAV capability and task requirement indices.

Notation	Description	Type	Range & Interpretation
Rr	UAV-borne radar search capability index	Resource Capability Index	[0, 1]; Larger values indicate stronger UAV capability
Ri	UAV-borne infrared search capability index
Ro	UAV-borne electro-optical search capability index
Re	UAV-borne electronic signal search capability index
Rm	UAV-borne magnetometer search capability index
Ra	UAV-borne search accuracy index
Rd	UAV-borne comprehensive delivery capability index
Rai	UAV-borne search anti-interference capability index
Tr	Radar search capability requirement index for the task	Task Requirement Index	[0, 1]; Larger values indicate higher required by the task
Ti	Infrared search capability requirement index for the task
To	Electro-optical search capability requirement index for the task
Te	Electronic signal search capability requirement index for the task
Tm	Magnetometer search capability requirement index for the task
Ta	Search accuracy requirement index for the task
Td	Comprehensive delivery capability requirement index for the task
Tai	Search anti-interference capability requirement index for the task

.

Taking the resource capability indexes as examples, their practical applications are illustrated as follows: R_r: surveying UAVs for radar-based detection of ground micro-topographic changes; R_i: rescue UAVs for nighttime search of heat signatures from lost personnel in wilderness regions; R_o: agricultural UAVs for electro-optical detection of crop disease spots or pest infestations; R_e: emergency rescue UAVs for locating signals from ground emergency beacons of trapped people; R_m: geological survey UAVs for detecting weak magnetic anomalies in shallow underground areas; R_a: power inspection UAVs for identifying transmission line defects with specified search resolution; R_d: wilderness rescue UAVs for delivering first-aid kits and thermal blankets to trapped people in mountainous areas (overcoming strong winds, payload weight, weak GPS signals, etc.); R_ai: UAVs with airborne electro-optical equipment for resisting glare interference during daytime search operations.

Both resource and task indices represent comprehensive capabilities with values ranging within the closed interval [0, 1]. The larger the value, the stronger the resource’s capability or the higher the task’s requirement for the corresponding capability. Taking the radar search capability index as an example, consider the UAV’s radar search capability R_r = 0.5 and the task’s required radar search capability index T_r = 0.4. Since R_r > T_r, this indicates that the UAV’s radar search capability meets the task’s requirement.

The calculation method for the resource-task capability matching value is defined as follows:

$$\begin{array}{r}{c}_s=(R_r\ge T_r)\wedge (R_o\ge T_o)\wedge (R_e\ge T_e)\wedge (R_m\ge T_m)\\ \wedge (R_i\ge T_i)\wedge (R_{ai}\ge T_{ai})\wedge (R_a\ge T_a)\wedge (R_d\ge T_d)\end{array}$$

(1)

where c_s denotes the resource-task capability matching result; c_s = True if the resource capability meets the corresponding task requirement, and c_s = False otherwise.

2.3. Design of Evaluation Indicators

By modeling the search and delivery task processes, task performance metrics are extracted to construct the objective function.

2.3.1. Modeling of Search Tasks

The modeling of search tasks considers search accuracy and time constraints [36,37]. First, the latitude and longitude coordinates of the target area are obtained. Adjacent rectangles, derived from the axis-aligned bounding boxes (AABBs) of the convex polygonal target area, are used to calculate the spherical polygon area, thereby determining the area to be searched. After dividing the search area and assigning resources based on availability, the path-planning algorithm generates a snake-shaped search path for each sub-area using relevant target area data. The maximum scan area and the estimated search duration prior to the deadline are calculated using the following formulas:

$$\left\{\begin{array}{c}{S}_j=w_j*(deadline-{\displaystyle \frac{d_j}{v_j}})\\ t_j={\displaystyle \frac{d_j+d_{path}}{v_j}}\end{array}\right.$$

(2)

where S_j denotes the maximum scanning area of resource j, w_j denotes the scanning width of resource j during the search, the deadline denotes the task deadline, d_j denotes the distance from resource j’s departure point to the boundary of the assigned area, v_j denotes the flight speed of resource j, t_j denotes the duration for resource j to complete the search of the assigned area, and d_path denotes the length of the snake-shaped search path planned for the assigned area of the task currently being computed.

After sequentially calculating the maximum scanning area and search duration for the assigned area of each selected resource, the maximum scanning area of the resource group and the task completion time are computed using the following formulas:

$$\left\{\begin{array}{c}S={\displaystyle \sum _{j=1}^n{S}_j}\\ t=\max \left(t_j\right), \forall j\in [1,n_r]\end{array}\right.$$

(3)

where S denotes the maximum scanning area of the resource group, t denotes the task completion time, and n_r denotes the actual number of deployed resources.

Based on evaluation indicators such as the maximum scanning area of the resource group, the task completion time, and the number of scheduled resources for the task, the objective function is constructed. These designed objective functions are used to address different task scheduling requirements, including minimizing resource usage, minimizing total task duration, and balancing resource usage against task duration, as follows:

When c_s = False, the resource is deemed completely incapable of completing the task; in this case:

$$fitness=0.001$$

(4)

When c_s = True and the deadline < t, the resource is considered to have partial capacity to complete the task but cannot do so fully; in this case:

$$fitness={\displaystyle \frac{S}{S_T}}$$

(5)

When c_s = True and the deadline ≥ t, the resource can fully complete the task; in this case:

$$fitness=a+b*{\displaystyle \frac{n_R}{n_r}}+c*{\displaystyle \frac{deadline}{t}}$$

(6)

where fitness represents the quality of a solution, n_R denotes the total number of available resources, and S_T denotes the target area. The parameters [a, b, c] are adjusted to accommodate different task scheduling preferences: [1, 1, 0] is set when the objective is to minimize resource usage, [1, 0, 1] is set for minimizing total task duration, and [0, 1, 1] is set to balance resource usage and task duration. Here, fitness represents the effectiveness of completing the task with the given solution, where a higher value is preferable. If a solution that fails to meet the task’s requirements is selected for execution, the fitness value is set to 0.001. When a scheduling solution cannot fully complete the task, the fitness value is less than 1; when the solution can fully complete the task, the fitness value is greater than or equal to 2.

2.3.2. Modeling of Delivery Tasks

The modeling of delivery tasks considers the delivery success probability and the delivery time [38]. Based on the latitude, longitude, and flight speed of each delivery UAV resource j, as well as the target’s latitude, longitude, moving speed, and moving direction, equations are established to calculate UAV j’s catch-up time and the time required for UAV j to reach the predicted intersection point with the target. The model does not account for the initial velocity of delivery UAVs prior to takeoff or their acceleration.

First, taking the coordinates of the delivery target as the vertex, compute the angle between the two lines connecting this point to the coordinates of the resource and to the predicted intersection point:

$$\left\{\begin{array}{c}\begin{array}{l}\Delta y=y_2-y_1\\ \Delta x=x_2-x_1\end{array}\\ A=\arccos \left(-{\displaystyle \frac{\Delta y}{\sqrt{\Delta x^2+\Delta y^2}}}\right)+\theta \end{array}\right.$$

(7)

where A represents the angle between the lines connecting the delivery target’s coordinates to the resource’s coordinates and to the coordinates of the predicted intersection point; (x₁, y₁) and (x₂, y₂) denote the Cartesian coordinates of the resource and the delivery target, respectively, following conversion to the Cartesian coordinate system; and θ represents the direction angle of the delivery target’s motion, with 0° defined as due north.

In the triangle formed by the coordinates of the delivery target, the delivery resource, and the predicted intersection point, an equation is derived using the Law of Cosines to calculate the intersection time, as follows:

$$\left(v_1^2-v_2^2\right)t_j^2+2v_2\cos A\sqrt{\Delta x^2+\Delta y^2}•t_j-\left(\Delta x^2+\Delta y^2\right)=0$$

(8)

where v₁ and v₂ denote the moving speeds of the delivery target and the delivery resource, respectively.

The mission duration is calculated through determining the intersection time for each deployed delivery resource, with the concurrent calculation of the delivery success probability:

$$\left\{\begin{array}{c}p=1-{\displaystyle \prod _{j=1}^{\mathrm{n}}\left(1-p_j\right)}\\ \begin{array}{cc}t=\max \left(t_j\right)& \forall j\in [1,n_r]\end{array}\end{array}\right.$$

(9)

where p denotes the total delivery success probability of the mission, p_j denotes the corresponding probability of resource j, t denotes the mission duration, and t_j denotes the time resource j takes to complete the mission.

Taking the delivery success probability, the mission duration, and the number of deployed resources as the evaluation metrics, we construct an objective function. We design this objective function to address three scheduling preferences: minimal resource usage, minimal total mission duration, and a balanced trade-off between resource usage and mission duration, as follows:

When c_s = False, the resource is deemed completely incapable of completing the task; in this case, the fitness calculation formula is the same as Equation (4).

When c_s = True, if the deadline < t or p_r > p, the resource is considered to have partial capacity to complete the task but cannot do so fully; in this case:

$$fitness={\displaystyle \frac{\min \left(1,\frac{p}{p_r}\right)}{2}}+{\displaystyle \frac{\min \left(1,\frac{deadline}{t}\right)}{2}}$$

(10)

When c_s = True, deadline ≥ t, and p_r ≤ p, the resource can fully complete the task; in this case, the fitness calculation formula is the same as Equation (6). The symbol meanings and value assignment rules for a, b, and c are consistent with those of the search task model.

2.4. Mathematical Model

For ease of calculation and observation, the mathematical expression of the model is designed as:

$$\max \mathit{benefit}=-{\log }_{0.87}\left(fitness\right)-5$$

(11)

This multi-resource scheduling problem involves optimizing the resource scheduling scheme under the premise of satisfying constraint conditions to maximize the benefit (i.e., maximizing the fitness value).

Considering the algorithm’s optimization requirements and the clarity of visual expression, this study takes into account relevant factors and the value range of fitness, and selects a logarithmic base of 0.87. This base is determined based on experimental results, primarily driven by the following two considerations: First, this base can maintain a numerical range of 100 for the benefit when the fitness ranges from 0.001 to 1000, thereby effectively and appropriately expanding benefit differences among schemes and enhancing the algorithm’s ability to identify and screen inferior solutions; second, when fitness = 2, the value obtained after this specific logarithmic transformation with base 0.87 is close to an integer, making the final benefit values adopt 0 as the demarcation point, thereby significantly distinguishing between feasible and infeasible schemes and facilitating intuitive visualization in charts.

In this model, when a scheduling scheme completely fails to meet the mission requirements, benefit is approximately −55; when the scheme cannot fully complete the mission, benefit is negative; when the scheme can complete the mission, benefit is non-negative. A higher benefit value indicates a better-performing scheme.

3. Flexible Combinatorial Auction Algorithm

This paper proposes a flexible combinatorial auction algorithm for heterogeneous resource scheduling based on the bidding mechanisms of simultaneous ascending auctions [39]. In this algorithm, tasks serve as bidders and resources serve as auction items. Before the auction starts, each bidder generates a set of candidate resource allocation schemes. After encoding each scheme, the proposed model calculates the corresponding benefit as the bidder’s valuation of the scheme. Each bidder then submits total-price bids for resource bundles, and these total prices are allocated to individual resources based on current prices. The algorithm determines resource prices following the rules of simultaneous ascending auctions, operates and terminates in accordance with predefined auction mechanisms, and finally outputs the optimal scheduling results.

3.1. Auction Algorithm

Based on the summary of existing research results on auction algorithms, the core content of the classical auction algorithm is as follows [40,41]:

Background: There are n bidders and n items, where the final allocation requires each bidder to win exactly one item, and all items to be allocated.

Stopping criterion: Either all bidders have won an item, or all bidders have negative benefits.

Objective: Maximize the total benefit of the items assigned to the bidders.

In each iteration of the classical auction algorithm, each bidder selects only one item to bid on according to predefined rules, setting all other bids to zero. The algorithm iterates until it meets the stopping criterion. Although relatively mature in research and widely applied, it requires the number of bidders to equal the number of items, and each bidder can win exactly one item.

3.2. FCAA Bidding Mechanism and Execution

The FCAA is developed by enhancing the classical auction algorithm’s core concepts.

Background: There are n tasks (bidders) and m resources (items). Under this framework, each bidder can win multiple items; not all items need to be allocated, but the combination of items won by each bidder must satisfy their respective requirements.

Stopping criterion: Either all bidders have acquired items that satisfy their requirements without inter-bidder allocation conflicts (indicating a successful auction), or all bidders have negative benefits (indicating a failed auction).

Objective: The objective is to maximize the total benefit of the items selected by the bidders. Since each bidder only bids on the optimal item combination under its current constraints, as long as each bidder secures at least one item and not all bidders have negative benefits, the resulting allocation is expected to be high-quality.

Overall, the auction structure of the FCAA is as follows (see Figure 1).

Here, p_ij represents the bid of task i for resource j, and p_j* denotes the current price of resource j derived from all bidders’ bids. In each round, each task submits a total bid for its optimal resource combination in accordance with predefined rules, allocates the total bid to individual resources, and generates p_ij (its bid for the corresponding resource). Bids for unselected resources are set to 0.

The operational flowchart of the FCAA developed for heterogeneous UAV resource scheduling problems is as follows (see Figure 2).

The bidding mechanism follows the bid formula of classical auction algorithms [40,41]. Task i has a valuation for each candidate solution, and the benefit of each candidate solution is defined as the valuation of the candidate solution minus the sum of the current prices of all resources within it. The algorithm bids for the candidate solution with the highest expected benefit in each round. The bid formula of classical auction algorithms is as follows:

$$p_{{\mathrm{ij}}^{*}}=b_{j^{*}}+g_{i{j}^{*}}-g_{i{j}_1^{*}}+\epsilon$$

(12)

where p_ij* represents the bid of task i for resource j*, b_j* is the current price of resource j*, g_ij* is the current optimal benefit of task i, g_ij1* is the suboptimal benefit of task i, and ε is the minimum price increment per bidding round. Under the guidance of this formula, as the current price of the resource corresponding to the optimal benefit continues to rise during the auction, the algorithm will shift to bidding on the previously suboptimal solution, ensuring a reasonable scheduling result.

The specific operational steps of the FCAA are as follows:

Step 1: Generate candidate solutions.

After the evaluation model calculates the benefit of each resource for task i, it sorts the resources in descending order to form the list α_i = {R_j(1),R_j(2),Rj₍₃₎,…,R_j(u),…,R_j(m)}. The j(1) denotes the index of the resource with the highest matching degree. The first u resources from the sorted sequence form a resource group {R_j(1),R_j(2),R_j(3),…,R_j(u)}. If this resource group can exactly complete task i, its resource count is denoted as u_i.

After traversing all tasks, the algorithm calculates the maximum number of available resources for each task:

$$R_{\max i0}=m-{\displaystyle \sum _{i\ne i_0}{u}_i}$$

(13)

where R_maxi0 denotes the maximum number of available resources allocated to task i₀ in the candidate solution, m is the total number of resources, and u_i is the minimum number of resources required to complete task i.

This constraint is introduced because if the number of resources in a candidate solution exceeds the task’s R_maxi0, other tasks will inevitably remain uncompleted, resulting in resource scheduling failure.

For task i, the algorithm first selects the top u_i resources from the single-resource benefit ranking α_i to form a resource group, thereby initiating the preparation of auction candidate solutions.

When u_i = 1, it indicates the existence of resources capable of independently completing task i; such resources are termed “independent resources”. The algorithm groups all independent resources into an independent resource group, randomly selects resources from this group, generates a specific number of candidate solutions at each resource quantity level as representatives of the corresponding level, and adds them to the candidate solutions. Then, the algorithm removes the used resources from α_i, calculates the minimum number of resources required to complete task i using the remaining resources, and updates this number to u_i. It then selects the top-ranked u_i resources from the updated α_i to form a new resource group, and continues generating candidate solutions according to the rules.

When u_i < R_maxi + 1, the algorithm generates all candidate solutions employing u_i − 1 resources based on this resource group, filters those capable of completing task i, and adds them to the candidate solutions. Then, the algorithm adds the best unused resource in α_i to the end of the resource group and continues attempting to generate the next batch of candidate solutions.

When u_i ≥ R_maxi + 1, the algorithm deletes the frontmost resource in the resource group to ensure the group’s resource count remains R_maxi + 1. The algorithm then generates all candidate solutions employing u_i − 1 resources based on this resource group, and adds the best unused resource in α_i to the end of the resource group. It keeps a tally of the number of deleted resources: when a total of u_i resources have been deleted, the generation of this batch of candidate solutions for task i is completed. The algorithm repeats this step until all resources in α_i have been used, indicating that all candidate solutions for task i have been generated.

The Algorithm 1 and

Table 2. Initial candidate solutions generation rules.

Order of Single Resource Matching Degree	Resource Group	Candidate Solution Generation Rules
Rj(1),Rj(2), …,Rj(m−1),Rj(m)	Rj(1), Rj(2), …, Rj(u1−1)	All independent resources form the resource group, and a specific number of candidate solutions are, respectively, generated within the order of magnitude from 1 to u1 − 1.
	Rj(u1)	The resource group cannot complete the task.
	Rj(u1), Rj(u2)	The resource group cannot complete the task.
	…	…
	Rj(u1), Rj(u2), …, Rj(ui)	Generate ui − u1 + 1 solutions, where each solution includes ui − u1 resources.
	…	…
	Rj(u1), Rj(u2), …, Rj(u1+Rmax)	Generate Rmax + 1 solutions, where each solution includes Rmax resources.
	…	…
	Rj(ui), …, Rj(ui+ui)/ R(ui+Rmax)	Generate ui + 1/Rmax + 1 solutions, where each solution includes ui/Rmax resources.

simultaneously present the rules for generating the first batch of candidate solutions.

Algorithm 1: First Batch Scheduling Candidate Solutions Generation Algorithm

Input: Task i, Resource set R = {R1, R2, …, Rm}, Resource set sorted by descending benefit αi = {Rj(1), Rj(2), …, Rj(m−1), Rj(m)}, Minimum required resources ui, Maximum available resources constraint Rmax, Number of candidate solutions generated per magnitude for independent resources num Output: First batch of scheduling candidate solutions S 1: Initialization: 2: S ← ∅//Initialization of candidate solution set 3: GroupR ← ∅//Initialization of resource group 4: ActiveR ← αi //Available resource pool 5: Base ← ∅//Initialization of candidate solutions 6: RemoveN ← 0 //Initialization of the count of deleted resources 7: GroupR ← αi [1..ui] //Select the first ui resources 8: if |GroupR| > Rmax then 9:   return S //No feasible solutions satisfying constraints 10: while ActiveR ≠ ∅ do 11:  if ui == 1 then://Independent resource: A single resource can complete the task 12:    GroupR ← GroupR ∪ {all independent resources} 13:    for g ∈ {1, …, |GroupR|} do 14:      S ← S ∪ generate_combinations(GroupR, g, num)//Generate num          solutions with g resources based on GroupR 15:    ActiveR ← ActiveR\GroupR 16:    ui ← update_the_minimum_required_resources(ActiveR) 17:    GroupR ← αi [1..ui]//Select the first ui resources as GroupR 18:  else if |GroupR| < Rmax + 1 then://The number of resources in GroupR is small. 19:    Base ← generate_combinations (GroupR, −1, |GroupR| − 1)//Generate all          candidate solutions with |GroupR| − 1 resources from GroupR. 20:    S ← S ∪ filter_to_obtain_valid_solutions (Base)//Filter out invalid candidate           solutions from Base 21:    GroupR ← incorporate_new_resources (ActiveR)//Remove the optimal            resource from ActiveR and add it to the end of GroupR. 22:  else //The number of resources in GroupR is large. 23:    while |GroupR| ≥ Rmax + 1 do 24:      GroupR ← GroupR [2..end]//Maintain the total number of resources in          GroupR at Rmax. 25:      Base ← generate_combinations (GroupR, −1, Rmax)//Generate all            candidate solutions with Rmax resources from GroupR 26:      S ← S ∪ filter_to_obtain_valid_solutions (Base) 27:      RemoveN ← RemoveN + 1 28:      GroupR ← incorporate_new_resources (ActiveR)//Remove the optimal             resource from ActiveR and add it to the end of GroupR. 29:      if RemoveN ≥ ui or αi == ∅ then break 30:    end while 31:  end if 32: end while 33: return S

The solutions generated in the above steps are all closely linked to the base solution {R_j(1),R_j(2),…,R_j(ui)}, and all candidate solutions generated in this batch are defined as derived solutions of this base solution. Next, the first ui resources are removed from α_i, and the algorithm continues generating candidate solutions following the previous rules. This process repeats until the maximum number of resources in the resource group is less than u_i, at which point all candidate solutions for task i are considered generated.

Batch Scheduling Candidate Solutions Generation Algorithm

Table 3. Other candidate solutions generation rules.

Order of Single Resource Matching Degree	Resource Group	Candidate Solution Generation Rules
Rj(u+1),Rj(u+2), …,Rj(m−1),Rj(m)	Rj(u+1)	The resource group cannot complete the task.
	Rj(u+1), Rj(u+2)	The resource group cannot complete the task.
	…	…
	Rj(u+1), …, Rj(u+1+ui)	Generate ui + 1 solutions, where each solution includes ui resources.
	…	…
	Rj(u+1), …, Rj(u+1+Rmax)	Generate Rmax + 1 solutions, where each solution includes Rmax resources.
	…	…
	Rj(u+1+ui), …, Rj(u+1+2×ui)/Rj(u+1+ui+Rmax)	Generate ui + 1/Rmax + 1 solutions, where each solution includes ui/Rmax resources.

presents the generation rules for candidate solutions in the remaining batches.

Two steps exist to add candidate solutions to the task’s candidate solution library during the algorithm execution:

(i)

Before initiating the auction algorithm, add a certain number of solutions to the task’s candidate solution library according to predefined rules;

(ii)

During the auction process, before task i submits a bid, the algorithm checks the number of solutions in its candidate solution library. If the count is below a predetermined threshold, the algorithm further checks for remaining available solutions. If any exist, add additional solutions to the library until the number of candidate solutions exceeds the threshold or no more solutions can be generated.

Solutions are batched by the number of resources they utilize, prioritizing those requiring fewer resources. For example, when adding candidate solutions initially, add all solutions with resource counts less than or equal to u_n sequentially. For subsequent additions, add solutions with resource counts greater than u_n but less than 2u_n, and so on, until the auction ends or no more solutions can be added.

Step 2: Valuation and benefit calculation.

For each task i, the algorithm defines the benefit of each solution as its valuation. Adopt different estimation formulas according to each task’s execution objectives to meet diverse requirements, such as minimizing completion time, minimizing resource usage, or balancing time and resource usage.

Based on the current price of each resource, the algorithm calculates the benefit of each solution sequentially based on each solution’s valuation. If this is the first execution, the algorithm first sets a reserve price. Calculate the benefit of solution k for task i using the following formula:

$$G_{ik}=W_{ik}-{\displaystyle \sum _{j\in K}{B}_j}$$

(14)

where G denotes the set of selection benefits of all solutions for task i, and G_ik represents the current selection benefit of solution k for task i; W denotes the set of valuations of all solutions for all tasks, and W_ik represents the valuation of solution k for task i; B denotes the set of current prices of all resources, and B_j represents the current price of resource j.

Step 3: Commence bidding.

Tasks place bids in turn, each time selecting the solution with the highest benefit from the pending solutions as a bidding target. The total bid prices for each task are calculated according to the rules, and bids for each resource in the selected solution are also similarly calculated. After all tasks complete one round of bidding, the process proceeds to the inspection phase. The formula for calculating the total bid price is as follows:

$$P_{ik}={\displaystyle \sum _{j\in K^{*}}{B}_j}+{\displaystyle \sum _{j\in K^{*}}{G}_{ij}}-{\displaystyle \sum _{j\in K_1^{*}}{G}_{ij}}+\epsilon$$

(15)

where P denotes the set consisting of two types of data in the current bidding round: the total bid prices of all candidate solutions for all tasks, and the bid prices of each utilized resource corresponding to these solutions; P_ik represents the total bid price of solution k for task i, extracted from the total bid prices in set P; K denotes the set of resources utilized in each solution; K* represents the optimal solution; K₁* represents the suboptimal solution; and ε denotes the minimum increment for each bid.

The bid price calculation formula for a single resource j₀ is as follows:

$$P_{i{j}_{0}k}=B_{j_0}+{\displaystyle \frac{{\displaystyle \sum _{j\in K^{*}}{G}_{ij}}-{\displaystyle \sum _{j\in K_1^{*}}{G}_{ij}}+\epsilon }{n}}$$

(16)

where P_ij0k represents the bid price for resource j₀ in solution k of task i, extracted from the bid prices of each utilized resource in set P; B_j0 denotes the current price of resource j₀; and n is the number of resources utilized in the optimal solution K*.

Step 4: Check for resource allocation conflicts.

Verify whether there are resource allocation conflicts among the solutions submitted by each task. If conflicts exist, tasks with the non-highest bid prices involved in the conflict must reassess whether to add new solutions, calculate valuations, compute benefits, and initiate the next round of bidding according to the rules. If no conflicts exist, the bidding concludes, and scheduling proceeds based on each task’s winning solutions.

4. Ablation Studies and Simulation

We randomly generated resource and task parameters within preset ranges based on scenario settings. Resources were categorized into search-only, delivery-only, and dual-capable UAVs (i.e., capable of both search and delivery). Their parameters included location coordinates, flight speed, scan width, delivery success rate, loaded flight speed, and search and delivery capability indices. Based on their inherent characteristics, distinct parameter ranges were defined for different resource types; a single resource capable of delivery might include multiple sub-resources that can deliver independently. Tasks were divided into search tasks and delivery tasks, and their parameters included task type, completion deadline, scheduling preference, target search area coordinates, required search capability indices, and delivery target coordinates, movement speed, movement direction, required delivery success rate, and required delivery capability indices. Specifically, search areas were randomly generated by an algorithm within a geographical range spanning 5° longitude (east–west) and 4° latitude (north–south), and could take various shapes from triangles to nonagons. Each delivery task included 2–6 targets, which were classified into fast-moving, slow-moving, and fixed targets; distinct task-specific parameter value ranges were specified for different types of targets according to their characteristics. During scheduling, each delivery target was treated as an independent delivery subtask for resource assignment.

We defined numerical ranges for each resource and task index according to their inherent characteristics, then randomly generated descriptive index values for individual resources and tasks using a uniform probability distribution. Finally, we constructed a resource pool with 3000 diverse resources and a task pool containing 500 search tasks and 500 delivery tasks. A random sampling strategy was employed to generate subsequent simulation cases: a predefined number of individual resources and tasks were randomly selected from the resource pool and the task pool, respectively, then combined to form a single simulation case, thereby fully reflecting task diversity and resource heterogeneity.

The FCAA was compared with two variants—the FCAA with a single generation of candidates (FCAA-S) and the FCAA with enumeration of candidates (FCAA-E)—as ablation studies. Additionally, scheduling results were compared with those of the genetic algorithm (GA), quantum genetic algorithm (QGA), zebra optimization algorithm (ZOA) [19], advantage actor-critic reinforcement learning (A2C), social learning discrete particle swarm optimization (SLD-PSO) [20], and growth optimization algorithm (GO) [21].

It should be noted that the setting of ε is associated with the value range of the benefit. From problem modeling and analysis, we find the benefit ranges from −55 to 45 for non-extreme scheduling schemes. Based on experimental tests, the minimum single price increment parameter ε was set to 0.05 for all the FCAAs (including the FCAA, FCAA-S, and FCAA-E). This setting was designed to balance search efficiency with comprehensive coverage of the search space. It enabled the algorithm to explore feasible solutions effectively while preventing the omission of high-quality solutions that could result from an excessively narrowed search.

4.1. Ablation Studies

The FCAA was compared with two variants—the FCAA-S and FCAA-E—as ablation studies to verify the effects of the candidate solution generation and addition mechanisms. Both FCAA-S and FCAA-E generated all candidate solutions in a single step before each scheduling round. Specifically, the FCAA-S adopted a flexible combinatorial approach to generate solutions, while the FCAA-E adopted an enumeration method. Considering the problem complexity and algorithmic computation time, the number of candidate solutions for each task in the FCAA-E was limited to 2000.

Considering the need to compare algorithmic performance, the ablation studies used small-scale multi-task resource scheduling simulation cases, where each scheduling instance handled either a single search task or a single delivery task. Each search task had one target area, and each delivery task contained multiple targets in the same batch, treated as independent tasks. The task set was formed by selecting either one search task or one delivery task; the resource set was formed by randomly selecting 5–30 resources from the resource pool. Each task was matched with a resource set capable of fulfilling it to form a simulation case. We employed seven algorithms (FCAA, GA, QGA, SLD-PSO, GO, ZOA, and A2C) to select such eligible resource sets, with each algorithm generating a certain number of simulation instances.

A total of 1000 simulation cases were generated for this part of the study. All cases collectively included 2532 tasks and 53,451 resources, and each case contained an average of 2–3 tasks and 53–54 resources. The key information is shown in

Table 4. Simulation case information for the ablation studies scheduling.

Total Number of Simulation Cases	Average Number of Tasks per Case	Average Number of Resources per Case
1000	2–3	53–54

.

Each algorithm was sequentially executed on the cases; the benefit and runtime of its output solutions were recorded, with results plotted as follows. The abscissa represents the temporary task index, with data sorted in ascending order based on the FCAA’s benefit and runtime. A benefit value less than 0 indicates a solution cannot complete the task; the higher the value, the better the solution quality. The case scheduling success rate was calculated at the case level, while the task completion rate was statistically analyzed for each subtask within individual cases. The proportion of maximum benefit was defined as the ratio of the number of test cases where a single algorithm’s scheduling benefit reached the case’s maximum scheduling benefit to the total number of test cases. For a single test case, if multiple algorithms had scheduling benefits equal to each other to three decimal places and all were the optimal value for that test case, these algorithms were all deemed “maximum benefit algorithms” for the case and were counted separately in the statistics of maximum benefit cases for each algorithm.

The simulation results are shown in Figure 3 and Figure 4, and

Table 5. Results of ablation studies scheduling simulation.

Algorithm	Case Scheduling Success Rate	Task Completion Rate	Average Benefit	Proportion of Maximum Benefit	Average Runtime (t/s)
FCAA	88.5%	95.0%	42.2	77.3%	0.74
FCAA-E	77.0%	86.4%	41.4	70.2%	70.01
FCAA-S	88.5%	94.8%	42.0	70.7%	2.48

.

Regarding average benefit, the FCAA, FCAA-S, and FCAA-E exhibited no significant differences. Compared with the FCAA-S, the FCAA exhibited a difference of less than 0.2% in the scheduling success rate and task completion rate. However, the FCAA-S attained a lower proportion of the maximum benefit than the FCAA, and its average runtime was 2.4 times longer than that of the FCAA. This was because the FCAA-S devoted substantial time to generating more candidate solutions prior to auctions, thereby increasing the total runtime despite reducing the time required for auction-based optimization.

When comparing the FCAA-S and FCAA-E, the FCAA-S achieved an 11.5% higher case scheduling success rate, an 8.4% higher task completion rate, and a 0.5% higher proportion of maximum benefit. The average runtime of the FCAA-E was 28 times that of the FCAA-S.

Considering the differences in complexity among different scheduling use cases and the benefits of theoretical optimal solutions, in order to eliminate the interference of the inherent characteristics of the use cases on algorithm performance evaluation, it was necessary to first standardize the original scheduling benefits and running times: we adopted Z-score standardization to process the benefit data, and normalized the running time data based on the minimum running time of all algorithms under each use case, with the formulas as follows:

$$\left\{\begin{array}{c}\mu ={\displaystyle \frac{1}{q}}{\displaystyle \sum _{l=1}^q{\mathrm{benefit}}_l}\\ \sigma =\sqrt{{\displaystyle \frac{1}{q-1}}{\displaystyle \sum _{l=1}^q{({\mathrm{benefit}}_l-\mu )}^2}}\\ norm\_benefi{t}_l={\displaystyle \frac{benefi{t}_l-\mu }{\sigma }}\times 100\%\\ norm\_t_l={\displaystyle \frac{t_l}{\min \left\{t_1,t_2,\dots ,t_l\right\}}}\end{array}\right.$$

(17)

where q denotes the number of algorithms compared in this round, μ and σ denote the mean and standard deviation of the benefits obtained by all compared algorithms for the same use case, norm_benefit denotes the standardized benefit data, and norm_t denotes the normalized running time data.

Subsequently, we computed the standard deviation and the 95% confidence interval (t-distribution) based on the normalized data to characterize the robustness and statistical reliability of algorithm performance. The statistical results of the ablation studies scheduling simulation are shown in

Table 6. Statistical results of ablation studies scheduling simulation.

Algorithm	Standardized Benefit Data			Normalized Time Data
	Mean	Std. Dev.	95% CI	Mean	Std. Dev.	95% CI
FCAA	0.007	0.46	[−0.02, 0.007]	1.01	0.03	[1.003, 1.005]
FCAA-E	0.087	0.79	[0.04, 0.09]	110.1	93.9	[104.2, 110.0]
FCAA-S	−0.094	0.44	[−0.12, −0.09]	2.73	3.21	[2.531, 2.730]

.

Based on the statistical results of the standardized benefit data and the normalized time data in the table, the analysis of the performance differences between the FCAA and the comparative algorithms (including the FCAA-S and FCAA-E) was as follows:

In terms of standardized benefit, although the mean benefit of the FCAA and the FCAA-S was slightly lower than that of the FCAA-E, the standard deviation and the 95% confidence interval values of their benefit data were significantly smaller, indicating superior stability in benefit outputs. In contrast to the FCAA-S, although the FCAA’s benefit standard deviation was slightly higher, its mean benefit and the 95% confidence interval values exhibited superior performance, achieving a higher benefit level.

In terms of time cost, the algorithms exhibited distinct hierarchical advantages: the FCAA was comprehensively superior to the FCAA-S, while the FCAA-S was comprehensively superior to the FCAA-E. Specifically, compared with the latter in each pair, the former demonstrated significant advantages in terms of the mean, standard deviation, and 95% confidence interval of its normalized time, exhibiting not only higher execution efficiency but also more stable time cost performance, thereby more reliably satisfying the timeliness requirements of task execution.

Ablation study results demonstrated that the proposed candidate solution generation mechanism was far superior to the commonly used enumeration method for solution generation in terms of generation efficiency and solution quality; the proposed candidate solution addition mechanism not only significantly shortened the scheduling time but also enabled efficient optimization while maintaining the solution quality.

4.2. Small-Scale Multi-Task Resource Scheduling

This section employed the 1000 simulation cases adopted from the ablation studies to compute the scheduling results of the FCAA and compare them with those of the GA, QGA, SLD-PSO, GO, ZOA, and A2C.

The A2C algorithm is based on the Advantage Actor-Critic framework, designed for resource scheduling in delivery and search tasks. Specifically, the actor network adopts a pointer network structure with the embedding layer, the LSTM encoder, and the decoder: it uses a glimpse mechanism to focus on key information and a pointer mechanism to generate action probability distributions, outputting resource scheduling paths and corresponding log probabilities, and is responsible for deciding “how to schedule”. Meanwhile, the critic network, which also uses an LSTM encoder, processes state information through a glimpse mechanism and outputs state values via a fully connected layer, and is responsible for evaluating “how good the current state is”. As for the training method, during training, the actor updates its policy based on the advantage (return—state value) evaluated by the critic to maximize cumulative rewards; the critic is updated using Mean Squared Error (MSE) loss to optimize state value estimation, and these two networks collaborate to enhance resource scheduling efficiency (e.g., reducing task completion time and improving resource utilization). In summary, based on this framework, the actor maximizes the advantage-weighted reward, while the critic minimizes the value estimation error. The Architecture of the agent is shown in

Table 7. Architecture of the A2C agent.

Item	Actor Network	Critic Network
Core Structure	Embedding layer + LSTM Encoder/Decoder + glimpse/pointer mechanisms	Embedding layer + LSTM Encoder + glimpse mechanism + fully connected layer
Input	Resource-Task-relevant Status (e.g., coordinates, speed)	Resource-Task-relevant Status
Output	action log probabilities	State values
Update Basis	Advantage evaluated by Critic	Error between actual return and predicted value

.

The other algorithms were heuristic algorithms proposed in published papers. Considering their search efficiency, they were configured in the experiments to stop and output the results once a feasible solution was found or the set number of optimization iterations was reached. The core hyperparameter information of these algorithms is shown in

Table 8. Hyperparameter settings of baseline algorithms.

Algorithm	Core Parameter Category	Parameter Configuration
GA	Population Size	max(resource_count, 50)
	Number of Generations	max(resource_count, 30)
	Change Rate	0.4
	Mutation Rate	0.2
QGA	Population Size	max(resource_count, 50)
	Number of Generations	max(resource_count, 30)
	Mutation_Rate	0.1
	Bit_Mutation Rate	0.01
SLD-PSO	Population Size	max(resource_count × 0.4, 20)
	Number of Generations	max(resource_count, 60)
	Acceleration Factor c1	Linearly decreasing (0.9 → 0.15) for individual cognition.
	Acceleration Factor c2	Linearly increasing (0.4 → 0.9) for social learning.
GO	Population_Size	max(resource_count × 2, 40)
	Maximum Function Evaluations	max(resource_count2, 2000)
	Population Division Parameter	5
	Retention Probability Parameter	0.001
	Elite Guidance Probability Parameter	0.3
ZOA	Population Size	max(resource_count, 50)
	Number of Generations	max(resource_count, 30)
	Defense Strategy Coefficient	0.01

.

The simulation results are shown in Figure 5 and Figure 6 and

Table 9. Results of small-scale multi-task resource scheduling simulation.

Algorithm	Case Scheduling Success Rate	Task Completion Rate	Average Benefit	Proportion of Maximum Benefit	Average Runtime (t/s)
FCAA	88.5%	95.0%	42.2	83.9%	0.74
GA	67.2%	86.8%	33.7	5.9%	1.63
QGA	52.6%	80.4%	31.7	6.6%	2.01
SLD-PSO	46.1%	76.6%	24.8	0.1%	0.62
GO	61.3%	84.6%	30.2	4.5%	0.28
A2C	64.0%	82.1%	29.5	0.3%	0.07
ZOA	52.3%	79.3%	26.1	4%	3.10

.

The FCAA achieved an average case scheduling benefit of 42.2, with both the case scheduling success rate and the task completion rate far exceeding those of the comparative algorithms. The proportion of cases where the FCAA achieved the maximum benefit reached 83.9%. Among the 115 cases where the FCAA failed to schedule, the GA successfully scheduled 72 cases, the QGA 43 cases, the A2C 61 cases, the ZOA 40 cases, the SLD-PSO 34 cases, and the GO 73 cases.

The FCAA had an average runtime of 0.74 s, lower than that of the GA, the QGA, and the ZOA, but higher than that of the two new heuristic algorithms with fast convergence (SLD-PSO and GO). The A2C maintained its runtime at the millisecond level throughout, showing an absolute advantage in speed.

The benefit and runtime data were standardized separately, and the means, standard deviations, and 95% confidence intervals (t-distribution) were calculated to conduct an in-depth comparison of the algorithms’ performance. The statistical results of the small-scale multi-task resource scheduling simulation are shown in

Table 10. Statistical results of small-scale multi-task resource scheduling simulation.

Algorithm	Standardized Benefit Data			Normalized Time Data
	Mean	Std. Dev.	95% CI	Mean	Std. Dev.	95% CI
FCAA	1.03	0.23	[1.01, 1.04]	10.44	9.96	[9.82, 11.06]
GA	−0.13	0.66	[−0.18, −0.09]	22.6	23.81	[21.12, 24.07]
QGA	−0.29	0.62	[−0.33, −0.25]	26.27	22.99	[24.85, 27.7]
A2C	0.26	0.84	[−0.31, −0.20]	1.01	0.12	[1.01, 1.03]
ZOA	−0.88	0.6	[−0.91, −0.84]	45.89	50.4	[42.76, 49.01]
SLD-PSO	−0.96	0.64	[−1.00, −0.93]	8.18	6.75	[7.76, 8.6]
GO	−0.44	0.59	[−0.48, −0.4]	9.63	16.79	[8.59, 10.67]

.

Based on the statistical results of the standardized benefit data and the normalized time data in the table, the analysis of performance differences between the FCAA and the comparative algorithms (GA, QGA, A2C, ZOA, SLD-PSO, and GO) was as follows:

In terms of standardized benefits, the FCAA achieved the best performance: it had a mean value of 1.03, making it one of only two algorithms with positive benefits among all comparative algorithms (the other being the A2C with 0.26), and its mean value was significantly higher than that of all comparative algorithms. Regarding stability, the FCAA had a standard deviation of 0.23, which was much lower than that of the A2C (0.84) and other algorithms (e.g., GA: 0.66, QGA: 0.62); its 95% confidence interval [1.01, 1.04] was the narrowest among all algorithms, indicating that the benefit output of the FCAA exhibited extremely high stability and reliability, with highly controllable benefit fluctuations.

In terms of time cost, although the FCAA’s overall performance did not reach the optimal level, it still fell within a relatively favorable range and exhibited good stability: it had a mean value of 10.44, significantly outperforming the GA, QGA, and ZOA, slightly exceeding that of the GO and SLD-PSO, but lower than that of the A2C. Regarding stability, it had a standard deviation of 9.96 and a 95% confidence interval [9.82, 11.06], which (i.e., its standard deviation) was only higher than that of the A2C and SLD-PSO yet smaller than that of the other comparative algorithms.

Overall, the FCAA demonstrated an overwhelming advantage in terms of the mean benefit and stability. Although its time overhead was slightly inferior to that of the A2C and SLD-PSO, it outperformed most comparative algorithms and achieved the optimal comprehensive performance. It could provide a relatively reliable timeliness guarantee for task execution while ensuring high benefit performance.

4.3. Multi-Task Resource Scheduling

In the multi-task resource scheduling simulation, 3–8 tasks were randomly selected from the task pool to form a task set in each run, and 30–120 resources were randomly drawn from the resource pool to form a resource set. For each task set, each algorithm was used to select resource groups capable of completing the tasks and match them to form a simulation case. Five algorithms were employed in this round of experiments, each generating a specific number of simulation cases, totaling 200 cases. All cases included 2270 tasks and 36,888 resources, with each case containing an average of 11–12 tasks and 184–185 resources. The key information is shown in

Table 11. Simulation case information of multi-task resource scheduling.

Total Number of Simulation Cases	Average Number of Tasks per Case	Average Number of Resources per Case
200	11–12	184–185

.

Due to the increased scheduling complexity, the hyperparameters of some baseline algorithms were modified. The core hyperparameter settings of these adjusted algorithms are presented in

Table 12. Hyperparameter adjustments of baseline algorithms.

Algorithm	Core Parameter Category	Parameter Configuration
GA	Population Size	max(resource_count, 100)
	Number of Generations	max(resource_count, 60)
QGA	Population Size	max(resource_count, 100)
	Number of Generations	max(resource_count, 60)
SLD-PSO	Population Size	max(resource_count × 0.4, 80)
	Number of Generations	max(resource_count, 150)
GO	Population_Size	max(resource_count × 1.2, 150)
	Maximum Function Evaluations	max(resource_count2, 8000)

.

Each algorithm was sequentially executed to process the cases. The A2C model was unable to handle this type of resource scheduling task, and the ZOA exhibited poor performance in terms of both scheduling success rate and runtime during small-scale multi-task resource scheduling; thus, neither was included in the comparison. The relevant simulation results, presented in Figure 7 and Figure 8 and

Table 13. Results of multi-task resource scheduling simulation.

Algorithm	Case Scheduling Success Rate	Task Completion Rate	Average Benefit	Proportion of Maximum Benefit	Average Runtime (t/s)
FCAA	98.0%	99.2%	272.4	93%	33.15
GA	21.0%	80.75%	199.0	0.5%	256.82
QGA	4.5%	58.94%	131.4	4%	258.07
SLD-PSO	5.5%	59.38%	117.7	1%	39.18
GO	6.0%	61.32%	123.5	1.5%	7.45

are as follows.

The FCAA achieved a remarkably high scheduling success rate of 98%, which was primarily attributable to the inherent limitations of the four comparative algorithms in solving large-scale scheduling problems. The 200 simulation cases employed in this experiment were generated by the five algorithms. The four comparative algorithms’ performance was weaker and highly stochastic in solving such large-scale scheduling problems, which not only resulted in the generation of simulation cases with relatively low scheduling difficulty—cases that the FCAA could handle successfully in most instances, but also prevented them from reliably completing the very cases they generated.

The FCAA achieved an average case scheduling benefit of 272.4, with both the case scheduling success rate and task completion rate significantly exceeding those of the comparative algorithms. The proportion of cases in which the FCAA achieved the maximum benefit reached 93%. In the two cases in which the FCAA’s scheduling failed, none of the comparative algorithms successfully completed the tasks.

The FCAA had an average runtime of 33.15 s, lower than that of the GA, QGA, and SLD-PSO, though higher than that of the GO. Due to the fast convergence property of the GO, even when the number of optimization iterations was increased tenfold, the improvements in the average benefit and the scheduling success rate remained below 10%. Compared with the FCAA, all comparative algorithms exhibited lower case scheduling success rates in complex scheduling scenarios, with a significant number of cases resulting in partial task scheduling failures.

The benefit and runtime data were standardized separately, and the means, standard deviations, and 95% confidence intervals (t-distribution) were calculated to conduct an in-depth comparison of the algorithms’ performance. The statistical results of the multi-task resource scheduling simulation are shown in

Table 14. Statistical results of multi-task resource scheduling simulation.

Algorithm	Standardized Benefit Data			Normalized Time Data
	Mean	Std. Dev.	95% CI	Mean	Std. Dev.	95% CI
FCAA	1.29	0.45	[1.27, 1.32]	5.65	9.37	[5.07, 6.23]
GA	0.27	0.64	[0.23, 0.31]	50.96	103.85	[44.51, 57.4]
QGA	−0.33	0.6	[−0.37, −0.29]	38.9	45.4	[36.08, 41.72]
SLD-PSO	−0.65	0.44	[−0.68, −0.62]	5.69	4.33	[5.42, 5.96]
GO	−0.58	0.47	[−0.61, −0.55]	1.23	0.78	[1.18, 1.27]

.

Based on the statistical results of the standardized benefit data and the normalized time data in the table, the analysis of the performance differences between the FCAA and the comparative algorithms (GA, QGA, SLD-PSO, and GO) was as follows:

In terms of standardized benefit, the FCAA achieved the overall optimal performance. Its mean standardized benefit was 1.29, which exhibited an absolute advantage and was significantly higher than that of the other algorithms: the GA had a mean value of 0.27, accounting for only 20.9% of that of the FCAA; the QGA, SLD-PSO, and GO all had negative mean values, indicating that these algorithms failed to reach the average benefit level. In contrast, the FCAA could stably generate positive and efficient benefit outputs. Regarding stability, the FCAA had a standard deviation of 0.45. Although slightly higher than that of the SLD-PSO, it was lower than those of the GA and QGA, and essentially equivalent to that of the GO. Its 95% confidence interval was [1.27, 1.32], with an interval width of only 0.05—the narrowest among all algorithms. This indicated that the benefit results of the FCAA were highly reliable, with extremely small benefit fluctuations across multiple runs, and could provide stable and reliable benefit guarantees for practical applications.

In terms of time cost, the FCAA fell within a relatively optimal range: its mean time cost was 5.65, which significantly outperformed the GA and QGA, while being essentially equivalent to that of the SLD-PSO and much higher than that of the GO. Regarding stability, the FCAA had a standard deviation of 9.37, with a 95% confidence interval of [5.07, 6.23] and an interval width of 1.16—demonstrating much better stability than that of the GA and QGA but inferior to that of the SLD-PSO and GO.

Overall, the FCAA achieved a low and stable time cost while ensuring an extremely high mean benefit and strong stability. In terms of scheduling benefit, the FCAA attained the highest positive mean value and exhibited the strongest stability. In terms of time cost, although the FCAA was inferior to the SLD-PSO and GO, their scheduling benefits were far lower than those of the FCAA and below the average level, rendering them unable to meet practical scheduling needs.

5. Conclusions

This paper presents a flexible combinatorial auction algorithm that integrates a bidding mechanism for simultaneous ascending auctions and establishes a candidate solution generation mechanism based on traditional auction algorithms. The algorithm is designed to address the resource scheduling problem of coordinating multiple groups of heterogeneous resources to collaboratively accomplish multiple tasks with the same priority. Under the defined scenario, the FCAA was compared with mainstream algorithms tailored for such problems, including heuristic algorithms and reinforcement learning algorithms. The main conclusions are as follows:

(i)

The FCAA achieves higher solution quality and time efficiency when solving simple scheduling problems of this type. In simulations of coordinating resources to complete small-scale scheduling tasks, all heuristic algorithms and reinforcement learning models could successfully handle over 60% of the small-scale task cases, but the FCAA consistently yielded the highest benefit solutions in most cases.

(ii)

The FCAA significantly outperforms the compared algorithms in solving complex multi-task scheduling problems. It demonstrates a superior scheduling benefit, a higher scheduling success rate, and greater solution stability.

(iii)

The optimization mechanism of the FCAA is better aligned with real-world resource scheduling constraints. By leveraging its candidate solution generation mechanism, the FCAA enables flexible adjustment of solution values and seamless incorporation of practical experience through whitelists and blacklists. This enhances the practical applicability of its solutions, particularly in human–machine collaborative task environments.

The FCAA has certain limitations. The algorithm’s optimization logic prioritizes high-benefit solutions from the optimal set, which boosts time efficiency but causes unavoidable resource scheduling conflicts in failed outcomes, making these solutions unfit for direct execution. In contrast, the heuristic algorithms optimize resource scheduling under the constraint of no scheduling conflicts, thereby ensuring their output solutions can be directly executed and used to complete at least part of the tasks. Therefore, one of the key directions for future improvements is addressing the resource scheduling conflicts in the FCAA’s failed solutions to maximize task completion rate when full task fulfillment is not feasible. Additionally, the FCAA’s runtime is significantly higher than that of the reinforcement learning algorithms, and there is a high degree of complementarity between the FCAA’s failed solutions and the A2C’s successful solutions. A potential optimization approach is to train neural network models based on the data generated by the FCAA, and then to employ transfer learning for further refinement, thereby leveraging the strengths of both algorithms.

Additionally, this study is primarily based on simulation experiments and has not yet been validated through physical flight tests in real-world environments. The FCAA’s performance and applicability in real-world UAV operations depend on a centralized scheduler with global information, making it susceptible to practical constraints: communication delays, packet loss during data transmission, environmental uncertainties, and hardware limitations. To simplify model construction, the simulations in this study have not incorporated the impact of UAV endurance capacity on task execution. Future research can supplement this critical factor by adding a UAV flight time (t_j) constraint in Equations (2) and (8).

Moreover, the FCAA’s architectural limitations prevent it from dynamically accommodating new tasks during scheduling computations, and when handling complex tasks, its average scheduling time reaches approximately 30 s. Given that the scheduling process itself consumes non-negligible time and the algorithm cannot adapt to mid-scheduling task additions, the FCAA is better suited to scenarios where the minimum execution time of a single task exceeds 180 s—ensuring the 30-s scheduling overhead is proportionally insignificant and avoiding disruptions from unforeseeable new task insertions. Future research will optimize the model and the algorithm to address the aforementioned limitations. We will also conduct physical flight and scheduling tests using heterogeneous UAV platforms with varied mission payloads and flight speeds. These tests aim to verify the algorithm’s robustness and scalability under realistic conditions. Furthermore, a comparative analysis will be performed between simulation-based scheduling experiments and physical flight experiments based on the key factors, including task benefits and completion time. This analysis aims to validate the fidelity of the simulation results, ultimately bridging the gap between theoretical models and practical applications.