Widest Path in Networks with Gains/Losses

Abstract

In this paper, the generalized widest path problem (or generalized maximum capacity problem) is studied. This problem is denoted by the GWPP. The classical widest path problem is to find a path from a source (s) to a sink (t) with the highest capacity among all possible s-t paths. The GWPP takes into account the presence of loss/gain factors on arcs as well. The GWPP aims to find an s-t path considering the loss/gain factors while satisfying the capacity constraints. For solving the GWPP, three strongly polynomial time algorithms are presented. Two algorithms only work in the case of losses. The first one is less efficient than the second one on a CPU, but it proves to be more efficient on large networks if it parallelized on GPUs. The third algorithm is able to deal with the more general case of losses/gains on arcs. An example is considered to illustrate how each algorithm works. Experiments on large networks are conducted to compare the efficiency of the algorithms proposed.

1. Introduction

Consider a directed and connected network $G=\left(V, A, u\right)$, where $V$ represents the set of nodes, A represents the set of arcs (each arc $a=\left(i, j\right)$ starts from node $i$ and terminates at node $j$), and $u$ is a capacity function mapping arcs to non-negative real numbers. Within this network, there are two special nodes: $s$, referred to as the source node; and $t$, referred to as the sink node. Let $n$ denote the total number of nodes in the network (|V|) and $m$ represent the number of arcs (|A|). A path, denoted as $P$, from a node $w \in V$ to a node $v \in V$ in network $G$ is defined as a sequence of nodes $P: \left(w=i_1, i_2, \dots , i_l=v\right)$, where $l$ is equal to or greater than $1$, and each consecutive pair of nodes $\left(i_k, i_{k+1}\right)$ is an arc from $A$ for every $k=1, 2, \dots , l-1$.

Combinatorial optimization is a special class of mathematical program that consists of finding an optimal object among a finite set of specifically structured objects. Some of the most prominent problems of this class are shortest path (SP) problems, maximum reliability path (MRP) problems, and maximum capacity path (MCP) problems/widest path problem (WPP). In these problems, the goal is to find an optimal path from an origin to a destination under a special objective function as follows:

• $\underset{P\in \mathbb{P}}{\min }{\displaystyle \sum }_{\left(i,j\right)\in P}{l}_{ij}$ for SP problems.
• $\underset{P\in \mathbb{P}}{\max }{\displaystyle \prod }_{\left(i,j\right)\in P}{p}_{ij}$ for MRP problems.
• $\underset{P\in \mathbb{P}}{\max }{\underset{\left(i,j\right)\in P}{\min }}_{}{u}_{ij}$for WPP.

where the set $\mathbb{P}$ consists of all paths from the origin to the destination. In this context, the parameters $l_{ij}$, $p_{ij}$, and $u_{ij}$ represent the length, reliability, and capacity of arc $\left(i,j\right)$ respectively. Fortunately, these problems are tractable and there exist polynomial time algorithms to solve them. For instance, the shortest path problem can be solved using Dijkstra’s algorithm with a Fibonacci heap implementation [1], which has a complexity of $O\left(m+n\log \left(n\right)\right)$ if the lengths, $l_{ij}$, are nonnegative. In case the lengths are negative, the best-known algorithm is a FIFO implementation of the Bellman–Ford algorithm [2,3], with a complexity of $O\left(mn\right)$, where $n$ and $m$ represent the number of nodes and arcs, respectively. The maximum reliability path problem can be transformed into a shortest path problem by defining $l_{ij}$ as $-\log \left(p_{ij}\right)$ for every arc $\left(i,j\right)$. Consequently, it can be solved similarly to the shortest path problem, especially when $p_{ij}$ is less than $1$. Additionally, both the maximum reliability path problem and the widest path problem can be solved directly by modifying the shortest path algorithms. This is because they share similar optimality conditions with the shortest path problem (refer to [4] for more details). However, the best-known algorithm for solving the widest path problem in an undirected network does not rely on this concept. Instead, it employs a recursive algorithm with a linear complexity of $O\left(m\right)$ [5]. The maximum capacity problem has many applications. The service vehicles and emergency vehicles should use such a path when returning from a service call to the base [6]. Also, the maximum capacity problem could be used to deal with computation problems where only comparison of the graph’s arcs values is permitted [7,8].

