TGN-MCDS: A Temporal Graph Network-Based Algorithm for Cluster-Head Optimization in Large-Scale FANETs

Abstract

With the growing deployment of Flying Ad hoc Networks (FANETs) in military and civilian applications, constructing a stable and efficient communication backbone has become a critical challenge. This paper tackles the Cluster Head (CH) optimization problem in large-scale and highly dynamic FANETs by formulating it as a Minimum Connected Dominating Set (MCDS) problem. However, since MCDS is NP-complete on general graphs, existing heuristic and exact algorithms suffer from limited coverage, poor connectivity, and high computational cost. To address these issues, we propose TGN-MCDS, a novel algorithm built upon the Temporal Graph Network (TGN) architecture, which leverages graph neural networks for cluster head selection and efficiently learns time-varying network topologies. The algorithm adopts a multi-objective loss function incorporating coverage, connectivity, size control, centrality, edge penalty, temporal smoothness, and information entropy to guide model training. Simulation results demonstrate that TGN-MCDS rapidly achieves near-optimal CH sets with full node coverage and strong connectivity. Compared with Greedy, Integer Linear Programming (ILP), and Branch-and-Bound (BnB) methods, TGN-MCDS produces fewer and more stable CHs, significantly improving cluster stability while maintaining high computational efficiency for real-time operations in large-scale FANETs.

1. Introduction

1.1. Challenges in Managing Flying Ad Hoc Networks

Unmanned aerial vehicle (UAV) technology has advanced rapidly in recent years. Operations have evolved from single-drone missions to large-scale cooperative swarms [1]. This evolution has given rise to Flying Ad Hoc Networks (FANETs), which enable real-time coordination and data exchange among UAVs. FANETs are now used in disaster response, environmental monitoring, precision agriculture, border patrol, and temporary communication support [2]. Unlike Mobile Ad Hoc Networks (MANETs) and Vehicular Ad Hoc Networks (VANETs), FANETs exhibit high three-dimensional mobility with six degrees of freedom. Such movement causes frequent and unpredictable topology changes [3]. Most FANETs lack fixed infrastructure and rely on self-organization among nodes. Each UAV also operates under strict limits of energy, computation, and communication range [4]. These characteristics make FANET management highly dynamic and technically challenging.

In large UAV swarms, maintaining a stable and efficient communication backbone is vital for coordinated operation. Cluster-based architectures are widely adopted to organize the network and reduce complexity. They divide the swarm into smaller clusters to improve scalability, energy efficiency, and fault tolerance [5]. Within each cluster, a Cluster Head (CH) manages local nodes, aggregates data, and communicates with other clusters. The CHs and their links form the backbone of the network. The selection of CHs is therefore crucial to system performance. An optimal CH set should provide full coverage, strong connectivity, and minimal control overhead. Achieving this balance under fast-changing topologies remains a difficult multi-objective problem and a core challenge in large-scale FANET management [6,7].

1.2. Cluster Head Optimization as a Minimum Connected Dominating Set Problem

The CH selection task in FANETs can be formally modeled as a Minimum Connected Dominating Set (MCDS) problem in graph theory. This formulation captures three essential properties of an optimal CH set: dominance, connectivity, and minimality.

Dominance ensures that every ordinary node is managed or covered by at least one cluster head. Connectivity guarantees that all CHs form a single connected subgraph, supporting global communication across the network. Minimality requires selecting the smallest possible set of CHs while maintaining full coverage and connectivity, which reduces overhead and energy consumption.

However, the MCDS problem [8,9] is NP-hard on general graphs. Exact algorithms are impractical for large and dynamic networks. Traditional heuristic methods, such as greedy algorithms, can find near-optimal solutions in static topologies but fail to adapt to fast-changing structures. In FANETs, a topology that is optimal at one time step can quickly become inefficient or even disconnected due to UAV mobility. To maintain a valid backbone, frequent recomputation of the MCDS is required, leading to heavy computation and control overhead. This instability also causes frequent CH switching, which degrades network performance and reliability.

In addition to heuristic and exact baselines, we further investigated the application of RL/DRL-based decision-making in large-scale FANETs. Existing surveys note that conventional RL is typically suitable for small-scale FANETs, whereas large-scale settings may suffer from enlarged state/action spaces, slow convergence, and the curse of dimensionality; DRL methods also face non-trivial computational complexity and deployment challenges on resource/energy-constrained airborne nodes [10,11]. The study [12] demonstrates that the DRL method achieves average routing times of 20–30 ms and 40–60 ms for 100/300 nodes, respectively. This is difficult to apply to high dynamic flight ad hoc networks.

Therefore, the real challenge in FANETs is not only to find an optimal MCDS at a single moment but to maintain a high-quality and stable MCDS over time. This shifts the problem from static optimization to a dynamic and predictive control task, where adaptability and temporal consistency are crucial for effective network management.

1.3. A Learning-Based Paradigm: Temporal Graph Networks

Traditional algorithms for cluster head selection are static and short-sighted. They optimize each network snapshot independently and ignore temporal evolution. Such methods perform poorly when topologies change rapidly.

To overcome this limitation, we introduce a learning-based approach using Temporal Graph Networks (TGNs) [13]. TGNs are designed for dynamic graphs and can capture spatiotemporal dependencies through memory and temporal encoding. By learning how the topology evolves, TGNs produce predictive node representations that support adaptive and stable cluster head selection. This paradigm shifts the problem from static optimization to dynamic learning, enabling proactive decision-making in large-scale FANETs.

1.4. Contributions and Paper Organization

The main contributions of this work are summarized as follows.

• TGN-MCDS Framework.

We propose a Temporal Graph Network-based framework, named TGN-MCDS, for solving the MCDS-based cluster head selection problem in dynamic FANETs. The model integrates a memory mechanism and temporal encoding to learn time-varying network structures in an end-to-end manner. The framework integrates a neighbor discovery module, memory module and time encoding to capture historical topology dynamics—an ability that is absent in many traditional dynamic GNN clustering models.

2.

Transform cluster head selection into an equivalent MCDS.

