In this paper, we study the Tracking Paths problem, which involves finding a minimum weight set of vertices in a vertex-weighted simple graph that can track moving objects in a network along the way from a source to a target . A set of vertices is a tracking set if for any (simple) - path in the sequence of the subset of vertices from that appear in , in their order along , uniquely identifies the path . That is, if holds for any two distinct - paths and . Formally, the problem is the following.
Tracking Paths Input: Undirected graph with positive integer weights , a source , and a target . Output: A minimum weight tracking set .
In the current age of information, social media networks have an important role in information exchange and dissemination. However, due to the unregulated nature of this exchange, spreading of rumours and fake news pose serious challenges in terms of authenticity of information [ChierichettiLP11, rumour-spreading]. Identifying and studying patterns of rumor spreading in social media poses a lot of challenges due to huge amounts of data in constant movement in large networks [rumour-det]. Tracing the sequence of channels (people, agents, …) through which rumors spread can make it easier to contain the spread of such unwanted messages [rumour-bigdata, rumour-pattern]. A basic approach would require tracing the complete route traversed by each message in the network. Here an optimum tracking set can serve as a resource-efficient solution for tracing the spread of rumors and dissolving them. Furthermore, Tracking Paths finds applications in tracking traffic movement in transport networks and tracing object movement in wireless sensor networks [sensor-tracking, localization].
The graph theoretic version of the problem was introduced by Banik et al. [BanikKPS20], wherein the authors studied the unweighted (i.e., for all ) shortest path variant of the problem, namely Tracking Shortest Paths (i.e., the set is required to uniquely identify each of the shortest - paths). They showed that this problem is NP-hard, even to approximate it within a factor of . They also show that Tracking Shortest Paths admits a -approximation algorithm for planar graphs. Later parameterized complexity of Tracking Paths was studied in [tr-j], where the problem was also proven to be NP-hard.
To the best of our knowledge, Eppstein et al. [ep-planar] were the first to study approximation algorithms for the unweighted Tracking Paths. They gave a -approximation algorithm when the input graph is planar. Recently this result was extended by Goodrich et al. [ep-log] to a -approximation algorithm for -minor free graphs and a -approximation algorithm for general (unweighted) graphs [ep-log]. They also gave a -approximation algorithm for Tracking Paths. The existence of constant factor application algorithm was posed as an open problem by Eppstein et al. [ep-planar]. In this paper we answer this affirmatively.
There is a -approximation algorithm for Tracking Paths in weighted graphs and a -approximation algorithm if the input is unweighted.
There exists an interesting connection between Feedback Vertex Set (FVS) and Tracking Paths. Before we discuss this in more detail, we introduce FVS and its fault tolerant variant. Formally, for a given vertex-weighted graph , FVS requires finding a minimum weight set of vertices , referred to as a feedback vertex set (fvs), such that the graph induced by the vertex set does not have any cycles. FVS is a classical NP-hard problem [Karp72] that has been thoroughly studied in graph theory. An -fault tolerant feedback vertex set (-ftfvs) is a set of vertices that intersect with each cycle in the graph in at least vertices; finding a minimum weight -ftfvs is the -Fault Tolerant Feedback Vertex Set problem [pm-1fvs]. Note that if a graph has a cycle of length less than or equal to , then it cannot have an -ftfvs.
Relation Between Fvs and Tracking Paths.
For a graph with source and destination , if each vertex and edge participates in an - path, then we refer to as a preprocessed graph. It is known that in a preprocessed graph, a tracking set is also a feedback vertex set [tr-j]. Thus, the weight of a minimum feedback vertex set serves as a lower bound for the weight of a tracking set in preprocessed graphs. This lower bound has proven to be helpful in the analysis of Tracking Paths. However, approximating Tracking Paths has been challenging since the size of a tracking set can be arbitrarily larger than that of a minimum fvs.
Further, it is known [iwoca, ep-planar] that in a graph , if a set of vertices contains at least three vertices from each cycle in , then is a tracking set for . Thus, a -fault tolerant feedback vertex set is also a tracking set. In this paper, we borrow inspiration from this concept to derive a polynomial time algorithm to compute an approximate tracking set. In particular, we start with finding an fvs for the input graph , and then identify cycles that need more vertices as trackers additional to the ones selected as feedback vertices.
Observe that a feedback vertex set is indeed a -fault tolerant fvs. Misra [pm-1fvs] gave a -approximation algorithm for the problem of finding a -fault tolerant fvs in unweighted graphs and -approximation algorithm for weighted graphs. In this paper, we give an approximation algorithm for finding an -fault tolerant feedback vertex set, where is a constant. We do this by using the Multicut in Forests problem (see Section 2) as an auxiliary problem. Misra [pm-1fvs] pointed out that the complexity of -Fault Tolerant Feedback Vertex Set is not known for and asked for an approximation algorithm.
There is an -approximation algorithm for -Fault Tolerant Feedback Vertex Set in weighted graphs, where is a constant.
It is worth mentioning that our approach relies on explicit enumeration of certain cycles in the input graph . This can be done in polynomial time if is a constant (see creftypecap 3.2). Thus, it remains open how to approximate the -Fault Tolerant Feedback Vertex Set if depends on the size of the input (e.g., , where is the number of vertices in ).
Motivation for (Fault Tolerant) Fvs.
The FVS problem is motivated by applications in deadlock recovery [GardarinS76, SiberschatzG93]Bar-YehudaGNR98], VLSI design [HudliH94], and other areas. Fault tolerant solutions are crucial to real world applications that are prone to failure of nodes in a network or entities in a system [Parter16]. In the case of FVS, the failure corresponds to not being able to eliminate the node from the network.
There has been a lot of heuristic based work on the problem of tracking moving objects in a network[network-tracking, tracking-info, ZhouM19]. Parameterized complexity of Tracking Shortest Paths and Tracking Paths was studied in [tr-j, tr1-j, BiloGLP20, quad, struct-tp, ep-planar]. Feedback Vertex Set is known to admit a -approximation algorithm which is tight under UGC [BafnaBF99, ChudakGHW98]. The best known parameterized algorithm for FVS runs in time, where is the size of the solution [LiN20]. It is worth noting that Misra [pm-1fvs] uses Multicut in Forests as a subroutine as well. The edge version is known to admit an LP formulation whose matrix is totally unimodular [GolovinNS06] if the family of paths is non-crossing; thus, it is solvable in polynomial time. A related problem is the -Hurdle Multiway Cut for which a factor -approximation algorithm is known (and it is again tight under UGC) [DeanGPW11].
Preliminaries and Notations.
We refer to [diestel] for the standard graph theory terminology. All paths we consider are simple. For a graph , we use to denote its vertex set. For a set we use to denote a graph that results from the deletion of vertex set and the edges incident to . For a weight function , let for denote the sum of respective elements, i.e.,
. An unweighted version of the problem is obtained by assigning all vertices the same weight. In fact, we can also omit the weights in this case. We write vectors in boldface and their entries in normal font, i.e.,is the third entry of a vector . If we apply minimum to two vectors, then it is applied entry-wise. We write for the vector of ones; we omit the superscript if the dimension is clear from the context.
2 Vertex Multicut in Forests
In this section, we gather polynomial time (approximation) algorithms for solving Vertex Multicut in Forests. The algorithms are used later in the subsequent sections to derive the approximation algorithms for -Fault Tolerant FVS and Tracking Paths.
Multicut in Forests (MCF) Input: A forest , weight function , terminal pairs . Output: A minimum weight set of vertices such that in the graph there is no path between and for .
In this work, we consider the Unrestricted version of Multicut in Forests i.e., a solution set is allowed to contain vertices from the terminal pairs. We will consider a set of paths instead of a set of terminal pairs. It is not hard to see that these two versions are equivalent on forests; if the terminals in a pair belong to different trees we can discard the pair since there does not exist any path between them, otherwise there exists a unique path between each pair of terminals, which the solution should intersect.
While MCF is NP-hard [CalinescuFR03], the unweighted version is polynomial time solvable [CalinescuFR03, GuoHKNU08]. However, recently the following strong version of constant factor approximability of the problem was shown (in fact, the result holds for all chordal graphs, not just for forests).
Consider the natural ILP formulation of the problem, where we introduce a binary variablefor each vertex describing, whether the corresponding vertex should or should not be taken into a solution. At least one vertex must be taken from each path from to make a feasible solution. Consider the following LP relaxation of the natural ILP.
Proposition 1 (Agrawal et al. [AgrawalLMSZ20, Lemma 5.1])
For a given instance of Multicut in Forests one can find a solution such that in polynomial time, where is the objective value of an optimal solution to the corresponding (LP).
We also need the following result of similar nature for unweighted forests, strenghtening the polynomial time solvability of the problem.
If all the weights are equal, then there is an integral optimal solution for (LP). Furthermore, such a solution can be found in polynomial time.
It is enough to show the lemma for each tree of separately.
Root the tree in . Among all optimal solutions to the LP, consider the solution that minimizes .
Assume, for the sake of contradiction that is not integral. Let be a vertex with and the maximum distance from the root . Note that, in particular, for all descendants of it holds that . Let us first assume that and let be the parent of . We define as
We claim that is a solution to (LP). Obviously, for every . Let . If , then . If , then either the path is fully contained in the subtree of rooted in , or . In the first case, we have . Since all the summands on the left hand side are integral by the choice of , it follows that . In the later case, if , then and otherwise .
Hence, is a solution to (LP). Furthermore, we have that (since all the weights are equal) and which is a contradiction. The case can be proved using a similar argument for such that and if .
The second part of the lemma follows from polynomial time algorithm for MCF [CalinescuFR03], since any optimal solution to the instance of MCF represents an optimal solution for the corresponding (LP) by the first part of the lemma.
3 Approximate -Fault Tolerant Feedback Vertex Set
In this section, we give an algorithm for computing an approximate -fault tolerant feedback vertex set for undirected weighted graphs, for any fixed integer . Recall that an -fault tolerant feedback vertex set is a set of vertices that contains at least vertices from each cycle in the graph. A polynomial time algorithm for computing a constant factor approximate -fault tolerant feedback vertex set was given by Misra [pm-1fvs]. The factor can be easily observed to be , where is the best possible approximation ratio for MCF. We start in Section 3.2 by giving an algorithm for finding -fault tolerant feedback vertex set. Later, in Section 3.3, we show how this technique can be generalized to give an -fault tolerant feedback vertex set for any .
3.1 Hardness of -Fault Tolerant Feedback Vertex Set
For any fixed , it is NP-hard to decide whether for a given graph and an integer , contains an -fault tolerant feedback vertex set of size at most .
The case of is equivalent to finding a feedback vertex set of size at most , which is a well known NP-complete problem [karp1972reducibility]. The case of was shown by Misra [pm-1fvs]. We extend his approach for .
We will show a reduction from Vertex Cover, which is a well known NP-complete problem [karp1972reducibility]. Let be an instance of Vertex Cover and let be a graph constructed from in the following way. First replace every edge of by a path with vertices . Additionally create two paths on vertices: on and on . We add edges , , , . Finally add a cycle with new vertices and connect to every vertex originally in . Two examples for a single edge can be seen in Figure 1.
If has vertices and edges, then this process creates new vertices and new edges. As is fixed, the total size of the construction is bounded by , therefore is polynomial in the size of the input and clearly can be constructed in linear time.
Let . We will now show that every cycle in has size at least and therefore the instance of -Fault Tolerant Feedback Vertex Set is not a trivial NO-instance.
Let be the set of vertices added to . We will first consider cycles with vertices only in . Let be such a cycle. Either is or there exists such that contains only vertices of . The second case leads to only two possible cycles. The first cycle consists of vertices , the other one consists of vertices . The first cycle has size , the other one .
Let us now consider all cycles containing some vertex from and excluding . Let , then as there must exist a cycle in such that . Also note that in , the distance between any two vertices such that is exactly . Therefore the length of is at least .
Now any other cycle containing and some vertex in must contain at least two vertices from , therefore the size of is at least . Therefore every cycle in has size at least .
We now show that has a vertex cover of size at most if and only if has an -fault tolerant feedback vertex set of size at most . Suppose that is a vertex cover of of size . Then we show that is an -fault tolerant feedback vertex set on . Note that .
Every cycle with vertices only in has size exactly and all its vertices are in . Let us then consider all cycles which exclude vertex and contain a vertex in . Let be such a cycle. As shown above, such must contain at least vertices from and therefore has at least in .
Now any other cycle contains a vertex in and . Let be such a cycle. If contains at least three vertices from , then there are at least vertices in and . Suppose then that contains exactly two vertices from , say and . Then there are at least vertices of in . As there is and is a vertex cover of , at least one of and must be in and therefore .
Now let us show that if has an -fault tolerant feedback vertex set of size at most , then there is a vertex cover of size at most on . Let be an -fault tolerant feedback vertex set of size at most . Consider any cycle on vertices only in . Each such cycle has size exactly and therefore all of its vertices must be in . Also every vertex in is on a cycle with vertices only in , therefore . We will show that is a vertex cover of size at most . It holds , therefore .
Suppose that is not a vertex cover. Then there is some edge such that . But then consider the cycle of size consisting of and . It follows that , which contradicts the assumption that is -fault tolerant.
3.2 Two-Fault Tolerant Fvs
-Fault Tolerant Feedback Vertex Set Input: Undirected graph and a weight function . Output: A minimum weight set of vertices such that for each cycle in , it holds that .
Let be the input graph. First, we compute a -approximate -fault tolerant feedback vertex set for using the algorithm of Misra [pm-1fvs]. Note that contains at least two vertices from each cycle in . Our goal is to compute a vertex set that contains at least three vertices from each cycle in . Hence, for each cycle in for which , we need to pick at least one more vertex from into our solution. We first identify, which pairs of vertices from are involved in such cycles. This can be done in polynomial time, by considering each pair of vertices and checking the graph for cycles. If no such contains a cycle, then we return as a -fault tolerant feedback vertex set. Otherwise, there exists at least one cycle in such that contains exactly two vertices from it. Observe that even though does not contain three vertices from each cycle in , might contain at least three vertices from some cycles in . We shall ignore such cycles.
If a cycle in intersects with at vertices and , then there exist two vertex-disjoint paths and between and in , such that . In order to find a -fault tolerant fvs that extends , we need to ensure that at least one vertex from is included in the solution. As each pair of paths is uniquely determined by the neighbors of and on and , there are at most such pairs in total and all of them can be found in time. We create a family of all such pairs of vertex disjoint paths between each pair of vertices in . More precisely, for each pair of such paths of length at least we obtain and by removing and from and , respectively. Then we add the pair to . If and are adjacent, then for each --path of length at least in we add to the pair , where is obtained from by removing and .
Next, we use the following linear program to identify which path among each pair should be selected, from which a vertex would be picked in order to be included in the solution.
We solve the above linear program in polynomial time using the Ellipsoid method [GrotschelLS81] (see also [GLS1988, Chapter 3]). Let be an optimal solution for the above LP and be its value.
Let be a -fault tolerant fvs in (not necessarily extending ) and let be the optimum value of (LP). Then, .
We claim that the vector defined for as
constitutes a solution to (LP). In order to see this let be a pair of paths and let be the cycle formed by these paths together with some . Since is a -fault tolerant fvs, we have and thus as needed. Hence, .
Next, we create a set of paths . For each path , we include in if holds. Through this process, we are selecting the paths from which we will include at least one vertex in our solution.
Finally, we create an instance of Multicut in Forests. Consider the corresponding LP relaxation.
Recall that we have for every path , by the definition of . Thus, we have for all and clearly for all . We conclude that is a solution to (LP).
We now show how to combine the -approximate -fault tolerant fvs with an approximate solution for Multicut in Forests to obtain a -approximate -fault tolerant fvs.
Let be an -approximate -fault tolerant fvs and let be an integral solution to (LP) of weight at most times the weight of an optimal solution. Then, is an -approximate -fault tolerant fvs.
It is not hard to see that is a -fault tolerant fvs. Indeed, if contains at least three vertices in a cycle of the input graph, so does . Thus, we can focus on a cycle with . If this is the case, then the conditions of (LP) imply that in it holds for some (follows from the construction of (LP)). Therefore, we have .
There is a -approximation algorithm for unweighted -Fault Tolerant FVS and -approximation algorithm for weighted -Fault Tolerant FVS.
We begin with the -approximation algorithm for -Fault Tolerant FVS by Misra [pm-1fvs]. In polynomial time we construct (LP) and obtain an optimal solution for it. Based on that we construct and (LP) in polynomial time. By Proposition 1 or Lemma 1 one can in polynomial time find an integral solution to (LP) of weight at most times the weight of an optimal solution. By Lemma 4 this solution combined with the initial -fault tolerant fvs gives -approximate -fault tolerant fvs. The algorithm works in polynomial time as it uses polynomial-time routines.
3.3 Higher Fault Tolerant fvs
Now we explain the procedure to scale up the algorithm from Section 3.2 to compute an -fault tolerant fvs for .
-Fault Tolerant Feedback Vertex Set Input: Undirected graph , weight function . Output: A minimum weight set of vertices such that for each cycle in , it holds that .
For the rest of the section we assume that is a fixed constant. We follow a recursive process to compute an -fault tolerant fvs. We start with an approximate solution for -Fault Tolerant FVS. Note that contains at least vertices from each cycle in . Similar to the process in algorithm in Section 3.2, here we identify every group of vertices that are involved in a cycle in , such that . Such cycles can be found by checking whether the graph , for such that , contains a cycle. If no such contains a cycle, then is an -fault tolerant fvs, and we return it as a solution. Else, we focus on cycles which contain exactly vertices from .
We create a family of path sets in the following way. For each cycle that contains exactly vertices of , labeled in cyclic order along as vertices , we consider the paths, say , where starts in and ends in (modulo ) and is a subpath of . We remove paths with only two vertices, and we shorten the rest by removing their end vertices, leaving us with paths , where (as some paths may have been removed). If the set of paths is non-empty, then we add it to the family . If the set is empty, then we have found a cycle of length and we report that there is no -fault tolerant feedback vertex set for as we cannot choose at least vertices on a cycle of length .
Construction of can be done in time.
There are no more than subsets of of order . Each such subset can be a part of many different cycles. To find all such cycles we take each of its orderings and we fix a predecessor and a successor (taken out of the respective vertex neighborhood) of each . This constitutes at most different possibilities for each ordering of . There is at most one path from the successor of to the predecessor of (modulo ) in as it is a forest. As the paths are now fixed, we just need to check whether they form a cycle by checking that the paths are vertex disjoint, which can be done in polynomial time. Altogether, we have time.
Once the family is computed, we solve the following linear program using the Ellipsoid method in polynomial time. Let be its optimal solution and its value.
Similarly to creftypecap 3.1 we get the following.
Let be an -fault tolerant fvs in and let be the optimum value of (LP). Then, .
Next, we create a set of paths . For each path , we include in if . As in Section 3.2, we create an instance of Multicut in Forests and consider its LP relaxation (LP).
Let be an -fault tolerant fvs. Let be an optimal solution of (LP) and let be its objective value. Then, is a solution to (LP) for . In particular, holds, where is the value of an optimal solution to (LP).
Recall that we have for each path . Thus, we have for all and clearly for all . We conclude that is a solution to (LP).
Let be a constant. Let be an -approximate -fault tolerant fvs and let be a solution to (LP) induced by with weight at most times the optimal. Then, is an -approximate -fault tolerant fvs.
Let us prove that is -fault tolerant. If contains at least vertices in a cycle of the input graph, so does . Thus, we can focus on a cycle with . If this is the case, then the conditions of (LP) imply that in it holds for some (follows from the construction of (LP)). Therefore, we have for every such . Hence, is an -fault tolerant fvs.
Theorem 3.4 (precise version of Theorem 1.2)
Let be a constant. There is a -approximation algorithm for -Fault Tolerant Feedback Vertex Set.
The -Fault Tolerant FVS problem has a -approximation algorithm due to Misra [pm-1fvs]. By Lemma 6 we add to the approximation factor when devising -fault tolerant fvs from -fault tolerant fvs it follows that for an arbitrary we have -approximation algorithm for finding an -fault tolerant fvs.
The algorithm by Misra [pm-1fvs] gives the -approximation for -Fault Tolerant FVS in polynomial time. We showed how to devise an -fault tolerant fvs from an -fault tolerant fvs. We use such steps to incrementally increase the fault tolerance of the fvs. In step of devising -fault tolerant fvs we use time to find as seen in Observation 3.2, then we construct and solve (LP) in polynomial time using the Ellipsoid method and then construct (LP) and solve it using either Proposition 1 or Lemma 1 in polynomial time. As is a constant we conclude that our -approximation algorithm for -Fault Tolerant FVS has polynomial time complexity.
4 Approximate Tracking Set
In this section, we give a constant factor approximation algorithm for Tracking Paths.
Let be the input graph and and the source and the target. We start by applying the following reduction rule on . This can clearly be done in polynomial time.
Reduction Rule 1 (Banik et al. [tr-j])
If there exists a vertex or an edge that does not participate in any - path, then delete it.
We use the term reduced graph to denote a graph that has been preprocessed using Reduction Rule 1. For the sake of simplicity, after the application of reduction rule, we continue to refer to the reduced graph as .
Next, we describe local source-destination pair (local - pair), a concept that has served as crucial for developing efficient algorithms for Tracking Paths [tr-j, iwoca, struct-tp, ep-planar]. For a subgraph , and vertices , we say that is a local - pair for if
there exists a path in from to , say ,
there exists a path in from to , say ,
Note that a subgraph can have more than one local source-destination pair. It can be verified in time whether a pair of vertices form a local source-destination pair for by checking if there exist disjoint paths from to and to in the graph , using the disjoint path algorithm from [KAWARABAYASHI2012424].
Let be a graph and let be a subgraph of . We can verify in polynomial time whether is a local - pair for .
We recall the following lemma from previous work.
Lemma 7 ([iwoca, Lemma 2])
In a graph , if is not a tracking set for , then there exist two - paths with the same sequence of trackers, and they form a cycle in , such that has a local source and a local destination , and .
Eppstein et al. [ep-planar] mentioned that a -fault tolerant feedback vertex set is always a tracking set. Here we use a variation of this idea to compute an approximate tracking set. Specifically, we start with a -approximate feedback vertex set and then identify the cycles that contain only one or two feedback vertices. We check if these cycles need more vertices as trackers and we use (LP) and (LP) explained in the previous section to add them.
Now we present the algorithm for computing a -approximate tracking set in polynomial time. We start by computing a -approximate feedback vertex set on the reduced graph using the algorithm by Bafna et al. [BafnaBF99]. We first check whether is a tracking set for by using the tracking set verification algorithm given in [tr-j]. If it is a tracking set, we return as the solution, otherwise we proceed further.
If is not a tracking set, we will find vertices on which to place additional trackers in the following way. First we identify cycles such that . Each such cycle can be obtained by taking a vertex together with a path between a pair of its neighbors in . For each vertex we check, whether (or ) is a local - pair for . If this is the case, then we distinguish two cases. If and are adjacent on , then let be the path . We add to the pair . If and are non-adjacent on , then let and be the two paths between and forming the cycle . We obtain and by removing and from and , respectively. Then we add the pair to .
If a cycle in intersects with in vertices and , then there exist two vertex-disjoint paths and between and , such that . Hence, each such cycle is uniquely determined by the neighbors of and on and . If, furthermore, (or ) is a local - pair for , then we add some pair to . In particular, if both are of length at least we obtain and by removing and from and , respectively. Then we add the pair to . If one of the paths, say , is of length (i.e., and are adjacent on ), we add to the pair , where is obtained from by removing and .
Similarly to creftypecap 3.2, we have at most candidate cycles with a single vertex of and for each of them we have at most candidates on . We have cycles with two vertices of . For each of them, we check, whether (or ) is a local - pair in time. Hence, can be obtained in time.
Now we use (LP) with to identify the paths on which we want to place at least one additional tracker. Let be an optimal solution of (LP), which can be obtained in polynomial time using the Ellipsoid method. We construct as the set of all paths such that .
We first show the following observation.
Let be a reduced graph and be a tracking set for . Let be the optimum value of (LP). Then .
Let be a vector such that for all
We show that is a solution to (LP). Suppose that for some , therefore . Let be the vertices such that contains a cycle , such that are a local - pair for . Such must exist because of the way was constructed.
Since is a local - pair, there exist two distinct paths and