The WPP finds its application in various domains. For instance, let us consider a network that represents connections between routers on the Internet. In this context, each arc in the network denotes the bandwidth of the corresponding connection between two routers. With the WPP, the objective is to discover the path between two Internet nodes that offers the highest possible bandwidth. This network routing problem is well-known in the field. Apart from being a fundamental network routing problem, the WPP also plays a crucial role in other areas. One noteworthy application is within the Schulze method, which is utilized for determining the winner of a multiway election [9]. In this method, the WPP aids in resolving ties and determining the strongest path among multiple alternatives. Additionally, the WPP finds application in digital compositing, wherein it assists in combining multiple images or video layers into a final composite image or sequence [10]. By identifying the path with the maximum capacity, the compositing process can ensure the most efficient allocation of computational resources. Moreover, the problem contributes to metabolic pathway analysis, which involves studying chemical reactions within biological systems. In this context, the WPP aids in understanding the flow of metabolites through various pathways and identifying the most influential pathways in terms of capacity [11]. In summary, the WPP has extensive applications ranging from network routing on the Internet, multiway election methods, and digital compositing, to metabolic pathway analysis. Its capability to identify and utilize paths with the highest capacity proves valuable across these diverse domains.

In this paper, a new combinatorial optimization problem called the generalized widest path (GWPP) problem is introduced. It is a more intricate version of the problem that involves finding a directed path from a given source node s to a given sink node t, with the minimum loss among all available directed paths from s to t [12]. To our knowledge, this is the only paper in the literature that studies st-paths in the gain/loss case. The GWPP is defined on a network where each arc is characterized by two attributes: capacity and loss/gain factor.

The capacity of an arc represents the maximum flow value that can be transmitted through it. On the other hand, the loss/gain factor of an arc indicates the flow value that arrives at the tail node when one unit of flow is sent through the arc. The objective of the GWPP is to find a path that is capable of transmitting the maximum flow while considering the loss/gain factors.

This problem is inspired by an extension of the maximum flow problems [13,14] that incorporates loss/gain factors, known as the generalized maximum flow problem. Therefore, the algorithms developed for solving the GWPP can also be utilized as subroutines for addressing generalized maximum flow problems.

Moreover, the GWPP can be viewed as an extension of the maximum reliability path and widest path problems. It becomes equivalent to the MRP problem when capacities are infinite and transforms into the WPP when the loss/gain factors are equal to $1$. Thus, the GWPP upon the scope of both MRP and the WPPs, encompassing their characteristics and generalizations.

In this paper, we introduce the GWPP—a novel combinatorial optimization problem that extends the concept of the WPP by incorporating loss/gain factors. The algorithms developed for the GWPP can be utilized for generalized maximum flow problems, making it a versatile and applicable problem in various contexts.

The rest of this paper is organized as follows. In Section 2, we provide the necessary background information and definitions to lay the foundation for the research work. Section 3 clearly defines the research problem and outlines its significance. Section 4 describes, in detail, the first two proposed algorithms to solve the GWPP in the case of loss factors. In Section 5, the more general case of loss/gain factors is studied, and an algorithm is presented to solve the GWPP in this general case. Section 6 presents the experiments conducted to validate and evaluate the proposed algorithms. Finally, Section 7 summarizes the main findings of the paper.

The current paper is an extension of the paper presented and published in the proceedings of the 13th International Conference on Operations Research and Enterprise Systems (ICORES 2024) [15]. In the current paper, the general case (with loss/gain factors) is studied, and a strongly polynomial algorithm is introduced to solve the GWPP in the general case (see Section 5). Also, in order to illustrate the functionality of the proposed algorithms, the iterations of each of the three algorithms are presented for a given network (see Section 4 and Section 5). The experiments from Section 6 were extended for Algorithm 3 [15] as well.

2. Preliminaries

For the sake of simplicity, from now on, we refer to a path from $s$ to $t$ as an “$st$-path”.

The capacity of an $st$-path $P$ is denoted by $u\left(P\right)$ and is given by the minimum of its capacities, that is,

$$u\left(P\right)=\min \left\{u\left(a\right)|a\in P\right\}.$$

In the network $\mathrm{G}$ is intended to find an $st$-path $\tilde{P}$ with the maximum capacity among all $st$-paths:

$$u\left(\tilde{P}\right)=\max \left\{u\left(P\right)|P \mathrm{is}\mathrm{an}s-t\mathrm{path}\right\}.$$

This problem is also called the widest path problem, the bottleneck shortest path problem, and the max–min path problem in the literature.

3. Problem Formulation

In this section, we will delve into the problem of the generalized widest path. Let us formally define the problem considering a connected and directed network denoted as $G\left(V, A, u, p\right)$. Here, $p$ is the loss/gain factor parameter.

For each arc $\left(i, j\right) \in A$, there are two key parameters associated with it. The first one is the capacity, denoted as $u_{ij}$, which represents the maximum amount of flow that can be sent along the arc. The second parameter $p_{ij}$ is the loss factor if it lies in the interval $\left(0,1\right]$, or it is the gain factor if $p_{ij}\in \left(1,+\infty \right)$. The loss factor captures physical transformations such as evaporation, energy dissipation, breeding, theft, or interest rates [16]. The loss/gain factor could be the exchange rate of two different currencies.