We formulate cluster head selection as the mathematical problem of solving the MCDS, and address it using the TGN-MCDS framework, achieving strong performance. To the best of our knowledge, existing dynamic graph learning methods have not yet been applied to solve the MCDS/cluster head selection problem in large-scale FANETs.

3.

Multi-objective Optimization.

We design a composite loss function that jointly optimizes coverage, connectivity, cluster size, centrality, edge penalty, temporal smoothness, and entropy regularization. This design enables the model to balance multiple objectives, improving both connectivity and stability.

4.

Efficient unsupervised training and inference.

The model employs an efficient unsupervised training process that leverages memory updates for temporal consistency. During inference, TGN-MCDS produces near-real-time CH predictions suitable for large-scale swarm applications.

5.

Performance Evaluation.

Extensive simulations show that TGN-MCDS outperforms classical greedy heuristics, integer linear programming (ILP), and branch-and-bound (BnB) algorithms in both solution quality and stability. The selected CHs are more centralized and less volatile, meeting the demands of dynamic UAV networks.

The rest of this paper is organized as follows.

Section 2 reviews related studies on MCDS optimization and graph neural networks for dynamic graphs. Section 3 presents the system model and problem formulation. Section 4 introduces the proposed TGN-MCDS algorithm in detail. Section 5 discusses the experimental setup and simulation results. Finally, Section 6 concludes the paper and outlines future research directions.

2. Related Work

2.1. MCDS Optimization and Cluster Head Selection

The Minimum Connected Dominating Set (MCDS) problem is a classical combinatorial optimization problem in graph theory, widely applied to CH selection in wireless ad hoc networks. A connected dominating set provides a virtual backbone that ensures efficient coverage and connectivity among nodes. Guha and Khuller established the computational complexity of the MCDS problem and proposed approximation algorithms with theoretical guarantees [14]. In practical networks, research has focused on distributed heuristic algorithms that construct small connected dominating sets with limited overhead. Wu and Li developed a distributed marking-based algorithm [15], while Wan et al. presented the first message-optimal distributed algorithm that significantly reduces communication costs during CH election [16]. Subsequent studies introduced weighted strategies based on residual energy, node degree, or mobility to enhance CH stability and network lifetime. However, these methods depend on manually designed rules, which restrict adaptability and global optimality in large-scale, dynamic scenarios.

For exact MCDS computation, approaches such as ILP and BnB have been explored. The MCDS can be formulated as a 0–1 integer programming problem and solved using commercial optimization tools; however, the exponential growth of variables limits scalability to small networks. The BnB algorithm improves efficiency through branch pruning based on upper and lower bounds, but its worst-case time complexity remains exponential [17,18]. Although optimized search-based methods have been proposed, they still fail to satisfy real-time requirements in large-scale FANETs. Consequently, practical backbone construction typically relies on heuristic or distributed approximations rather than exact optimization.

2.2. Graph Neural Networks and Dynamic Graph Models

With the rise in deep learning, Graph Neural Networks (GNNs) have emerged as powerful models for learning over graph-structured data [19]. GNNs iteratively aggregate neighborhood information to learn node and graph representations that capture both local and global dependencies [20]. Representative variants such as Graph Convolutional Networks (GCNs), GraphSAGE, and Graph Attention Networks (GATs) have achieved remarkable success in applications ranging from social network analysis to communication network optimization [21]. However, these models are designed for static graphs, assuming that node attributes and topologies remain unchanged over time. This assumption limits their applicability to dynamic systems such as UAV networks, where node mobility causes continuous topological variation [22].

To address temporal dynamics, researchers have developed a range of dynamic graph learning frameworks. Early works discretized time into snapshots and applied sequence models such as Recurrent Neural Networks (RNNs) or Long Short-Term Memory (LSTM) networks. Although effective in certain cases, snapshot-based models cannot capture asynchronous or continuous-time events. More recent research directly models continuous-time dynamic graphs (CTDGs), represented by frameworks such as Temporal Graph Attention Networks (TGAT) and Temporal Graph Networks (TGN). TGAT introduces time encoding into the attention mechanism, enabling the learning of time-aware embeddings [23]. Building on this foundation, Rossi et al. proposed the TGN framework, which incorporates node memory modules and flexible message-passing functions to record and update historical states [24,25,26]. TGN updates node memories upon topological events and applies temporal encoding to capture inter-event dependencies [27]. Through the integration of memory and graph operators, TGN achieves superior accuracy and computational efficiency in dynamic representation learning [28,29], outperforming TGAT in tasks such as dynamic link prediction and node classification. This capacity to model continuous and asynchronous structural evolution makes TGN particularly suitable for highly dynamic FANET environments.

Recent research has also applied GNNs to network optimization problems, revealing their potential to learn heuristic strategies for NP-hard graph tasks such as the Maximum Independent Set and Traveling Salesman Problem [30]. These findings indicate that deep learning models can learn efficient combinatorial optimization heuristics directly from data, often outperforming handcrafted methods. Motivated by this paradigm, it becomes natural to explore whether GNNs—particularly temporal variants like TGN—can approximate optimal MCDS-based cluster head selection strategies in dynamic FANETs. By training on diverse and continuously evolving network data, such models can capture implicit spatiotemporal patterns of cluster formation. This paves the way for adaptive, data-driven backbone optimization in large-scale UAV swarms.

3. System Model and Problem Formulation

3.1. Network Model

A large-scale FANET can be formally modeled as a temporal graph, which represents the dynamic evolution of the UAV swarm topology over discrete time steps. The temporal graph is denoted as $G=\left\{G_1,G_2,\dots ,G_T\right\}$, T represents the total number of discrete time steps. At any time step $t$, the network snapshot $G_t$ is defined as follows:

• $V = \left\{v_1{,v}_2{,\dots ,v}_n\right\}$ denotes the fixed set of UAV nodes in the network, where $n$ is the total number of UAVs.
• $E_t$ denotes the set of bidirectional communication links at time $t$. An edge $\left(v_{i }{,v}_j\right) \mathsf{\in }{ E}_t$ exists if and only if the Euclidean distance between UAVs $v_i$ and $v_j$ does not exceed the predefined communication radius R, that is, $distance\left(v_i,v_j\right)\le R$.
• Each node $v_i$ at time t is associated with a feature vector $x_v(t)$, which contains dynamic state attributes such as residual energy ratio, three-dimensional position ${(\mathit{pos}}_x{,\mathit{pos}}_y{,\mathit{pos}}_z)$ and velocity vector ${(\mathit{vel}}_x{,\mathit{vel}}_y{,\mathit{vel}}_z)$.

This temporal-graph representation effectively captures the essential characteristics of FANETs: while the node set V remains relatively stable, both the inter-node connectivity $E_t$ and the node states evolve dynamically over time due to UAV mobility and environmental changes.

3.2. Problem Definition: MCDS in FANETs

Based on the above network model, the MCDS problem can be defined on each snapshot $G_t{ = (V,E}_t)$. A subset $S \subseteq V$ is a connected dominating set (CDS) of $G_t$ if it satisfies the following conditions:

• Dominating condition:

$$\mathsf{\forall }u \mathsf{\in } V\backslash S, \mathsf{\exists }v \mathsf{\in } S, (u,v) \mathsf{\in } E_t.$$

(1)

This ensures that every non-backbone node $\left(V\backslash S\right)$ is adjacent to at least one backbone node (S), thereby guaranteeing full network coverage.

2.

Connectivity condition:

The subgraph induced by all nodes in $S$ and the edges among them in $G_{t }$, denoted by $G_t\left[S\right]$, is connected. This ensures that the backbone forms an integrated and connected structure capable of supporting global information exchange across the network.

3.

Minimization objective:

Among all sets satisfying the above conditions, the optimal set $S_t^{*}$ has the smallest cardinality:

$$S_t^{*} = \mathit{arg}\underset{S\mathsf{\subset }V}{\mathit{min}}\left|S\right|, s.t.{ S \mathit{is} a \mathit{CDS} \mathit{of} G}_t.$$

(2)

In other words, the MCDS problem seeks to minimize the number of selected nodes while maintaining both coverage and connectivity.

3.3. Equivalence to Cluster Head Optimization

The CH selection problem in FANETs can be strictly mapped to the MCDS problem. At any given time t, the optimal cluster head set ${\mathrm{CH}}_t$ must constitute a minimum CDS of the network graph $G_t$. This equivalence is intuitive and theoretically grounded because it reflects the three fundamental requirements of an ideal CH configuration:

• Dominating property: Each non-CH node must have a direct communication link to at least one CH node, ensuring complete network coverage and accessibility.
• Connectivity property: All selected CH nodes must form a connected subgraph, guaranteeing backbone integrity and enabling inter-cluster communication.
• Minimality objective: The number of CH nodes should be minimized while satisfying the above two properties. This reduces routing overhead, control signaling, and energy consumption while improving management efficiency.

However, solving the MCDS independently at each time step t is a short-sighted approach that neglects temporal stability. Due to frequent topology changes, CH sets optimized at consecutive time steps may differ significantly, resulting in high switching frequency and increased control cost. To address this issue, a more realistic dynamic objective should minimize not only the instantaneous backbone size but also the variation between consecutive time steps. This can be expressed as a weighted optimization problem:

$$\mathit{min}\left[\mathit{\alpha }\cdot {|\mathit{CH}}_t|+(1 - \mathit{\alpha })\cdot {\displaystyle \frac{{\left|\right(\mathit{CH}}_t{\backslash \mathit{CH}}_{t-1}) \cup { (\mathit{CH}}_{t-1}{\backslash \mathit{CH}}_t\left)\right|}{{|\mathit{CH}}_t \cup { \mathit{CH}}_{t-1}|}}\right].$$

(3)

The first term aims to achieve instantaneous optimality (i.e., minimal size), while the second term focuses on ensuring temporal stability. $\alpha$ is a weighting factor balancing compactness and stability. Traditional algorithms cannot directly optimize such time-dependent objectives. This limitation motivates the adoption of TGNs, whose memory and temporal encoding mechanisms enable the model to learn implicit dynamic decision strategies influenced by historical states. When selecting CHs, a TGN does not only evaluate each node’s current domination capability but also its temporal stability potential. For instance, a node that remains central in the network topology across multiple time steps may be assigned a higher CH probability, even if its instantaneous coverage is slightly lower. Through this mechanism, TGNs can approximate the above dynamic composite objective, achieving a balance between instantaneous optimality and long-term stability. This leads to an adaptive and temporally consistent CH selection strategy suitable for large-scale and highly dynamic FANET environments.

4. TGN-MCDS: A Temporal Graph Network Approach for MCDS Optimization

To solve the MCDS problem in dynamic FANETs, we propose TGN-MCDS, an end-to-end learning framework. The framework employs temporal graph neural networks to capture spatiotemporal patterns. Each node receives a probability score indicating its likelihood of being part of the MCDS. A lightweight decoder then constructs the final backbone solution from these probabilities through an efficient decoding process.

4.1. Architecture Overview

The TGN-MCDS framework consists of two main components: a TGN encoder and an MCDS decoder. The encoder receives a temporal graph stream ${{\left\{\right(G}_t{,X}_t\left)\right\}}_{t=1}^T$ as input T represents the total number of discrete time steps. At each time step $t$, it computes a high-dimensional embedding $h_v\left(t\right)$ for each node $v$. This embedding represents the node’s local topology, intrinsic attributes, and dynamic evolution across time.

The decoder takes the node embeddings ${{\{h}_v\left(t\right)\}}_{v\mathsf{\in }V}$ generated by the encoder and maps them to scalar probabilities $p_v\left(t\right)$ through a shallow multi-layer perceptron (MLP). These probabilities are then used by a probability-guided greedy algorithm to construct the MCDS solution. The entire framework is trained end-to-end with a composite loss function, allowing the model to learn the mapping from raw temporal graph data to high-quality MCDS solutions.

4.2. Temporal Graph Network Encoder

The encoder of TGN-MCDS is adapted from the original Temporal Graph Network and customized for dynamic FANETs. It includes four core modules: a memory module, a message generation and aggregation module, an embedding module, and a neighbor-finder module.

