1. Introduction
The Minimum Spanning Tree (MST) problem and the Bottleneck Spanning Tree (BST) problem are classical spanning tree problems in combinatorial optimization problems. Given a simple edge-weighted connected undirected graph , the sets V and E are the sets of vertices and edges, respectively, and is an edge-weight function that assigns a positive real number to each edge . The MST problem seeks a spanning tree such that the total edge weight is minimized, that is, , where denotes the set of all spanning trees. Conversely, the BST problem aims to find a spanning tree such that the maximum edge weight is minimized, that is, . Both problems optimize network structures, with MST minimizing overall cost and BST focusing on the worst-case edge in the network.
Interdiction and improvement are important optimization problems, where the objective is to minimally adjust edge weight parameters
c so that the resulting network performance under modified parameters
is either no less than or no greater than a given constant on graph
. Many scholars have conducted extensive research on these problems on MST and BST. Hsu et al. [
1] first formulated the problem of deleting
k edges to maximize the weight of MST on the resulting network and established fundamental theoretical foundations. Based on this, Iwano et al. [
2] developed more efficient algorithms for the single-edge case through graph traversal techniques. The theoretical complexity of the generalized problem was established by Frederickson and Solis-Oba [
3]. They proved that the problem is NP-hard for arbitrary
k. Shen [
4] subsequently enhanced this by developing more efficient approximation algorithms, while Liang [
5] focused on developing polynomial-time solutions for fixed small values of
k. Furthermore, Bazgan et al. [
6] proposed a new efficient algorithm and adapted it to establish an implicit enumeration algorithm based on a branch and bound procedure, which can handle significantly larger instances due to a better use of memory space. Most recently, Wei et al. [
7] proposed novel integer programming formulations for this problem, including a bilevel optimization framework and cutting-plane algorithms, which provided new optimization methods to disrupt network connectivity. For the interdiction problem on BST, Abdolahzadeh et al. [
8] designed polynomial-time algorithms for the problems under the weighted
norm and sum-type Hamming distance. On the improvement front, Frederickson et al. [
3] designed a polynomial-time algorithm with time complexity
for the improvement problem on MST under the weighted
norm, and Zenklusen [
9] proposed a constant-factor approximation algorithm. Additionally, under the sum-type Hamming distance, Frederickson and Solis-Oba [
3] proved the problem is NP-hard and developed an approximation algorithm.
In networks that demand both cost efficiency and robustness, such as in secure communication systems [
10], the Max+Sum Spanning Tree (MSST) problem arises as a natural generalization of both MST and BST problems. Given a graph
with two edge weight functions—
representing transmission costs and
denoting verification delays—the MSST problem seeks a spanning tree
that minimizes the combined objective
which balances both worst-case delay and total cost across all possible spanning trees. Notice that the MST and BST problems are both special cases of the more general MSST problem. The current fastest algorithm for determining the MSST of
was proposed by Punnen and Nair [
11] in
time.
The study of performance enhancement in adversarial and proactive scenarios is increasingly crucial in network optimization with the rapid expansion of modern communication networks. In adversarial scenarios, the model of the interdiction problem on MSST provides a quantitative analysis tool for protecting critical information infrastructure. By identifying vulnerable points in networks, security teams can give priority to reinforce these critical connections to enhance the overall network resilience against attacks. Conversely, from a proactive optimization perspective, one can reinforce critical connections to improve overall network performance, corresponding precisely to the improvement problem on MSST. Note that network operators can adjust overall network performance under budget constraints by optimizing bandwidth allocation (adjusting weight c) and/or reducing transmission delays (adjusting weight w).
Despite its clear practical relevance, the MSST problem has received relatively little attention in the literature. Some progress has been made on the inverse MSST problem, which aims to find minimal adjustments of edge weights (to
c or/and
w) under specific norms to make a given spanning tree
optimal [
12]. When adjusting
c under the weighted
norm, Guan et al. [
13] transformed the problem into a linear fractional combinatorial optimization problem and designed an algorithm in
time. Under the weighted
norm, Zuo et al. [
14] proposed a column generation algorithm to solve a special case of the problem, in which the minimum relative cost in each iteration can be transformed into solving a MSST problem under new parameters and can be solved in polynomial time. Further, Guan et al. [
15] reformulated the problem as a linear program with an exponential number of constraints and solved it via column generation. For the weighted bottleneck Hamming distance, Guan et al. [
16] proposed a
time algorithm based on a binary search method and showed the NP-hardness of the problem under the unit-sum Hamming distance. When adjusting
w, Jia et al. [
17] proposed a
time algorithm based on a binary search and the greedy technique. Interdiction and improvement problems on MSST remain significantly understudied in the existing literature, highlighting a clear research gap.
We let be a simple edge-weighted connected undirected graph, where and , are the sets of vertices and edges, respectively. And we let and be the sum-type weight and maximum weight functions, respectively. The MSST interdiction problem (MSSTID) aims at adjusting some weights of edges (for c or/and w) to minimize the total cost under some measurement such that the weight of the optimal MSST is at least K, while the MSST improvement problem (MSSTIP) similarly aims to make the weight of the optimal MSST at most K through minimal total cost of weight modifications under some measurement. This paper mainly studies problems MSSTID and MSSTIP under the weighted norm by modifying w or c.
In this paper, for any , we let denote the cost of adjusting or by one unit. Note that if there is an edge with , indicating zero cost, we can modify its weight directly to either its upper or lower bound to obtain a new modified graph, in which the relevant problem can then be solved. For instance, in the problem (MSSTID) under weighted norm by modifying w, we can set all zero-cost edges to their upper bounds and solve the problem in this modified graph. Therefore, without loss of generality, in this paper, we only consider the case when for all .
For convenience, we define the following useful notations in this paper. We let and be the sum of weight c and the maximum weight of w on a tree T in brief. We let be the combined metric denoted by any one edge with the maximum weight of w on a tree T.
Here is a property frequently used in this paper regarding the intersections of several piecewise linear functions.
Lemma 1 ([
17]).
Let be a set of piecewise linear functions with x as the independent variable, where are constants. Let be the set of x-coordinates corresponding to all intersection points of the lines in the family , sorted such that . For any interval , let . If , then holds for all .Note: In the line family , if two lines coincide, that is, they are identical, do not compute their intersection point.
The following lemma characterizes the invariance of the optimal MSST under perturbations of c or w, provided that the relative ordering of the edges remains unchanged.
Lemma 2. Let be a simple edge-weighted connected undirected graph. Construct an auxiliary network for a given , where . Suppose the network is connected and the spanning tree is the optimal MSST with as its maximum weight edge.
(1) If the order of every edge is the same under c and , then the spanning tree remains the optimal MSST in with as the maximum weight edge.
(2) If the order of every edge is the same under w and , then the spanning tree remains the optimal MSST in with as the maximum weight edge.
Proof. (1) Note that
is the optimal MSST with
as the maximum weight edge in network
, hence
is the minimum spanning tree under
c containing the edge
. Furthermore,
is also the minimum spanning tree under
containing the edge
according to the Cycle Optimality Conditions for Minimum Spanning Trees (page 519 of [
18]), which implies
remains the optimal MSST in
with
as the maximum weight edge. Similarly, the proof for (1) also holds for (2). □
The paper is organized as follows. In
Section 2, we solve problem MSSTID under weighted
norm by modifying
w in
time by a binary search method and the greedy technique based on series of necessary analysis. Building on this approach,
Section 3 solves problem MSSTIP under weighted
norm by modifying
w in
time. In
Section 4 and
Section 5, we propose two algorithms both in
time to solve problems MSSTID and MSSTIP under weighted
norm by modifying
c, respectively. In
Section 6, numerical experiments are conducted to show the efficiency of the four algorithms. In
Section 7, we draw a conclusion and put forward future research.
2. Solve Problem MSSTIDw
In this section, we study problem MSSTID under weighted
norm by modifying
w (
). For any
, we let
denote the cost of adjusting
by one unit and
represent the upper limit for increasing
. The mathematical model is as follows:
For any given
, we define a vector
as follows:
Lemma 3. The vector defined as (3) is a feasible solution to problem if and only if , where is the optimal value of problem . Moreover, if , then is an optimal solution of problem . Proof. Necessity: We let
defined as (
3) be a feasible solution and let
be an optimal solution of problem
, that is,
. We show that
. We have
Hence, we have . Then holds.
Sufficiency: Suppose is an optimal solution to problem . We prove that for any , holds. Suppose there exists , such that , that is,
(1) If , then , which contradicts with .
(2) If
, then
, which implies
This contradicts with
. Thus, Constraints (
1) and (
2) hold for the vector
, confirming that
is indeed feasible.
We next show that
Similar to the process in (
4), we have
, where it is sufficient to show that
as for any edge
we have
.
To sum up, the lemma holds. □
By Conditions (
1) and (
2), the following lemma immediately holds.
Lemma 4. Define . Let and be the optimal MSSTs under weights w and , respectively. If , then no adjustment is needed for problem . If , then problem is infeasible.
By Lemmas 3 and 4, we can determine the optimal value by a binary search method, which can be proceeded as follows: First, we establish an upper bound and a lower bound for . Then, we evaluate the midpoint to determine its relationship with and update the bounds accordingly. This process is repeated until the interval length becomes smaller than a sufficiently small positive number . At this point, we consider . Since the number of iterations depends on the precision , this algorithm is not strongly polynomial. To design a strongly polynomial-time algorithm, we present the following lemma.
Lemma 5. Let be the optimal objective value of problem and be the optimal solution constructed via (3). Then there exists a spanning tree and an edge such that and , where . Proof. (1) We prove that there exists satisfying . Suppose for , . We define , , , , . We construct . Clearly, remains feasible, but its objective value is strictly less than , contradicting the optimality of .
(2) We let and . We prove there is satisfying . We assume for all , holds. We define , , , , . We construct . Again, is feasible but yields a strictly better objective value than , leading to a contradiction. □
We now present a strongly polynomial-time algorithm to solve this problem. The main steps are as follows: (1) If the problem is feasible and requires adjustment, we compute all x-coordinates of intersection points for the line family:
. We add the upper bound
and the lower bound 0 of
to this set. (2) Using a binary search method on the constructed set, we identify the interval
containing
, where
. We construct
via (
3) with
. (3) We compute the bottleneck value
and identify the set
of critical edges. By Lemmas 1 and 5, the edge
defined in Lemma 5 must be in
, so we only need to verify edges in
.
Note: For Line 25 in Algorithm 1, computing the optimal MSST with as maximum-weight edge can be implemented as
(1) Construct a modified sum vector
(2) Compute optimal MSST
on
, that is,
is the optimal MSST with
as maximum-weight edge on
.
| Algorithm 1 An algorithm to solve problem (): . |
| Input: Network , four vectors and a given value . |
| Output: The optimal value . |
| 1: Let . Determine the optimal MSSTs , under w and , respectively. |
| 2: if then |
| 3: return |
| 4: end if |
| 5: if then |
| 6: “The problem is infeasible.” |
| 7: end if |
| 8: Compute all x-coordinates of intersection points for the line family , denoted as set . |
| 9: Let , . |
| 10: Sort elements in in ascending order. |
| 11: Initialization: , . |
| 12: while do |
| 13: Let and . Construct via (3) and determine an optimal MSST . |
| 14: if then |
| 15: Update . |
| 16: else |
| 17: Update . |
| 18: end if |
| 19: end while |
| 20: Let . Construct and via (3). |
| 21: Let , . |
| 22: Initialize . |
| 23: for each do |
| 24: Let . |
| 25: Compute optimal MSST on with as the maximum-weight edge. |
| 26: if then |
| 27: Let , . |
| 28: Update . |
| 29: end if |
| 30: end for |
| 31: return . |
Theorem 1. Algorithm 1 correctly solves problem .
Proof. Lines 8–19 identify the interval containing the optimal value . Lemma 1 guarantees that for any , if holds for , then holds. This implies the maximum-weight edge for each spanning tree remains unchanged during the approximation from to . As a consequence, given an edge e and a spanning tree T, if T is optimal for among the trees with e as its maximum weight edge, then it remains so during the approximation process. Notice that is the bottleneck value under in Line 21, so that we have , where is defined in Lemma 5. From Lines 23 to 30 of Algorithm 1, we sequentially determine whether each edge could possibly be . First, we compute the optimal MSST with as the maximum weight edge under . It remains the optimal MSST in with as the maximum weight edge for any by Lemma 2. If , it implies that edge might be . Consequently, we need to increase the weight of this edge by the minimum cost so that under the new cost , the total weight of is exactly K. At this point, serves as a lower bound for , since problem requires that the sum of the maximum weight and the sum-type weight in every spanning tree must be at least K. Therefore, after the for loop ends, we obtain the optimal value . □
Theorem 2. We can solve problem by Algorithm 1 in time.
Proof. Lines 1–7 require two optimal MSST computations, costing
time. Line 8 computes intersections of
lines in
time, with
. Sorting (Lines 9–10) takes
. The binary search method (Lines 12–19) runs
iterations, totaling
. Line 21 needs
time to calculate the bottleneck value [
19]. Lines 23–30 execute
iterations with one optimal MSST computation in each iteration in
. Thus, the overall time complexity is
. □
3. Solve Problem MSSTIPw
This section investigates problem MSSTIP under weighted
norm by modifying
w (
). For each
, we let
denote the unit adjustment cost for
and
represent the downward adjustment limit with
. The mathematical formulation is
For any
, we define the weight vector
as follows:
Similar to Lemma 3, the following lemma holds:
Lemma 6. The vector as (7) is feasible for if and only if , where is the optimal value. Moreover, if , then is an optimal solution of problem . By Conditions (
5) and (
6), the following lemma immediately holds.
Lemma 7. Define . Let and be the optimal MSSTs under weights w and , respectively. If , then no weight adjustment is required for problem . If , then problem is infeasible.
Building upon Lemma 6, we could employ a binary search method to determine the optimal value . However, since the number of iterations depends on the precision parameter , this approach does not yield a strongly polynomial-time algorithm. To develop a strongly polynomial-time algorithm, we establish the following key lemma:
Lemma 8. Let be the optimal objective value of problem and be the optimal solution constructed via (7). Then there exists a spanning tree and an edge satisfying , and . Proof. (1) We first prove that for all . We suppose there is such that . We define , , , , . We construct which remains feasible but achieves a better objective value than , contradicting with the optimality of . Thus, there is with .
(2) Next, we let and . We show there is satisfying . We assume by contradiction that for all . We define , , , , . We construct which is feasible with better objective value, contradicting the optimality of . Therefore, the required must exist. □
We now present a strongly polynomial-time algorithm for solving problem
with the main steps outlined as follows. For feasible problems requiring adjustment: (1) We compute all x-coordinates of intersection points for the line family
and add the upper bound
and lower bound 0 to this set. (2) We use a binary search method on this set to determine the optimal interval
with
. We construct
via (
7) with
. (3) We compute the bottleneck value
and identify critical edges
. By Lemmas 1 and 8, the optimal value must be attained on some edge in
, so we only need to verify edges in
.
Theorem 3. Algorithm 2 correctly solves problem .
| Algorithm 2 An algorithm to solve problem : . |
| Input: Network , weight vector , sum vector , lower bounds , cost vector and a given value K. |
| Output: Optimal value . |
| 1: Compute and optimal MSSTs , . |
| 2: if then |
| 3: return |
| 4: end if |
| 5: if then |
| 6: “The problem is infeasible.” |
| 7: end if |
| 8: Compute all x-coordinates of intersection points for the line family , denoted as |
| 9: Let , . |
| 10: Sort in ascending order. |
| 11: Initialization: , . |
| 12: while do |
| 13: Let and . Construct via (7). Determine the optimal MSST under . |
| 14: if then |
| 15: . |
| 16: else |
| 17: . |
| 18: end if |
| 19: end while |
| 20: Let . Construct , , via (7). |
| 21: Let , . |
| 22: Initialize . |
| 23: for each do |
| 24: Let . |
| 25: Compute optimal MSST on with as the maximum-weight edge. |
| 26: Let , . |
| 27: if then |
| 28: Update . |
| 29: end if |
| 30: end for |
| 31: return |
Proof. Lines 8–19 identify the interval containing the optimal value . Lemma 1 guarantees that for any , if holds for , then holds. This implies the maximum-weight edge for each spanning tree remains unchanged during the approximation from to . Notice that is the bottleneck value under in Line 21, so that we have , where is defined in Lemma 8. From Lines 23 to 30 of Algorithm 2, we sequentially determine whether each edge could possibly be . We first compute the optimal MSST with as the maximum weight edge under whose value . It remains the optimal MSST in with as the maximum weight edge for any by Lemma 2. Consequently, we need to decrease the weight of this edge by the minimum cost so that under the new cost , the total weight of is exactly K. What is more, we consider at the same time, so the conditional statement in Line 27 is necessary. Notice that the case when means cannot be , so we only need to consider the case . Then serves as an upper bound for , since problem just requires that the sum of the maximum weight and the sum-type weight in the optimal MSST is no more than K. Therefore, after the for loop ends, we obtain the optimal value . □
Theorem 4. We can solve problem by Algorithm 2 in time.
Proof. Similar to Theorem 2, the time complexity of Lines 8–10 is . The binary search method in Lines 12–19 requires iterations, leading to a time complexity of . Line 21 computes the bottleneck value in time. Lines 23–30 involve a loop over edges, where each iteration requires computing an optimal MSST once, resulting in a time complexity of . Then the overall time is . □
4. Solve Problem MSSTIDc
In this section, we study problem MSSTID by modifying
c under weighted
norm (
). For any
, we let
be the cost required to adjust one unit of
,
be the upper adjustment limit of
. The mathematical formula is as follows:
For any given
, we define vector
as
Lemma 9. The vector as (10) is feasible for problem if and only if , where is the optimal value. Moreover, if , then is an optimal solution of problem . By Conditions (
8) and (
9), the following lemma is immediate.
Lemma 10. Define . Let and be the optimal MSSTs under c and , respectively. If , then problem requires no adjustment. If , then problem is infeasible.
According to Lemma 9, we can use binary search to determine the optimal value . However, the number of iterations depends on the precision , making it not a strongly polynomial-time algorithm. To design a strongly polynomial-time algorithm, we present the following lemma.
Lemma 11. Let be the optimal value of problem , be the optimal solution constructed by (10), , , . Then , and . Proof. Since is optimal, then . If , we let and construct ( ).
Furthermore, for any
,
If , then .
If
, then
It contradicts with the optimality of ; then, . Moreover, is the bottleneck value under weight w, so . □
Based on the lemmas above, we design a strongly polynomial-time algorithm to solve this problem. The main ideas are as follows: If the problem is feasible and adjustment is needed, we (1) compute all x-coordinates of intersection points for the line family
and add the upper bound
and lower bound 0 of
to this set; (2) use a binary search method on this set to determine the interval
containing the optimal value
, where
, compute the edge set
from Lemma 11; (3) for each
, construct an auxiliary network
, where
,
and
is constructed by (
10), find the optimal MSST
in
with
as the maximum weight edge, determine the set
of adjustable edges in
, and compute the minimum cost
to adjust these edges so that the total weight of
reaches
K; and finally (4) for each
, if
is non-empty, the cost
gives a candidate optimal value. The maximum among all these candidates is the optimal value.
Theorem 5. Algorithm 3 correctly solves problem .
| Algorithm 3 An algorithm to solve problem : . |
| Input: Network , weight vector , sum vector , upper bounds vector , cost vector and constant . |
| Output: Optimal value . |
| 1: Let , determine the optimal MSSTs under c and , denoted as and . |
| 2: if then |
| 3: return |
| 4: end if |
| 5: if then |
| 6: “The problem is infeasible.” |
| 7: end if |
| 8: Compute all x-coordinates of intersection points for the line family: , denoted as set . |
| 9: Let , . |
| 10: Sort the elements in in ascending order. |
| 11: Initialize . |
| 12: while do |
| 13: Let , , construct by (10), determine the optimal MSST under . |
| 14: if then |
| 15: Update . |
| 16: else |
| 17: Update . |
| 18: end if |
| 19: end while |
| 20: Let , construct via (10). |
| 21: Let , . |
| 22: Initialize . |
| 23: for do |
| 24: Let . |
| 25: Compute optimal MSST in with as the maximum weight edge. |
| 26: if then |
| 27: Compute the set of adjustable edges in : . |
| 28: Let . Update . |
| 29: end if |
| 30: end for |
| 31: return . |
Proof. Lines 8–20 identify the interval containing the optimal value . By Lemma 1, for any , if holds for , then holds. Line 21 computes and from Lemma 11. Notice that is the bottleneck value under w in Line 21, so we have , where is defined in Lemma 11. From Lines 23 to 30 of Algorithm 3, we sequentially determine whether each edge could possibly be . We first compute the optimal MSST in with as the maximum weight edge. It remains the optimal MSST in with as the maximum weight edge for any by Lemma 2. If , then the set of adjustable edges in is non-empty and any edge satisfies according to the construction of the line family in Line 8. Then Line 28 computes the minimal cost to increase the total weight of to exactly K, yielding a lower bound of the optimal value. □
Theorem 6. We can solve problem by Algorithm 3 in time.
Proof. Similar to Theorem 2, Lines 8–10 take time. The binary search method in Lines 12–19 has iterations, totaling time. Line 21 computes the bottleneck value in time. Lines 23–30 loop times, each requiring one optimal MSST computation, hence time. Therefore, the overall time complexity is . □
5. Solve Problem MSSTIPc
In this section, we study problem MSSTIP by modifying
c under weighted
norm (
). For any
, we let
be the cost required to adjust one unit of
,
be the lower adjustment limit of
with
. The mathematical model is as follows:
For any given
, we define vector
as
Lemma 12. The vector as (13) is feasible for problem if and only if , where is the optimal value. Moreover, if , then is an optimal solution of problem . By Conditions (
11) and (
12), the following lemma is immediate.
Lemma 13. Define . Let and be the optimal MSSTs under c and , respectively. If , then no adjustment is needed. If , then the problem is infeasible.
By Lemma 12, we can determine via a binary search method, but the iteration count depends on precision , making it not strongly polynomial. To design a strongly polynomial algorithm, we present the following lemma.
Lemma 14. Let be the optimal value of problem , be the optimal solution constructed by (13), , , . Then , and . Proof. Since is optimal, then .
If , let .
We construct
for
. Then,
Moreover, for any
,
If , then .
If
, then
It contradicts the optimality of . Hence, . Also, is the bottleneck value under weight w, so . □
Based on lemmas above, we design a strongly polynomial-time algorithm. The main ideas are as follows. If the problem is feasible and the adjustments are needed, we (1) compute all x-coordinates of intersection points for the line family
and add
and 0 to this set; (2) use a binary search method to find the interval
with
, compute
from Lemma 14; (3) for each
, construct auxiliary network
where
,
and
from (
13), find the optimal MSST
in
with
as maximum weight edge, determine the set
of adjustable edges in
, and compute the minimum cost
to adjust these edges so that the total weight of
is decreased to
K; and finally (4) for each
, if
is non-empty, the cost
gives a candidate optimal value. The minimum among all candidates is
.
Theorem 7. Algorithm 4 correctly solves problem .
| Algorithm 4 An algorithm to solve problem : . |
| Input: Network , weight vector , sum vector , lower bounds vector , cost vector , and constant . |
| Output: Optimal value . |
| 1: Let , compute optimal MSSTs and . |
| 2: if then |
| 3: return |
| 4: end if |
| 5: if then |
| 6: “The problem is infeasible.” |
| 7: end if |
| 8: Compute the set of all x-coordinates of intersection points for the line family: . |
| 9: Let , . |
| 10: Sort in ascending order. |
| 11: Initialize . |
| 12: while do |
| 13: Let , , construct using (13), compute optimal tree under . |
| 14: if then |
| 15: Update . |
| 16: else |
| 17: Update . |
| 18: end if |
| 19: end while |
| 20: Let , construct via (13). |
| 21: Compute , . |
| 22: Initialize . |
| 23: for do |
| 24: Let . |
| 25: Determine the optimal tree in with as maximum weight edge. |
| 26: Compute the set of decreasable edges in : . |
| 27: if then |
| 28: Let . Update . |
| 29: end if |
| 30: end for |
| 31: return . |
Proof. Lines 8–20 identify the interval containing the optimal value . By Lemma 1, for any , if holds for , then holds. Line 21 computes and from Lemma 14. Notice that is the bottleneck value under w in Line 21, so we have , where is defined in Lemma 14. From Lines 23 to 30 of Algorithm 4, we sequentially determine whether each edge could possibly be . We first compute the optimal MSST in with as the maximum weight edge whose value must be more than K. It remains the optimal MSST in with as the maximum weight edge for any by Lemma 2. Then if the set of adjustable edges in is non-empty and any edge satisfies according to the construction of the line family in Line 8, Line 28 computes the minimal cost to decrease the total weight of to exactly K, yielding an upper bound of the optimal value. □
Theorem 8. We can solve problem by Algorithm 4 in time.
Proof. Similar to Theorem 2, Lines 8–10 take time. The binary search method in Lines 12–19 has iterations, taking time. Line 21 computes in time. Lines 23–30 loop times, each requiring one optimal MSST computation, hence time. Therefore, the overall complexity is . □
6. Numerical Experiment
To evaluate the runtime performance of Algorithms 1–4, we generated seven types of random graphs with node and edge counts
as (200, 500), (500, 1000), (1000, 2000), (2000, 5000), (4000, 8000), (5000, 10,000), (10,000, 15,000). For each graph size, 200 instances were randomly generated with parameters
,
,
,
,
, and
, where
U stands for the uniform distribution. The algorithm was implemented in MATLAB R2020a and run on a Lenovo Legion Y7000P laptop (manufacturer: Lenovo, Beijing, China) with Windows 10, Intel(R) Core(TM) i5-8250U CPU @1.60 GHz, 8.00 GB RAM. The running times are shown in
Table 1, where the running time is measured in seconds.
These comprehensive results confirm that all four algorithms with time complexity
maintain practical computational efficiency even for large-scale problem instances, making them suitable for real-world applications. For a better understanding of the running time complexity, we have the following
Figure 1 to illustrate the comparison between the theoretical runtime complexity and the empirical average runtime of four algorithms (Algorithms 1–4).
In each sub-figure, the theoretical complexity is represented by the blue dashed line , and the colored straight lines show the linear fit of the average runtime against the theoretical complexity term , with the corresponding scatter points representing the actual observed values. The results demonstrate that the empirical runtime growth aligns closely with the theoretical model, confirming the expected complexity behavior for these algorithms.
7. Conclusions and Further Research
This work presents a comprehensive study of problems MSSTID and MSSTIP under the weighted norm. Focusing on undirected graphs with two edge weights c and w, we establish complete mathematical formulations for both MSSTID and MSSTIP, where the former strategically modifies edge weights c or w to degrade network performance (ensuring the weight of MSST is at least K), while the latter optimizes weight adjustments for performance enhancement (the weight of MSST is no more than K). We provide a rigorous analysis of optimal value properties and then develop four strongly polynomial-time algorithms with a time complexity of through innovative combinations of binary search methods and greedy techniques. Finally, we conducted comprehensive numerical validations of the proposed methods and algorithms, demonstrating their effectiveness.
The current algorithms presented in this paper are exact algorithms, and their time complexity is confirmed and manageable. In terms of memory complexity, the primary storage requirement comes from storing the graph , which scales as , where n is the number of nodes in the graph. This memory requirement is feasible for most real-world applications, as the size of the graphs typically encountered can be handled by current computational resources.
For extremely large-scale graphs with millions of edges and nodes, further research is needed to explore more advanced methods, such as graph decomposition, which would allow us to handle larger instances efficiently. While the algorithm in this study focuses on solving problems MSSTID and MSSTIP under norm, it is important to note that the approach may not directly apply to similar problems under other norms. This is a common challenge in combinatorial optimization, where specialized algorithms are often required for different problem structures. Nonetheless, the methodology developed in this paper can be adapted and extended to solve related problems in other infinite models.
For future research, we can consider problems MSSTID and MSSTIP by adjusting the two edge weights (c and w) at the same time. Meanwhile we identify the weighted norm setting as a particularly promising direction, given its fundamental connections to inverse MSST problems and its potential to yield new theoretical insights in combinatorial optimization.