Considering the flow along the arcs, if $x_{ij}$ units of flow enter arc $\left(i, j\right)$, $p_{ij}{x}_{ij}$ units of flow are actually delivered to node $j$. If $p_{ij}\in \left(0,1\right]$, then this implies that $\left(1-p_{ij}\right)x_{ij}$ units of flow are absorbed or lost along the arc due to the specified loss factor. If $p_{ij}\in \left(1,+\infty \right)$, then this means that flow is increased by $\left(p_{ij}-1\right)x_{ij}$ units.

The aim of the generalized widest path problem is to find an $st$-path that enables the transmission of the maximum possible flow while taking the loss/gain factors into consideration.

To formulate this problem in a precise manner, we introduce the following variables:

-

$x_{ij}$, representing the flow entering arc $\left(i, j\right)$.

-

$y_{ij}$, a binary variable that determines whether or not arc $\left(i, j\right)$ carries a positive flow ($1$ if it does, $0$ otherwise).

Now, we can express the GWPP as a mixed zero–one linear programming model, which can be stated as follows:

$$\max z=v_t$$

(1a)

$${{\displaystyle \sum }}_{j:\left(i,j\right)\in A}{x}_{ij}-{{\displaystyle \sum }}_{j:\left(j,i\right)\in A}{p}_{ji}{x}_{ji}=\left\{\begin{array}{c}{v}_s i=s,\\ 0 i\ne s,t,\\ -v_t i=t, \end{array}\right.\forall i\in V,$$

(1b)

$${{\displaystyle \sum }}_{j:\left(i,j\right)\in A}{y}_{ij}\le 1, \forall i\in V\backslash \left\{t\right\},$$

(1c)

$$0\le x_{ij}\le u_{ij}{y}_{ij}, \forall \left(i,j\right)\in A.$$

(1d)

Let us break its points down into separate parts:

• The variables $v_s$ and $v_t$ represent the flow leaving the source node $s$ and the flow entering the sink node $t$, respectively.
• Constraints (1b) and (1d) correspond to the balanced flow constraint and the bound constraints commonly found in maximum flow problems [4].
• Constraint (1c) ensures that, at most, one outgoing arc from any node is capable of sending flow. This constraint guarantees that flow is sent only along a single $st$-path.
• The formulation (1) of the GWPP closely resembles that of generalized maximum flow problems, with the added inclusion of zero-one variables $y_{ij}$ and the constraint (1c) [4].

 Remark 1. 

While we have assumed that$p_{ij}\le 1$, constraint (1d) does not account for the possibility of a flow increment on arc$\left(i,j\right)$when$p_{ij}>1$. In such cases, it should be written as$0\le max\left\{x_{ij},p_{ij}{x}_{ij}\right\}\le u_{ij}{y}_{ij}$. To handle this situation without loss of generality, we can redefine the capacity of arc$\left(i,j\right)$ as $min\left\{u_{ij},u_{ij}/p_{ij} \right\}$.

4. Algorithms for the Case of Losses on Arcs

This section focuses on the development of two algorithms to solve the GWPP in polynomial time. This provides evidence that the problem is tractable, similar to the WPP, SP, and MRP problems.

We start with a simple observation: if we send the maximum flow along a path, then at least one of its arcs will be saturated. The capacity of this saturated arc determines the flow value along the path. Let $\left(i_P, j_P\right)$ be the last saturated arc in an $st$-path $P=s-\cdots -i_P-j_P-\cdots -k-t.$ The flow value along path $P$ is then equal to $u_{i_P{j}_P}\times \left(p_{i_P{j}_P}\times \dots \times p_{kt}\right)$. An interesting insight is that if we remove the arc $\left(i_P, j_P\right)$ from the network and add a new arc $\left(s, j_P\right)$ with capacity $u_{s{j}_P}=u_{i_P{j}_P}$, loss factor $p_{s{j}_P}=p_{i_P{j}_P}$, $\mathrm{then}$ we can send the same flow value along the new path $s-j_P-\cdots -k-t$. This simple idea leads to a polynomial time algorithm for solving problem (1).

In the first algorithm, disregarding arc capacities, we aim to find a maximum reliability path from s to t, which is a path $P$ where the value of the product ${{\displaystyle \prod }}_{\left(i,j\right)\in P}{p}_{ij}$ is maximized. This can be achieved by assigning arc lengths $l_{ij}=-log\left(p_{ij}\right)$ and finding the shortest $st$-path based on these arc lengths. Let $P$ be the shortest path obtained. Then, we identify the last arc $\left(i_P, j_P\right)$ in $P$ that would become saturated if we were to send the maximum flow along $P$. We remove arc $\left(i_P, j_P\right)$ from the network and introduce an artificial arc $\left(s, j_P\right)$ with a loss factor $p_{s{j}_P}=p_{i_P{j}_P}$, capacity $u_{s{j}_P}=u_{i_P{j}_P}$, and a weight of $-\log (u_{i_P{j}_P}{p}_{i_P{j}_P})$. We repeat this process until we find a path $P$, in which the last saturated arc is one of the artificial arcs.

Considering the unique characteristics of our algorithm, it is noteworthy to underscore that the negative weights exclusively pertain to arcs emanating from the source node $s$. This crucial distinction enables the seamless application of Dijkstra’s algorithm, as its efficacy is contingent upon the absence of negative cycles within the graph. To further streamline the application of Dijkstra’s algorithm and eliminate negative arcs altogether, we propose a judicious adjustment to the arc weights. Specifically, we suggest augmenting all arcs with the minimum value among the arcs originating from $s$, denoted as $\min \left(s,j\right)$ for the pair $\left(s,j\right)$. This augmentation ensures the absence of negative weights in the entire graph, rendering it amenable to Dijkstra’s algorithm without any reservations.

Subsequently, upon identifying the optimal path and obtaining the computed result, we advocate for subtracting the added value, which is representative of the minimum value among the source-emerging arcs. This corrective measure guarantees the restoration of the original, unaltered values on the optimal path while harnessing the benefits of an adjusted graph conducive to the successful application of Dijkstra’s algorithm.

It is important to note that the optimal value of problem (1) is equal to the maximum flow along the last path found by the algorithm. To obtain the optimal path, we need to save the segment of path $P$ from $s$ to $i_P$ whenever $\left(i_P, j_P\right)$is removed and $\left(s, j_P\right)$ is added. This can be accomplished by introducing an additional parameter $P_{s{j}_P}$ for each artificial arc. Therefore, if the algorithm finds path $P$ in the last iteration, the optimal solution will be a path that includes arcs from $P_{s{j}_P}$ and $P$, excluding $\left(s, j_P\right)$.

Algorithm $1$ provides a formal description of our first algorithm. Since an arc is removed in each iteration, the number of iterations is, at most, equal to m (the total number of arcs). Algorithm 1 runs, at most, m times classical Dijkstra’s algorithm in the modified network (by applying –log to the initial values). As a result, we can conclude the following.

 Theorem 1. 

The complexity of Algorithm $1$is$O\left(mS\left(n,m\right)\right)$, in which$S\left(m,n\right)$ is the complexity of finding the shortest path in the network.

Algorithm 1 (Alg1)

Input: An instance of the generalized WPP Output: An optimal path   for $\left(i,j\right)\in A$:        if $i==s:$                  Set ${\overline{l}}_{ij}=-\log p_{ij}{u}_{ij}$ and $P_{ij}=\left(i,j\right)$        else:                  Set ${\overline{l}}_{ij}=-\log p_{ij}$ and $P_{ij}=\varnothing$ while True:        Find a shortest path $P$ with respect to ${\overline{l}}_{ij}$        if $P_{s{j}_P}\ne \varnothing :$        The optimal path is $P_{s{j}_P}\cup P\backslash \left\{\left(s,j_P\right)\right\}$        else:                  Find the last arc $\left(i_P,j_P\right)$ of $P$ to be saturated.                  Remove $\left(i_P,j_P\right)$.                  Add an artificial arc $\left(s,j_P\right)$                   $\mathrm{Set}{\overline{l}}_{s{j}_P}=-\log (u_{i_P{j}_P}{p}_{i_P{j}_P})$

Algorithm 1 iterations (Figure 1, Figure 2, Figure 3, Figure 4, Figure 5, Figure 6, Figure 7, Figure 8 and Figure 9 illustrate the iterations of the algorithm):

We observe that our graph example contains arcs with negative weights. However, this does not pose a problem as the negative arcs will always exist from the source node. This particularity ensures that Dijkstra’s algorithm performs well.

We applied Dijkstra’s algorithm to find the shortest path from source 1 to the sink 8. The resulting path is marked with dotted line and is $P$ = (1,4,3,5,6,8).

The last saturated arc $\left(5_P, 6_P\right)$ on the shortest path P is eliminated, and the arc (s,6) is added with the capacity of $\left(5_P, 6_P\right)$ and the weight ${\overline{l}}_{s{j}_P}=-\log (u_{i_P{j}_P}{p}_{i_P{j}_P})=$0.1503.

The resulted path on the second iteration is $P$ = (1,4,3,5,8).

On the new shortest path found, after we push the maximum flow through it, we find that the arc $\left(3_P, 5_P\right)$ is last saturated. So, it is removed, and the arc (1,5) is added with the same capacity of 3 and the new weight of −0.982.

The resulted path on the third iteration is $P$ = (1,4,5,8).

In the third iteration, the arc $\left(5_P, 8_P\right)$ is found to be the last saturated arc. An artificial arc (1,8) with the capacity 4 and weight −0.6931 is added.

The last saturated arc is one of the artificial arcs; therefore, we stop here. In this scenario, we applied Dijkstra’s algorithm fourth times. After we apply $P_{s{j}_P}\cup P\backslash \left\{\left(s,j_P\right)\right\}$, which, in our scenario, is $P_{s{j}_P}=\left(1,4,5\right)$ and $P\backslash \left\{\left(s,j_P\right)\right\}$ = (5,8), we obtain the optimal path (1,4,5,8) as can be seen in Figure 10.

In the followings, we discuss optimality conditions for problem (1) and present an algorithm with a time complexity of $O\left(S\left(m,n\right)\right)$, which improves the complexity of Algorithm $1$ by a factor of $m$.

To begin, we introduce a label $d\left(j\right)$ for each node $j \in V$. During intermediate stages of computation, the label $d\left(j\right)$ serves as an estimate (or an upper bound) of the maximum flow sent from the source node s to node j along a single path. At the termination of the algorithm, the label $d\left(j\right)$ represents the optimal value of problem (1). Our objective is to establish necessary and sufficient conditions for a set of labels to accurately represent the maximum flow.

Let $d\left(j\right)$ denote the value of the maximum flow sent from the source node to node j (where we set $d\left(s\right)=+\infty$). In order for the labels to be optimal, they must satisfy the following necessary optimality conditions:

-

Constraint (1c): For each node $j \ne s$, there exists, at most, one outgoing arc with positive flow. This condition ensures that the flow is sent only along a single $st$-path.

-

Capacity Constraint: For each arc $\left(i,j\right)$, the flow through the arc must not exceed its capacity. Mathematically, this can be written as $f_{ij} \le u_{ij}$, where $f_{ij}$ represents the flow on arc $\left(i,j\right)$ and $u_{ij}$ represents the capacity of arc ($i,j)$.

-

Flow Conservation: The flow conservation principle must be satisfied at every node (except the source and sink nodes). For any node $j \ne s$ and $j \ne t$, the sum of incoming flows must equal the sum of outgoing flows. Mathematically, this can be expressed as ${{\displaystyle \sum }}_{\left(i,j\right)\in A}{f}_{ij}-{{\displaystyle \sum }}_{\left(j,k\right)\in A}{f}_{jk}=0$.

-

Optimality Condition: For each node $j \ne s$, the label $d\left(j\right)$ represents the maximum flow sent from the source node $s$ to node $j$. Therefore, we have $d\left(j\right)={{\displaystyle \sum }}_{\left(i,j\right)\in A}{f}_{ij}-{{\displaystyle \sum }}_{\left(j,k\right)\in A}{f}_{jk} ,$ where $f_{ij}$ represents the flow on arc $\left(i,j\right)$ and $f_{jk}$ represents the flow on arc $\left(j,k\right)$.

By satisfying these necessary optimality conditions, we can ensure that the labels $d\left(j\right)$ accurately represent the maximum flow in the network.

If the labels are optimal, they must satisfy the following necessary optimality conditions:

$$d_j\ge p_{ij}\min \left\{u_{ij},d_i\right\}.$$

This is an extension of the optimality conditions of both the WPP and MRP problem. On the optimal path, the inequality is satisfied in the equality form. It states that the label of node $j$ is either $p_{ij}{d}_i$ or $p_{ij}{u}_{ij}$. In the case that the flow value arriving at node $i$ is less than $u_{ij}$, (namely, $d_i<u_{ij}$), this arc is not saturated and consequently $d_j=p_{ij}{d}_i$. In the other case, $\left(i,j\right)$ is saturated, sending more flow than its capacity. So, $d_j=p_{ij}{u}_{ij}$ in this case.

Since this optimality condition is similar to that of the SP problem, we can apply the concept of Dijkstra’s algorithm to solve problem 1. This is presented in Algorithm 2.

 Theorem 2. 

Algorithm 2 solves the problem in$O\left(n^2\right)$ time.

 Proof of Theorem 2. 

Considering the provided information, we can deduce that in the while loop, each arc is checked only once. As a result, the number of iterations executed by the two last lines of the loop is, at most$, O\left(m\right)$, which is also less than or equal to $O\left(n^2\right)$ considering the worst-case scenario. □

Conversely, the node selection process, where the node with the minimum label is chosen, requires $O\left(n\right)$ time in each iteration. Taking into account that the number of iterations is $O\left(n^2\right)$, we can conclude that the most time-consuming operation in this algorithm is the node selection, which takes $O\left(n^2\right)$ time. Algorithm 2 is derived from Dijkstra’s algorithm by replacing the classical test with $d_j<p_{ij}\min \left\{u_{ij},d_i\right\}$; then, if necessarily, the update $d_j=p_{ij}\min \left\{u_{ij},d_i\right\}$ is performed.

Algorithm 2 (Alg. 2)

Input: An instance of the generalized WPP Output: An optimal path   for $i\in V:$       Set $d\left(i\right)=0$ Set$d_s=+\infty$ Set $S_0=\left\{\right\};$ $\overline{S}=V$ while $\left|S\right|<n$:      Let $i\in S$ be a node for which $d_i=\max \left\{d_j:j\in \overline{S}\right\}$; $\overline{S}=\overline{S}\backslash \left\{i\right\};$         for each $j\in V:\left(i,j\right)\in A$:                    if $d_j<p_{ij}\min \left\{u_{ij},d_i\right\}$:                          Update $d_j=p_{ij}\min \left\{u_{ij},d_i\right\}$                          Update$S=S U \left\{i\right\}$;

We can also use the available implementations of Dijkstra’s algorithm for the complexity improvement of Algorithm 2. For example, the Fibonacci heap implementation reduces the complexity to $O(m+n\log n)$.

• Algorithm 2 iterations:

We will apply Algorithm 2 for the graph from Figure 1. We have the following data structures: d (distance vector), Pred. (predecessor vector), and S (priority queue or a Fibonacci heap, depending on the implementation). It is important to note that all structures are starting from index 1 in this example.

Upon examination of the predecessor vector Pred. represented by [−1, 1, 1, 1, 4, 5, 5, 5], it is obvious that the optimal path is (1, 4, 5, 8). So, both the first and second algorithms yield identical optimal paths (see Figure 10 and

Table 1. Algorithm 2 iterations.

No. itr.	Structure	Structure Data
1	D	[inf, 0, 0, 0, 0, 0, 0, 0]
	S	[1]
	Pred.	[−1, −1, −1, −1, −1, −1, −1, −1]
2	D	[inf, 6.02, 5.84, 8.2, 0, 0, 0, 0]
	S	[2, 3, 4]
	Pred.	[−1, 1, 1, 1, −1, −1, −1, −1]
3	D	[inf, 6.02, 5.84, 8.2, 5.44, 0, 0, 0]
	S	[2, 3, 5]
	Pred.	[−1, 1, 1, 1, 4, −1, −1, −1]
4	D	[inf, 6.02, 5.84, 8.2, 5.44, 0, 0, 0]
	S	[3, 5]
	Pred.	[−1, 1, 1, 1, 4, −1, −1, −1]
5	D	[inf, 6.02, 5.84, 8.2, 5.44, 0, 0, 0]
	S	[5]
	Pred.	[−1, 1, 1, 1, 4, −1, −1, −1]
6	d	[inf, 6.02, 5.84, 8.2, 5.44, 0.9, 1, 2]
	S	[6, 7, 8]
	Pred.	[−1, 1, 1, 1, 4, 5, 5, 5]
7	D	[inf, 6.02, 5.84, 8.2, 5.44, 0.9, 1, 2]
	S	[6, 7]
	Pred.	[−1, 1, 1, 1, 4, 5, 5, 5]
8	D	[inf, 6.02, 5.84, 8.2, 5.44, 0.9, 1, 2]
	S	[6]
	Pred.	[−1, 1, 1, 1, 4, 5, 5, 5]
9	D	[inf, 6.02, 5.84, 8.2, 5.44, 0.9, 1, 2]
	S	[EMPTY]
	Pred.	[−1, 1, 1, 1, 4, 5, 5, 5]

).

5. Gain/Loss Case of the GWPP

Since the GWPP is reduced to a minimum path search problem in a network with non-negative values on arcs (except for the arcs starting with the source node), Dijkstra’s algorithm was adapted for solving the GWPP. The same optimality conditions may apply to problems involving gain factors (leading to arcs with negative values in the modified network). Therefore, Bellman–Ford’s algorithm can be adapted to address the case when the arcs have gain/loss factors. We used the shortest path faster algorithm (SPFA) implementation of Bellman–Ford [17]. The algorithm iteratively relaxes edges in the graph and updates the optimal path estimates until no further updates are possible. This algorithm is described in Algorithm 3. The correctness of Algorithm 3 is akin to that of the well-known Bellman–Ford algorithm (the modifications performed for the classical Bellman–Ford’s algorithm are similar to those conducted for Dijkstra’s algorithm). For a proof, please refer to [4].

Algorithm 3 (Alg. 3)

Input: An instance of the GWPP with gain/loss factors Output: An optimal path   for $i\in V:$       Set$d_{\mathrm{i}}=0, pre{d}_i=-1, S_i=false$ Set $d_{\mathrm{s}}=+\infty$, $Q=\left\{s\right\};$ while Q has elements: $i =pool Q;$  $S_i=false;$        for $\left(i,j\right)\in A$:                 if $d_j<p_{ij}\min \left\{u_{ij},d_i\right\}$:                          Update $d_j=p_{ij}\min \left\{u_{ij},d_i\right\}.$                          Set $pre{d}_j=i.$                          if $S_j==false$: $Q=Q U \left\{j\right\}$; $S_j=true;$ Restore the optimal path by the $Pred$ indices.

• Algorithm 3 iterations:

No. itr.	Selected Edge	Structure	Structure Data
0—init.	-	Q	[1]
		S	[true,false,false,false,false,false,false,false]
		d	[inf, 0, 0, 0, 0, 0, 0, 0]
		Pred.	[−1, −1, −1, −1, −1, −1, −1, −1]
1	(1,2)	Q	[2]
		S	[false,true,false,false,false,false,false,false]
		d	[inf, 6.02, 0, 0, 0, 0, 0, 0]
		Pred.	[−1, 1, −1, −1, −1, −1, −1, −1]
2	(1,3)	Q	[2, 3]
		S	[false,true,true,false,false,false,false,false]
		d	[inf, 6.02, 5.84, 0, 0, 0, 0, 0]
		Pred.	[−1, 1, 1, −1, −1, −1, −1, −1]
3	(1,4)	Q	[2, 3, 4]
		S	[false,true,true,true,false,false,false,false]
		d	[inf, 6.02, 5.84, 8.20, 0, 0, 0, 0]
		Pred.	[−1, 1, 1, 1, −1, −1, −1, −1]
3	(2,3)	Q	[3, 4]
		S	[false,false,true,true,false,false,false,false]
		d, Pred.	No change
4	(2,5)	Q	[3, 4, 5]
		S	[false,false,true,true,true,false,false,false]
		d	[inf, 6.02, 5.84, 8.20, 4.45, 0, 0, 0]
		Pred.	[−1, 1, 1, 1, 2, −1, −1, −1]
5	(3,2)	Q	[4, 5]
		S	[false,false,false,true,true,false,false,false]
		d, Pred.	No change
5	(3,4)	Q, S, d, Pred.	No change
6	(3,5)	Q, S, d, Pred.	No change
7	(4,3)	Q	[5]
		S	[false,false,false,false,true,false,false,false]
		d, Pred.	No change
8	(4,5)	Q, S	No change
		d	[inf, 6.02, 5.84, 8.20, 5.44, 0, 0, 0]
		Pred.	[−1, 1, 1, 1, 4, −1, −1, −1]
9	(5,6)	Q	[6]
		S	[false,false,false,false,false,true,false,false]
		d	[inf, 6.02, 5.84, 8.20, 5.44, 0.90, 0, 0]
		Pred.	[−1, 1, 1, 1, 4, 5, −1, −1]
10	(5,7)	Q	[6, 7]
		S	[false,false,false,false,false,true,true,false]
		d	[inf, 6.02, 5.84, 8.20, 5.44, 0.90, 1.0, 0]
		Pred.	[−1, 1, 1, 1, 4, 5, 5, −1]
11	(5,6)	Q	[6, 7, 8]
		S	[false,false,false,false,false,true,true,true]
		d	[inf, 6.02, 5.84, 8.20, 5.44, 0.90, 1.0, 2.0]
		Pred.	[−1, 1, 1, 1, 4, 5, 5, 5]
12	(6,8)	Q	[7, 8]
		S	[false,false,false,false,false,false,true,true]
		d, Pred.	No change
13	(7,8)	Q	[8]
		S	[false,false,false,false,false,false,false,true]
		d, Pred.	No change
14	(8,-) No neighbors	Q	[EMPTY]
		S	[false,false,false,false,false,false,false,false]
		d, Pred.	No change

The complexity of the algorithm is stated in the following theorem.

 Theorem 3. 

Algorithm 3 solves the GWPP in the presence of loss and gain factors in $O\left(nm\right)$ time.

 Proof of Theorem 3. 

See [4]. □

While Algorithm 3 is less efficient than Algorithm 2, its ability to handle gain factors makes it a valuable tool in the more general case of gain or loss factors attached to the arcs.

6. Experiments and Discussions

Since the problem studied in the paper is new, the (three) algorithms proposed in the paper were compared with each other. The results of the comparison can be seen below.

Based on the findings presented in Theorems 1 and 2, it is obvious that Algorithm 2 outperforms Algorithm 1 in terms of speed. However, Algorithm 1 offers an advantage in that it can be effectively parallelized on GPUs by utilizing classical Dijkstra’s algorithm [18] in a sequential manner. So, the implementation of CUDA-based Dijkstra’s algorithm resulted in a noteworthy acceleration of Algorithm 1.

The CUDA version exhibited significantly improved performance compared to Algorithm 2, as shown in Figure 11. Particularly for larger network instances with 10,000 nodes or more, the CUDA implementation of Algorithm 1 was up to 25.7 times faster than that of Algorithm 2.

As expected, Algorithm 2 is faster than Algorithm 3 (see Figure 12). The experiments were performed on large networks (see

Table 2. Network generator parameters used for experiments.

No. of Nodes	No. of Instances	No. of Paths	No. of Cycles	Erdős–Rényi Prob.	No.
1000	10,000	500	100	0.5	1
		500	100	0.7	2
		500	100	0.9	3
2000	1000	1000	100	0.1	4
		1000	250	0.15	5
		1000	500	0.6	6
5000	100	2500	1000	0.1	7
		2500	1000	0.2	8
		2500	1000	0.3	9
10,000	5	5000	2500	0.15	10
		5000	2500	0.3	11
		5000	2500	0.5	12
15,000	3	7500	1000	0.15	13
20,000	2	7500	1000	0.15	14
25,000	1	8000	1500	0.15	15

). They showed that Algorithm 2 runs up to 1.64 times faster than Algorithm 3 (see

Table 3. Running times (ms) comparison between algorithms.

No.	Algorithm 1 CPU	Algorithm 1 GPU	Algorithm 2	Algorithm 3	Algorithm 1 GPU vs. Algorithm 2 (Times Faster)	Algorithm 2 vs. Algorithm 3 (Times Faster)
1	165.75	187.30	3.98	5.55	0.02	1.39
2	121.1	138.66	5.02	7.52	0.04	1.49
3	188.96	311.78	6.06	9.52	0.02	1.57
4	30.22	52.40	6.86	8.90	0.13	1.29
5	120.00	209.34	23.00	36.18	0.10	1.57
6	193.50	315.60	16.92	27.88	0.05	1.64
7	183.00	71.52	40.15	52.19	0.56	1.29
8	284.30	103.41	41.7	55.00	0.40	1.31
9	626.6	226.74	61.4	76.45	0.27	1.24
10	671.10	89.21	98.01	117.61	1.10	1.19
11	677.14	67.78	216.00	302.40	3.19	1.40
12	940.20	76.15	358.01	466.6	4.70	1.30
13	1306.07	49.41	265.33	424.52	4.82	1.59
14	2965.04	53.48	452.11	524.44	8.46	1.15
15	3549.10	32.11	826.04	966.46	25.72	1.16

The highest differences between algorithms’ running speeds are highlighted in Table 3.

).

We used different instances of random generated networks with the number of nodes varying from 1000 to 25,000 (see Table 1). The networks were generated using the network random generator from [19]. It is imperative to acknowledge that throughout various experimental analyses, the graph’s density played an important role and was calibrated using the Erdős–Rényi probability distribution [20]. The Erdős–Rényi variable, a continuous parameter spanning the interval [0, 1], played a pivotal role in these experimental investigations.

In this context, it is essential to elucidate that the Erdős–Rényi variable assumes a value of 0 when the graph lacks any new arcs, signifying minimal density. Conversely, a value of 1 denotes the graph’s attainment of maximum density, highlighting the comprehensive spectrum of density exploration in our experimental framework.

The experiments were performed using a PC with an Intel(R) Core(TM) i5-6500 CPU @ 3.20 GHz, 24 GB RAM, and an NVIDIA GeForce GTX 1070 TI graphics card. The algorithms were programmed in Visual C++ 2022 under Windows 10.

7. Conclusions

In this paper, a novel combinatorial optimization problem was introduced (GWPP). The main objective is to identify a path that can transmit the maximum flow, taking into account both the capacities and loss/gain factors of the arcs.

The paper presented two strongly polynomial algorithms to address the GWPP in the loss factor case and a third algorithm that can be used to solve the GWPP in the general case of gain/loss factors attached to arcs. The first algorithm has a time complexity of $O\left(mS\left(n,m\right)\right)$, where $S\left(m,n\right)$ represents the time complexity of finding the shortest path in the network. On the other hand, the second algorithm has a more efficient time complexity of $O\left(n^2\right)$. However, when the first algorithm is implemented on GPUs, it performs substantially faster than the second algorithm, especially for large network instances. Algorithm 3 has a worse time complexity of $O\left(mn\right)$ compared to that of Algorithm 2, but Algorithm 3 can deal with the more general case of gain/loss factors. To better understand how each of the three algorithms works, an example was considered, and the iterations of each algorithm were presented.

The same experiments were performed for all three algorithms, and the performance was compared. Algorithm 1 is considerably slower than Algorithm 2, both programmed on a CPU. However, Algorithm 1 can be easily and efficiently implemented on GPUs, and in this case, it outperforms Algorithm 2. As expected, Algorithm 3 is slower than Algorithm 2.