4.2.1. Memory Module

The memory module maintains a time-varying hidden state for each node, summarizing its interaction history. Similarly to recurrent network states, the memory updates whenever a topological change or neighbor event occurs and decays smoothly during inactivity. Initially, all memory vectors $s_i\left(\mathit{0}\right)$ are zero. At each step, the memory is updated by exponential smoothing:

$$s_i\left(t\right) = \mathsf{\beta }\hspace{0.17em}{s}_i^{\mathit{old}} + (1-\mathsf{\beta })\hspace{0.17em}{\mathit{tan}h( \overline{m}}_i\left(t\right)),$$

(4)

where $s_i\left(t\right)$ is the updated memory, ${\overline{m}}_i\left(t\right)$ is the aggregated message, and $\mathsf{\beta } \mathsf{\in }$ [0,1] controls memory retention. This mechanism preserves long-term dependencies while preventing outdated information from dominating. When a UAV node reappears after inactivity, its refreshed memory promptly reflects recent environmental changes, maintaining adaptive behavior.

4.2.2. Message Generation and Aggregation Module

This module defines how node interactions generate messages and how they are aggregated for memory updates. When node $i$ interacts with neighbor $j$ at time $t$ (when the distance between them becomes smaller than $R$), each node produces a message for itself and the neighbor. All adjacency relations within a discrete step are treated as concurrent events. The message from $j$ to $i$ is computed as:

$$m_{i\mathsf{\leftarrow }j}{\left(t\right)=x}_j{\left(t\right)W}_{\mathit{proj}},$$

(5)

where $x_j\left(t\right)$ is the neighbor feature of node i, and $W_{\mathit{proj}}\mathsf{\in }{R}^{D_{\mathit{in}}{+D}_t{\times D}_{\mathit{mem}}}$ is a fixed projection matrix (non-trainable parameters). Messages from all neighbors are aggregated using mean pooling:

$${\overline{m}}_{i\mathsf{\leftarrow }j}\left(t\right) = {\displaystyle \frac{1}{{|N}_i\left(t\right)|}}{{\displaystyle \sum }}_{j\mathsf{\in }{N}_i\left(t\right)}{m}_j\left(t\right),$$

(6)

where $N_i\left(t\right)$ denotes the neighbor set of node $i$.

The resulting ${\overline{m}}_i\left(t\right)$ can be regarded as the composite message arriving at node $i$. To improve efficiency, our implementation simplifies the original TGN design: the message function is replaced with an identity linear transformation on neighbor features, and the aggregator adopts a non-learnable mean function. This simplification maintains model performance while significantly reducing computational complexity, making it suitable for real-time FANET applications.

4.2.3. Embedding Module

The embedding module computes each node’s temporal representation from memory and neighborhood information. It outputs the probability that a node should become a CH. To mitigate memory staleness from long inactivity, embeddings incorporate temporal neighborhood aggregation. At time $t$, node $i$ builds an input vector ${x_i}^{\prime }\left(t\right)$ by concatenating three parts: its current feature vector $x_i\left(t\right)$, a time-encoding vector $e_t$, and updated memory after the previous batch node $s_i(t-1)$.

Formally, these are concatenated to form the input embedding:

$${x_i}^{\prime }\left(t\right) = \left[x_i\left(t\right){, e}_t{, s}_i\left(t-1\right)\right].$$

(7)

The model uses a two-layer neighbor-aggregation network to produce embeddings. On the first layer, neighbor inputs are averaged, linearly transformed, and passed through ReLU. This yields the intermediate representation $h_i^{\left(1\right)}\left(t\right)$. On the second layer, the same aggregation and transformation are applied to $h^{\left(1\right)}$. The second layer output is the final hidden representation $h_i^{\left(2\right)}\left(t\right)$.

Layer $\mathrm{l}$ is computed as:

$$h_i^{\left(l\right)}\left(t\right) = \mathsf{\sigma }\left({\displaystyle \frac{1}{\left|N_i\right|}}{{\displaystyle \sum }}_{j\mathsf{\in }{N}_i\left(t\right)}{h}_j^{\left(l-1\right)}\left(t\right)W^{\left(l\right)}{+b}^{\left(l\right)}\right), l=1,2,$$

(8)

where $h_i^{\left(0\right)}{\left(t\right)=x^{\prime }}_i\left(t\right)$ is the input feature vector, with $W^{\left(l\right)}$ and $b^{\left(l\right)}$ as the weight and bias at layer $l$, and $\mathsf{\sigma }$ as the ReLU activation function.

For a single-layer model, the above operation is performed once. After obtaining the final hidden representation $h_i\left(t\right)$ (i.e., $h_i^{\left(2\right)}\left(t\right)$ in a two-layer setup), a linear projection followed by a sigmoid activation converts it into the CH probability:

$$z_i\left(t\right){ = h}_i\left(t\right)W_{\mathit{out}}{ + b}_{\mathit{out}}, p_i\left(t\right) = \mathsf{\sigma }(z_i\left(t\right)).$$

(9)

This process effectively combines historical memory and the latest neighborhood information, providing an immediate estimate of each node’s suitability for CH selection.

In the original TGN framework, the embedding module often employs a graph attention mechanism that computes weighted aggregation based on neighbor memories, features, and time encodings. To reduce computational overhead, TGN-MCDS replaces attention with a mean-aggregation graph convolution. Despite this simplification, the inclusion of temporal memory ensures that recent neighbor dynamics are fully captured.

Consequently, the resulting embeddings remain both temporally adaptive and computationally efficient, making the model well-suited for large-scale dynamic FANETs.

4.2.4. Neighbor-Finder Module

The neighbor-finder module determines the set of neighboring nodes used in each graph convolution step. It extracts the spatiotemporal neighborhood of a target node from the dynamic graph sequence.

In the original TGN framework, this module efficiently retrieves historical interaction events from large temporal datasets, often relying on indexing or sampling strategies. In contrast, the neighbor relationships in a FANET are governed directly by spatial proximity. At time $t$, two UAV nodes are considered neighbors if their Euclidean distance is smaller than the communication range $R$. Based on this rule, a radius-based adjacency graph $G\left(t\right)$ is constructed at each time step using the UAV positions. From $G\left(t\right)$, the adjacency matrix $A\left(t\right)$ and neighbor list $N_i\left(t\right)$ are generated for all nodes. This approach provides a physics-driven implementation of the neighbor-finder: no random sampling or complex indexing is required—neighbor edges are determined solely by spatial distance thresholds.

Because UAV networks exhibit high mobility, the adjacency relations can change at every time step. Through the combination of the memory module and the neighbor-finder, the model simultaneously preserves the influence of past neighbors and incorporates the latest neighborhood information. This design enables TGN-MCDS to capture the impact of dynamic topological evolution on node representations in real time.

4.2.5. Working Mechanism

The interactions among all modules in the TGN-MCDS temporal graph encoder are illustrated in Figure 1.

By combining time encoding with memory units, the encoder enables effective information propagation across the dynamic topology of FANETs. The propagation mechanism operates on two complementary dimensions—temporal and topological. Along the temporal dimension, node memories accumulate and decay over time, allowing historical information to flow forward along the time axis. Whenever a node interacts with its neighbors or experiences a neighborhood change, new messages are generated to update its memory. These updated memories continuously influence subsequent embeddings, transmitting past information into future representations. Meanwhile, memories that are not refreshed gradually decay, ensuring that older events exert weaker influence as time progresses.

Along the topological dimension, the embedding module aggregates information from each node’s neighborhood, enabling state diffusion among connected nodes. For example, if a node remains inactive for an extended period but its neighbors are recently active, the aggregation process still allows the node to receive updated contextual information from its vicinity. This design ensures that information remains synchronized across the network even under highly dynamic topology changes. Through this dual propagation mechanism, TGN-MCDS maintains sensitivity to both temporal evolution and structural variation. As a result, the model can balance historical stability with real-time adaptability, producing accurate and robust predictions for CH selection in dynamic FANET environments.

4.3. MCDS Decoder and Solution Construction

After obtaining each node’s embedding $h_i\left(t\right)$ from the encoder, the decoding process proceeds in two stages.

4.3.1. Probability Prediction

Each embedding $h_i\left(t\right)$ is passed through a shallow multi-layer perceptron (MLP). The final layer applies a Sigmoid activation to produce a probability $p_i\left(t\right)$, representing the confidence that node $i$ belongs to the optimal MCDS at time $t$.

4.3.2. Greedy Decoding Strategy

Selecting all nodes with probabilities above a fixed threshold does not necessarily yield a valid MCDS, as it may violate dominance, connectivity, or minimality. To address this, we design a probability-guided greedy decoding algorithm, inspired by classical greedy heuristics but driven by the learned probabilities.

• Initialization:

Initialize the solution set $S = \mathsf{\varnothing }$ and mark all nodes as uncovered (white).

2.

Dominating Set Construction:

While uncovered (white) nodes remain in the network, the algorithm iteratively expands the dominating set as follows. From all nodes not included in $S$, select the node $v^{*}$ that maximizes a utility function balancing its selection probability and its ability to cover new nodes:

$${\mathit{utility}\left(v\right) = p}_v\left(t\right) \times \mid \mathit{number} \mathit{of} \mathit{white} \mathit{neighbors} \mathit{of} v\mid .$$

(10)

Add the selected node $v^{*}$ to the solution set $S$, and mark $v^{*}$ and all of its white neighbors as covered (gray).

3.

Connectivity Enforcement:

After the previous steps, the set $S$ forms a dominating set but may consist of several disconnected components. To ensure full connectivity, the algorithm identifies all connected components within $G_t\left[S\right]$, where $G_t\left[S\right]$ denotes the subgraph induced by node set $S$ in the current network snapshot $G_t$. If multiple components are detected, the algorithm iteratively selects bridge nodes from outside $S$ to connect them. Candidate bridge nodes are chosen based on two criteria:

• A high predicted probability $p_v\left(t\right)$
• Their position along shortest paths linking distinct components.

Each selected node is added to $S$ until $G_t\left[S\right]$ becomes a single connected subgraph. This process guarantees that the final solution satisfies both the domination and connectivity conditions required by the MCDS formulation.

4.4. Model Training, Loss Function, and Supervision Design

4.4.1. Training Procedure

The TGN-MCDS model is trained end-to-end in a self-supervised manner using simulated FANET dynamics. Each training epoch simulates the network evolution over $T$ discrete time steps, during which the model continuously observes the changing topology and learns to output the CH probability $p_i\left(t\right)$ for every node. At the start of each epoch, all node memories are reset to zero, and the initial node positions and velocities are randomly generated. At every time step, the previous network graph $G(t-1)$ is first constructed from the last batch of node positions, and the message generation and aggregation modules are applied to compute aggregated neighbor information. This information is then used to update the memory state $s_i(t-1)$, which stores historical interaction patterns. Next, the current graph $G\left(t\right)$ is built based on updated positions, and each node’s normalized degree and other topological features are calculated to form $x_i(t)$. A temporal encoding $e_t$ is concatenated with these features and combined with the previous memory to obtain the input $x_i^{\prime }\left(t\right)$. The model then performs graph convolution and outputs the CH probability $p_i\left(t\right)$. A composite loss $L\left(t\right)$ is computed according to the objectives defined in Section 4.4.2, and model parameters are updated through backpropagation using the Adam (Adaptive Moment Estimation) optimizer [31]. The process is executed sequentially without access to future topology, ensuring strict temporal causality. After sufficient epochs, the model parameters converge, enabling the learned network to predict CH probabilities that jointly satisfy domination, connectivity, and stability constraints under dynamic FANET topologies, see Figure 2.

4.4.2. Loss Function and Supervision Design

The training objective of TGN-MCDS is defined as a weighted combination of multiple proxy losses that jointly enforce coverage, connectivity, compactness, and temporal stability:

$$L = {\lambda }_c{L}_c+{\lambda }_n{L}_n+{\lambda }_s{L}_s+{\lambda }_{\mathit{temp}}{L}_{\mathit{temp}}+{\lambda }_{\mathit{cent}}{L}_{\mathit{cent}}+{\lambda }_{\mathit{edge}}{L}_{\mathit{edge}}+{\lambda }_{\mathit{ratio}}{L}_{\mathit{ratio}}+{\lambda }_{h}H$$

(11)

Since the CH optimization task lacks explicit supervision labels, these components serve as surrogate signals that guide the model toward learning valid MCDS under dynamic FANET topologies. Coverage and connectivity are treated as hard constraints with the highest weights, cluster size and temporal smoothness are moderately weighted for compactness and stability, and regularization terms are lightly weighted to support convergence.

• Coverage Loss ($L_c$)

This term ensures that every node is dominated by at least one CH. For each node, we define the coverage score $s_i={{\displaystyle \sum }}_{j\mathsf{\in }\left\{i\right\}\cup N_i}{p}_j$, representing the probability that the node or any of its neighbors acts as a CH. The loss penalizes insufficient coverage as

$$L_c={\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_{i=1}^N\mathit{max}(0.1-s_i),$$

(12)

encouraging the model to achieve full network domination.

2.

Connectivity Loss ($L_n$)

To maintain a connected backbone among CHs, we compute each node’s neighbor CH probability $r_i ={{\displaystyle \sum }}_{j\mathsf{\in }{N}_i}{p}_j$. The connectivity loss is

$$L_n={\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_{i=1}^N{p}_i\mathit{max}({0.1-r}_i),$$

(13)

which penalizes CHs that lack adjacent CHs, thus promoting topological coherence.

3.

Size Loss ($L_s$) and Ratio Constraint ($L_{\mathit{ratio}}$)

The size term

$$L_s={\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_i{p}_i,$$

(14)

controls the average CH ratio, while the ratio constraint

$$L_{\mathit{ratio}}=(\mathit{\mu }-r_t{)}^2,$$

(15)

forces it toward a target proportion ${\mathrm{r}}_{\mathrm{t}}$, which gradually decays from 0.30 to 0.15 during training. Together, these two terms ensure compact CH selection and stable convergence.

4.

Temporal Smoothness Loss ($L_{\mathit{temp}}$)

To enhance temporal consistency, the following loss penalizes sharp probability fluctuations between consecutive time steps:

$$L_{\mathit{temp}} = {\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_i{{(p}_i\left(t\right)-p_i(t-1\left)\right)}^2.$$

(16)

This stabilizes CH selection and mitigates frequent reconfiguration.

5.

Centrality and Edge Regularization

To prefer nodes in structurally advantageous positions, two regularization terms are introduced.

$$L_{\mathrm{cent}}=-{\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_i{p}_i{w}_i^{\left(\mathit{cent}\right)}{, L}_{\mathit{edge} }={\displaystyle \frac{1}{N}}{{\displaystyle \sum }}_i{p}_i{w}_i^{\left(\mathit{edge}\right)}.$$

(17)

The centrality reward $L_{\mathrm{cent}}$ encourages nodes with higher graph centrality, while the edge penalty $L_{\mathit{edge}}$ suppresses selections near network boundaries. Weighted by ${\lambda }_{\mathrm{cent}}$ and ${\lambda }_{\mathrm{edge}}$, these terms bias CH selection toward central, stable regions.

6.

Entropy Regularization ($H$)

Finally, entropy regularization prevents probability collapse and maintains diversity:

$$H = -{\displaystyle \frac{1}{N}}{\mathsf{\Sigma }}_i{[p}_i{\mathit{log} p}_i + (1-p_i)\mathit{log} (1-p_i\left)\right].$$

(18)

It encourages moderate uncertainty, helping the model explore diverse CH configurations during early training.

All model parameters—including GNN weights, temporal encoders, and memory modules—are optimized using the Adam optimizer. At the end of each epoch, the model is evaluated on randomly generated validation scenarios, measuring coverage rate, connectivity, CH ratio, and total loss. Over time, the losses converge smoothly, and the model learns to generate CH probabilities that satisfy both domination and connectivity constraints under dynamic network conditions. The trained model can then be deployed for online inference, outputting CH probabilities in real time and producing explicit CH sets through the decoding strategy described earlier.

5. Experimental Evaluation

This section presents the experimental evaluation of the proposed TGN-MCDS algorithm. We first describe the experimental setup and parameter configuration, followed by comparative analyses of training behavior, coverage and connectivity, CH set size, and computational efficiency. Visualization results are also provided to illustrate the algorithm’s dynamic behavior and overall performance trends.

5.1. Experimental Platform and Settings

All experiments were implemented on the MATLAB platform. The hardware environment consisted of an Intel i7 CPU and 32 GB RAM. The simulation was conducted using a three-dimensional mobile network model. We have carried out experiments based on the parameters of node speed, communication distance and coverage range of different network scales. Next, we will introduce the simulation results based on a set of typical experimental parameters, see

Table 1. Simulation Parameters.

Parameter	Value	Parameter	Value
Number of nodes N	300	$\mathrm{Maximum} \mathrm{hop} \mathrm{count} \mathrm{hop}$	2
Mobility model	Gaussian–Markov	$\mathrm{Communication} \mathrm{radius} R$ (m)	500
$\mathrm{Average} \mathrm{speed} \overline{v}$ (m/s)	100	Simulation area (m3)	$1000 \times 1000 \times 1000$
Propagation model	Nakagami	Simulation time T(s)	100

.

Each UAV was assigned a communication radius of R = 500 m. Two nodes were considered connected if their Euclidean distance was less than R, forming an undirected communication link. The network evolution was simulated for T = 100 discrete time steps, each corresponding to one second of real time. At every time step, the current network topology $G\left(t\right)$ was reconstructed based on node positions and then fed into the TGN-MCDS model for processing. This setup effectively samples the connectivity dynamics of a continuously evolving FANET at one-second intervals.

5.2. Model Configuration and Training Hyperparameters

The graph neural network component of TGN-MCDS consists of two layers. Each node input is represented by its degree feature, while both the hidden and embedding dimensions are set to 32. The network outputs the CH selection probability for each node. The memory vector dimension is also fixed at 32, consistent with the node embedding size. Temporal encoding is configurable but, in the current setup, no explicit time-frequency encoding is applied.

Training is conducted in a self-supervised manner using simulated network data. The composite loss function integrates multiple objectives with the following weighting coefficients: coverage ${\lambda }_c = 4.0$, connectivity ${\lambda }_n = 1.0$, size constraint ${\lambda }_s = 0.03$ (encouraging smaller $\mid S\mid$), and temporal smoothness ${\lambda }_{temp} = 0.5$. Two structural priors are also incorporated: centrality encouragement ${\lambda }_{\mathit{cent}} = 0.10$ and edge penalty ${\lambda }_{\mathit{edge}} = 0.12$. An entropy regularization term ${\lambda }_h = 0.01$ is added to enhance training stability. Model optimization is performed using the Adam optimizer with an initial learning rate of ${5 \times 10}^{-3}$. Training proceeds for 120 epochs, and every ten epochs the model is evaluated on a validation set to assess coverage rate and CH count, based on which model selection and hyperparameter adjustments are conducted.

5.3. Performance Evaluation

To comprehensively evaluate the proposed algorithm, we define several key performance metrics. These indicators not only measure the quality of combinatorial optimization but also directly reflect the operational efficiency of FANETs in real-world scenarios.

5.3.1. Training Convergence

Figure 3 and Figure 4 illustrate the loss convergence of the TGN-MCDS model and a baseline model without memory modules. The total loss of TGN-MCDS decreases rapidly during early training and stabilizes after approximately 30 epochs. Both the coverage and connectivity losses approach zero within the first few iterations, indicating that the model quickly learns to satisfy basic coverage and connectivity constraints. In later stages, optimization focuses on minimizing the size and entropy losses, refining the number of CHs and improving decision confidence.

As training progresses, the CH ratio gradually decreases from around 0.35 to the target value of approximately 0.15. Throughout the process, both the coverage rate and subgraph connectivity remain close to 1.0. The temporal smoothness loss stays low, suggesting that the CH probabilities evolve smoothly without abrupt oscillations. Compared with the non-memory baseline, TGN-MCDS converges faster and remains more stable. This result confirms that the memory mechanism effectively captures dynamic temporal patterns.

5.3.2. Coverage and Connectivity

We evaluate whether the CH sets selected by TGN-MCDS can fully cover all nodes and form a connected backbone across the test network sequences. As shown in Figure 3, TGN-MCDS consistently achieves nearly 100% node coverage and maintains complete connectivity at all time steps. In contrast, the Greedy heuristic occasionally exhibits coverage below 100% and fluctuating connectivity due to node mobility. The ILP and BnB algorithms, though effective for small-scale graphs, often fail to converge within the predefined time limit in larger networks.

Guided by the connectivity loss and supported by temporal memory effects, TGN-MCDS strictly ensures both coverage and backbone integrity. Figure 5 further visualizes the spatial distribution of selected CHs, including their proximity to network boundaries, degree distribution, and centrality characteristics.

5.3.3. CH Set Size

Figure 6 presents the variation in CH set size ∣S∣ across different time frames. Due to computational limits, ILP and BnB often fail to complete within the maximum allowed runtime. As a result, they are impractical as baselines for large-scale MCDS solutions. Among the four compared methods, TGN-MCDS consistently achieves the smallest CH sets, with only minor deviations at specific frames. This result highlights the model’s strong decision-making capability under complex dynamic topologies.

5.3.4. Cluster Stability

Cluster stability reflects backbone persistence and control overhead. It is evaluated by counting CH changes between consecutive frames and summing them over time. A higher score indicates fewer changes and lower communication cost. In experiments, Figure 7 shows that TGN-MCDS yields far fewer transitions than other algorithms, confirming its strong temporal robustness.

5.3.5. Runtime and Scalability

We further examine the runtime performance of all algorithms under different network sizes. The ILP method scales poorly: when $N > 50$, solving time exceeds one minute, and for $N > 80$, feasible solutions are rarely obtained within an hour. BnB also becomes computationally prohibitive when $N \approx 40$. In Figure 8, the latency of BnB and ILP remains nearly unchanged across frames, as the algorithm has reached its maximum runtime limit. The Greedy algorithm has a per-selection complexity of ${O(N}^2)$, yielding an average runtime of about 0.5 s for $N = 1000$—acceptable but insufficient for strict real-time demands.

In contrast, TGN-MCDS inference performs only two graph-convolution layers and lightweight memory updates, yielding a linear complexity of $O(\left|E\right|)$. In sparse networks, it achieves high efficiency, requiring only 0.01 s per step for N = 100 and 0.05 s for N = 1000. With GPU acceleration, the model can further scale to real-time operation in large-scale FANETs. This is well within the capacity of standard embedded processors.

5.3.6. Visualization and Analysis

Figure 9 and Figure 10 present a visual comparison of CH selection for a representative FANET topology. At $t = 20$, the network snapshot shows the node distribution, selected CHs, and backbone communication links. The ILP algorithm produces the largest number of CHs and requires the longest runtime, often reaching the time limit without convergence. Greedy and BnB perform better but still select several nodes near the network boundary. In contrast, TGN-MCDS generates the smallest yet fully connected CH set, covering all critical regions of the network. Most selected CHs are located near the topological center, while peripheral nodes are effectively covered by nearby central CHs rather than being selected themselves. This observation confirms that TGN-MCDS favors central nodes and suppresses redundant selections at the edge of the network.

Over continuous time steps, TGN-MCDS shows smooth transitions in CH evolution. Existing CHs remain active if they still occupy important positions in the updated topology. When a CH moves to an unfavorable region or a better candidate emerges, the model gradually reduces its selection probability and promotes another node. This progressive adjustment prevents abrupt, large-scale replacements and demonstrates high temporal stability. By contrast, the Greedy algorithm recomputes CHs independently at each frame, often causing rapid, unstable changes that appear as “flashing.” This difference highlights the advantages of incorporating temporal memory and smoothness constraints for consistent CH decision-making.

5.3.7. Ablation Experiment

Finally, we conducted a set of ablation studies to evaluate the specific contributions of individual components in the proposed algorithm. The model components are systematically categorized into temporal modules and structural modules, as detailed below.

Memory module: We evaluated a memory-free variant of TGN-MCDS, in which each time step is processed independently without maintaining any historical state. The results indicate a significant degradation in temporal performance: removing the memory module leads to a substantially higher CH switching frequency. In addition, the memory-free model exhibits slightly degraded coverage consistency. In some cases, due to the lack of temporal context for anticipating topology evolution, the coverage rate temporarily drops below 100%. Simultaneously, we observed that when the memory vector of a CH node remains stable across consecutive time steps, the node exhibits a strong tendency to persist within the CH set. Conversely, significant fluctuations in a node’s memory—indicative of substantial changes in its local environment—typically precipitate a transition in status, leading the node to either gain or lose its CH role. Indeed, we identified a strong positive correlation between the magnitude of a CH node’s memory update and the probability of it being replaced in the subsequent time step. This demonstrates that the memory module effectively captures temporal patterns to ‘hand over’ the cluster head role at appropriate moments.

Temporal smoothing loss: We further removed the temporal smoothing loss from the training objective. This variant still retains the memory module but no longer explicitly penalizes rapid temporal changes. We observe that, without the smoothing term, the model becomes noticeably less stable, exhibiting a higher CH switching frequency than the full TGN-MCDS. While coverage and connectivity remain high—as expected, since they are enforced by other loss terms—and the model converges to a similar average number of CHs, it achieves these objectives through substantially more oscillatory CH assignments. This confirms that the temporal smoothing loss is effective in suppressing unnecessary reconfigurations and plays a complementary role to the memory module.

Structural prior terms (centrality reward and edge penalty): We also evaluated a variant in which the structural prior terms are removed. Although the resulting model still satisfies coverage and connectivity constraints, we observe subtle yet consistent differences in CH selection. Specifically, without structural priors, the model tends to select UAVs near the topological boundary of the network as CHs, whereas the full model systematically avoids such selections. Consequently, to maintain full coverage, the prior-free variant requires on average approximately 10% more CHs, since boundary CHs cover fewer neighbors and are therefore less efficient. Due to this suboptimal CH placement, the network also exhibits slightly reduced overall efficiency. These results indicate that, although the centrality reward and edge penalty are not strictly necessary for feasibility, they effectively guide the model toward more efficient CH configurations and thus improve solution quality, see

Table 2. Ablation Study: Impact of Key Components on Network Performance.

Model Variant	Component Configuration			Performance Metrics
	Memory	Temp. Smooth	Struct. Prior	Switching Freq.	Coverage Rate	Avg. CH Count
w/o Memory	×	✓	✓	↑↑ (Severe)	<100% (Unstable)	--
w/o Smoothness	✓	×	✓	↑ (≈1.3×)	100%	≈Baseline
w/o Struct. Priors	✓	✓	×	Low	100%	↑ 10% (Inefficient)
TGN-MCDS (Ours)	✓	✓	✓	Lowest	100% (Stable)	Optimal

Note: “✓” and “×” denote the inclusion and exclusion of the component, respectively. ”↑” indicates an increase in the metric (negative impact for switching and count). “↑↑” denotes a significant degradation.

.

The simulation results clearly demonstrate the effectiveness and superiority of TGN-MCDS in solving the MCDS-based CH optimization problem. The proposed method achieves near-complete coverage with a minimal CH set, while maintaining high temporal stability and computational efficiency—capabilities rarely achieved together by traditional approaches. In large-scale and highly dynamic FANETs, TGN-MCDS provides a robust and efficient solution for enhancing self-organization and communication reliability across UAV networks.

6. Conclusions

6.1. Summary of Contributions

This paper presents TGN-MCDS, a Temporal Graph Network-based framework for solving the MCDS problem in large-scale FANETs. By incorporating time encoding and memory modules into a graph neural network, the proposed model learns adaptive CH selection strategies directly from dynamic topological data. A multi-objective loss function jointly optimizes coverage, connectivity, cluster size, centrality, and temporal smoothness, ensuring both structural efficiency and stability. Simulation results show that TGN-MCDS consistently outperforms classical heuristic and static approaches in coverage, connectivity robustness, CH reduction, and temporal consistency. These improvements make it a strong candidate for practical FANET scenarios such as autonomous coordination, military reconnaissance, and emergency communication.

6.2. Key Findings

Extensive experiments conducted in dynamic FANET environments confirm the effectiveness of the proposed framework. While learning-based models generally produce smaller dominating sets than heuristic methods, the true advantage of TGN-MCDS lies in its ability to capture and anticipate network dynamics. The integrated memory mechanism enables the model to retain long-term temporal information, enabling more stable and predictive CH decisions. Consequently, the resulting communication backbone is compact, persistent, and exhibits minimal reconfiguration over time. This stability leads to measurable performance gains, including prolonged network lifetime and improved data delivery reliability. Overall, the findings highlight an essential insight: optimization in dynamic networks must evolve from static, reactive designs to dynamic, predictive strategies that account for temporal behavior.

6.3. Future Work

This work demonstrates the potential of dynamic graph neural networks for optimizing highly mobile UAV systems. Future research can further enhance TGN-MCDS in several directions:

• Scalability.

Extend the model to very large UAV swarms with thousands of nodes. Promising approaches include graph sampling, hierarchical aggregation, and lightweight GNN architectures.

2.

Directed-topology modeling.

Adapt the framework to directed communication graphs to better capture link asymmetry in real-world FANET deployments.

3.

Onboard implementation.

Deploy trained TGN models on UAV platforms with limited resources, enabling distributed and real-time inference. Model compression methods such as pruning and quantization will be key to this effort.

4.

Cross-layer optimization.

Integrate backbone construction with routing protocols to create co-optimized, topology-aware communication strategies.

5.

Heterogeneous UAV networks.

Generalize the model to heterogeneous swarms where UAVs differ in communication range, energy capacity, and mobility patterns, enhancing its adaptability to practical missions.