Covering a tree with rooted subtrees

We consider the multiple traveling salesman problem on a weighted tree. In this problem there are m salesmen located at the root initially. Each of them will visit a subset of vertices and return to the root. The goal is to assign a tour to every salesman such that every vertex is visited and the longest tour among all salesmen is minimized. The problem is equivalent to the subtree cover problem, in which we cover a tree with rooted subtrees such that the weight of the maximum weighted subtree is minimized. The classical machine scheduling problem can be viewed as a special case of our problem when the given tree is a star. We observe that, the problem remains NP-hard even if tree height and edge weight are constant, and present an FPT algorithm for this problem parameterized by the largest tour length. To achieve the FPT algorithm, we show a more general result. We prove that, integer linear programming that has a tree-fold structure is in FPT, which extends the FPT result for the n-fold integer programming by Hemmecke, Onn and Romanchuk.

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

07/18/2019

A Constant Factor Approximation for Capacitated Min-Max Tree Cover

Given a graph G=(V,E) with non-negative real edge lengths and an integer...
04/20/2020

Parameterized Study of Steiner Tree on Unit Disk Graphs

We study the Steiner Tree problem on unit disk graphs. Given a n vertex ...
04/22/2021

On the fixed-parameter tractability of the partial vertex cover problem with a matching constraint in edge-weighted bipartite graphs

In the classical partial vertex cover problem, we are given a graph G an...
03/24/2020

Parameterized Algorithms for Red-Blue Weighted Vertex Cover on Trees

Weighted Vertex Cover is a variation of an extensively studied NP-comple...
12/26/2017

Folding Polyominoes into (Poly)Cubes

We study the problem of folding a polyomino P into a polycube Q, allowin...
10/25/2017

Cross-identification of stellar catalogs with multiple stars: Complexity and Resolution

In this work, I present an optimization problem which consists of assign...
09/28/2017

Energy Constrained Depth First Search

Depth first search is a natural algorithmic technique for constructing a...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

We consider the multiple traveling salesmen problem on a given tree . In this problem there is a root where all the salesmen are initially located. There is a weight associated with each edge , which is the time consumed by a salesman if he passes this edge. Each salesman starts at , travels a subset of the vertices and returns to . The goal is to determine the tours traveled by each salesman such that every vertex is visited by some salesman, and the makespan, i.e., the time when the last salesman returns to , is minimized.

We observe that the tour of every salesman is actually a subtree rooted at , and the total traveling time of each salesman is exactly twice the total weight of edges in the subtree. Therefore the problem is equivalent as the minmax subtree cover problem, where we aim to find subtrees for such that , and is minimized, where . We call as the weight of the subtree and the makespan.

The subtree cover problem is a fundamental problem in computer science and has received many studies in the literature. Indeed, when the given graph is a star, the problem is equivalent to the identical machine scheduling problem , where the goal is to assign a set of jobs of processing times onto identical parallel machines such the largest load among machines is minimized. We may view each job as an edge of weight in a star graph, whereas falls exactly into the problem of covering a star with stars. In 2013, Mnich and Wiese [14] provided an FPT (fixed parameter tractable) algorithm parameterized by the largest job processing time .

The problem becomes much more complicated when the given graph is a tree. There exist some approximation algorithms for the problme, e.g., Xu et al. [17] showed that there exists an FPTAS when the number of subtrees, , is a constant. However, we are not aware of a paramerized algorithm for this problem.

Our contribution. Our main contribution is to show that the subtree cover problem admits a fixed parameter tractable (FPT) algorithm (parameterized by the makespan). More precisely, we prove the following theorem.

Theorem 1.

For some computable function , there exists an FPT algorithm of running time for determining whether there exists a feasible solution for the subtree cover problem of makespan .

We remark that, despite the fact that the special case of covering a star admits an FPT algorithm parameterized by the largest edge weight, we show in this paper that the subtree cover problem remains NP-hard even if the tree is of height 2 and every edge has a unit weight. Therefore, we restrict our attention to the larger parameter .

Indeed, our FPT algorithm relies on an FPT algorithm for a more general integer programming problem, which extends the existing FPT algorithm for the -fold integer programming [4]. We consider the following integer programming:

(1)

In the -fold integer programming, the matrix consists of small matrices and as follows (Here is an -matrix and is an -matrix).

More precisely, the matrix consists of one row of and a submatrix with being at the main diagonal. We remark that throughout this paper s that appear in a matrix refer to a submatrix consisting of the natural number .

The -fold integer programming has received many studies in the literature. Indeed, the natural ILP formulation of the scheduling and bin packing problem falls into an -fold integer programming, as is observed by Knop and Koutecký [11]. In 2013, Hemmecke, Onn and Romanchuk presented an FPT algorithm for -fold integer programming with the running time of where is some computable function, is the largest absolute value among all entries of and is the encoding length of the problem. This algorithm implies an FPT algorithm parameterized by the largest job processing time for and many other scheduling problems [11]. We further extend their result by considering a broader class of integer programming, namely tree-fold integer programming as we describe as follows.

The structure of an -fold matrix could be viewed as a star with the root representing the row of and each leaf representing one of the rows . More precisely, we can view each row as a vertex such that vertex is a parent of vertex if row dominates row , where by saying row dominates row , we mean row is more ”sparse” than row

as a vector, i.e., if the

-th coordinate of row is non-zero, then the -th coordinate of row is also non-zero. Using this interpretation, we can generalize an -fold matrix to a tree-fold matrix. The following is an example.

A tree-representation of the matrix above is:

In general, a tree-fold matrix consists of copies of small matrices , , , with being an -matrix. Every row consists of ’s and some ’s in the form of (i.e., appears consecutively). Every column consists of ’s and exactly one copy of each . Furthermore, if we call a row containing as an -row, then any -row is dominated by some -row, that is, if at a certain row appears consecutively from column to column , then there exists some -row such that appears consecutively from to such that . Representing the matrix as a tree, every row is represented as a vertex and the vertex corresponding to each -row will be the parent of the vertex corresponding to -row it dominates.

To facilitate the analysis, we further require that the -row contains no and every -row contains exactly one copy of , that is, all rows containing form a sub-matrix with being at the diagonal. Note that this assumption causes no loss of generality: If it is not the case, we can always add a set of dummy constraints: , whereas and become a -dummy matrix consisting of .

We define ILP (1) with being a tree-fold matrix as a tree-fold integer programming and establish the following FPT result.

Theorem 2.

For some computable function , there exists an FPT algorithm of running time for a tree-fold integer programming, where is the largest absolute value among all entries of , and is the length of the binary encoding of the vector .

Note that , thus the FPT term only depends on the small matrices and does not rely on the structure of . We also remark that, by introducing slack variables for inequalities, our theorem also holds for the integer programming: .

Related work. As we have mentioned, the problem of covering a star with stars is exactly the identical machine scheduling problem . Approximation schemes are studied in a series of prior papers, see, e.g., [1, 16, 6, 9, 10]. In terms of FPT algorithms, Mnich and Wiese [14] showed that is FPT parameterized by the largest job processing time (edge weight). Very recently, Knop and Koutecký [11] observes the relationship between the scheduling problem and -fold integer programming in terms of FPT algorithms. Indeed, they show that a variety of scheduling problems, including , could be formulated as an -fold integer programming. Applying the FPT algorithm for -fold integer programming by Hemmecke, Onn and Romanchuk [4], an FPT algorithm for follows. It is worth mentioning that parameterized studies for integer programming that has a sparse structure have received much attention in the literature, e.g., [8, 12].

Covering a tree with subtrees is much more complicated. In 2013, Xu et al. [17] showed that if the number of subtrees, , is a constant, then the problem admits a pseudo-polynomial time exact algorithm and an FPTAS. We are not aware of FPT algorithms for this problem.

2 The FPT algorithm

In this section, we show that the subtree cover problem is FPT parameterized by the makespan. Towards this, we formulate the problem as an ILP. We observe that the ILP we establish has a special structure, which generalizes the -fold integer programming studied in the literature. We call it as a tree-fold integer programming. Indeed, when the input tree is a star, the tree-fold integer program we formulate becomes an -fold integer program. We extend the FPT algorithm for the -fold integer programming to derive an FPT algorithm for the tree-fold integer programming, which implies an FPT algorithm for the subtree cover problem. This result may be of separate interest.

Recall that when the given graph is a star, the subtree cover problem becomes FPT parameterized by the largest edge weight  [14]. However, this is no longer true even if the given graph is a tree of height , as is implied by the following theorem.

Theorem 3.

The subtree cover problem remains NP-hard even if the given tree is of height and every edge has unit weight.

The above hardness result excludes FPT algorithms parameterized by edge weight and tree height, and therefore we restrict our attention to makespan. We will first show that a tree-fold integer programming can be solved in FPT time. Then we establish a configuration ILP for the subtree cover problem and prove that the ILP falls exactly into the category of tree-fold integer programming, and is thus solvable in FPT time.

2.1 Tree-fold integer programming

The goal of this and next subsection is to prove Theorem 2. Towards this, we first introduce some basic concepts and techniques which are crucial for our proof. Here we only give a very brief introduction and the reader may refer to Appendix A.2 for details.

We consider the following integer programming with being a tree-fold matrix consisting of copies of -matrix , where .

(2)

Any vector can be written into ”bricks” in the form of where . Using the standard technique, we can prove that if we have an algorithm for a tree-fold ILP such that given a feasible initial solution, it can augment it into an optimal solution, then by using this algorithm as a subroutine we can also solve the tree-fold ILP without knowing the initial solution (see Appendix A.5). Therefore, it suffices to focus on the ”augmenting” algorithm. It is easy to see that all the vectors that can be used to augment a feasible solution to should satisfy that . It is shown by Graver [3] that instead of considering all the , it suffices to consider a subset , which is called Graver basis. Hemmecke, Onn and Weismantel [5] proved that, starting from an arbitrary feasible solution , the optimal solution could be achieved by iteratively applying the best augmentation via Graver basis, i.e., augmenting by using the best possible augmentation vector of the form , where and . The total number of augmentation steps needed is bounded by , where is the length of the binary encoding of the vector 111It should be noted that the best augmentation via Graver basis needs not be the best augmentation (i.e., there may exist such that is better than any .. This statement remains true if, instead of choosing the best possible augmentation vector of the form , say, , we choose an augmentation vector which is at least as good as in every augmentation step. That is, if in each augmentation step we choose an augmentation vector such that , then the optimal solution could also be achieved after augmentation vectors [4, 2]. Notice that does not necessarily belong to . Such an augmentation is called a Graver-best augmentation and such greedy algorithm is called Graver-best augmentation algorithm.

As we have described above, the problem of solving a tree-fold integer programming reduces to the problem that, given a feasible solution, finding an augmentation vector that is at least as good as the best augmentation via Graver basis. Towards this, it is crucial to understand the structure of the Graver basis for . The following lemma provides such structural information and is crucial to our algorithm.

Lemma 1.

Let . There exists some integer that only depends on matrices , , , and

such that for any we have for any .

Here means is a tree-fold matrix consisting of , , . Roughly speaking, Lemma 1 states that for any Graver basis element of the matrix , although it is of a very high dimension, it is sparse, i.e., among the bricks , only an “FPT”  number of them can be nonzero. This lemma extends the structural lemma for -fold integer programming in [4], which can be viewed as the case when . The proof of Lemma 1 is involved and is deferred to Appendix A.3.

2.2 Dynamic programming in FPT time

We provide a dynamic programming algorithm running in FPT algorithm for the tree-fold integer programming, and Theorem 2 follows. Towards this, we let and be defined as in Lemma 1.

Given a feasible solution of the integer programming (2), let , satisfy that is the best augmentation among Graver basis, i.e., the best possible augmentation vector of the form where and . The following lemma from [4] allows us to guess in time:

Lemma 2 ([4]).

In time we can compute a set of integers such that and .

The proof in [4] is for the case when , however, it works directly for the general tree-fold matrices. For the completeness of the paper we give the proof in Appendix A.4.

In the following we give a dynamic programming algorithm such that given a feasible solution and any , it finds out that minimizes , or equivalently, minimizes subject to the constraints that and . With such an algorithm, we can run it for every and pick such that is minimal. By the definition of , is at least as good as the best augmentation via Graver basis and is thus the Graver-best augmentation that we desire.

The dynamic programming works in stages where in each stage it solves a subproblem. To define the subproblem, we define a matrix as follows. Consider any small matrix and all the rows in that contain . Suppose appears consecutively in these rows from column to column , from column to column , , from column to column . We define where each row of is the summation of some rows in . More precisely, contains the same number of rows as . If in the -th row of some small matrix appears consecutively from column to column , then in the -th row of the small matrix appears consecutively from to , that is, we construct by extending the sequence of in each row of to column . It is obvious that if and only if .

Let be all the rows in . Let be the set of rows where only the first columns are non-zero. Obviously . Let and . According to Lemma 1, , and hence for any , is only dependent on the submatrices . We define subproblem- as follows:

For every where , find some such that

  • for , that is, only the first bricks can be non-zero.

  • .

  • for .

  • for any .

  • ,

  • is minimized.

It is easy to see that the optimal solution for the subproblem- can be constructed by extending the optimal solution for the subproblem- by one brick, and such a brick belongs to . Therefore, the optimal solution for subproblem- can be found in time, where the big-O hides a coefficient that only depends on .

The overall running time. We have shown in this subsection that the dynamic programming algorithm can find out a Graver best augmentation in time (ignoring all the FPT-terms). By [5] the number of Graver best augmentations needed is where is the encoding length of the integer programming, therefore tree-fold integer programming can be solved in time, and Theorem 2 is proved (if a feasible initial solution is given).

2.3 Subtree cover–integer programming formulation

The goal of this subsection is to derive an ILP formulation of the subtree cover problem which falls into the category of tree-fold integer programming. Given this result, applying Theorem 2, Theorem 1 is proved.

For ease of description, we let the root . We define the unweighted distance between two vertices as the length the path connecting them in the same tree with all edge weights as . The depth of any vertex is the unweighted distance of to .

Preprocessing. We consider the decision version of the problem which asks whether there exists a subtree cover of makespan . We assume without loss of generality that the height of the tree, , is at most , since otherwise we can conclude directly that there is no feasible solution of makespan at most . For ease of presentation, we modify the problem in the following way. For any leaf whose depth is , we append a path to it which consists of dummy vertices and dummy edges of weight. By doing so every leaf of has a depth of . Next, we direct all the edges towards the root and move the weight of each edge to its source vertex. Specifically, the weight of the root is . Now the weight of any subtree is simply the total weight of its vertices. For simplicity, we still denote the modified tree as and denote by the number of its vertices.

Configurations. We define configurations. Any tree with at most vertices whose weight is bounded by can be encoded via an -vector as follows: We index all vertices from to . For every vertex, we store its weight and its parent. We call such an -vector as a configuration and have the following simple observation.

Observation 1.

There are at most different kinds of configurations.

We index configurations arbitrarily as and denote by the number of vertices in . Given an arbitrary configuration , we use to denote its vertex of index . is also called the location of this vertex. Let be the maximal number of vertices among all the configurations. A pair with is called invalid. For simplicity, is always the index (location) of the root for every .

Given a configuration , we define a function which maps a vertex of location to the location of its parent (it shall be noted that here the function has nothing to do with the function in Theorem 2).

Now we revisit the subtree cover problem using the notion of configurations. Consider an arbitrary subtree of rooted at whose weight is at most . We first observe that there are at most vertices in the subtree. To see why, we can first consider a subtree of weight at most in the original tree before preprocessing. Since every vertex, except the root, has non-zero weight, the number of vertices is bounded by . As the preprocessing procedure will append at most vertices below a vertex, the total number of vertices is thus bounded by . Hence, any subtree of weight at most can be mapped to a configuration. Furthermore, any feasible solution can be interpreted as subtrees that can be mapped to configurations. Using this idea, we now establish an ILP formulation of the problem.

We define an integral variable for every vertex and every pair . For , implies that there are subtrees in the solution which contain , and furthermore, each of them can be mapped to the configuration such that is mapped to the location vertex in .

Obviously, can not be mapped to an arbitrary vertex in . We say a vertex is consistent with the pair , if both of the following conditions are true:

  • the depth of in is the same as the depth of the location vertex in ;

  • the weight of in is the same as the weight of the location vertex in .

Otherwise, we say they are inconsistent.

Let be the set of children of , be the set of leaves. We establish the following for the subtree cover problem:

Constraint ensures that every leaf is contained in one of the subtrees. Constraints and are straightforward. We now explain constraint . Consider any feasible solution and let be an arbitrary vertex. Let be any child of . If is mapped to the vertex of location in , then must be mapped to the vertex of location in . Therefore, if we consider the total number of configuration where a child of is mapped to its vertex of location , this should be equal to the number of configuration where is mapped to its vertex of location . This is essentially what constraint implies.

The following two lemmas ensures that the we have derived indeed solves the subtree cover problem. One direction (Lemma 3) is staightforward, yet the other direction is a bit involved and the reader is referred to Appendix A.6 for details.

Lemma 3.

If there exists a feasible solution of the scheduling problem with makespan at most , then there exists a feasible solution of the ILP with the objective value at most .

Lemma 4.

If there exists a feasible solution of the ILP with the objective value at most , then there exists a feasible solution of the subtree cover problem with makespan at most .

Still, is similar but not exactly the same as a tree-fold integer programming. We need to tune the ILP a bit. The tuning is essentially by replacing some of the variables with the equation in it satisfies, i.e., we will remove some of the variables. See Appendix A.7 for details. Once transformed into a tree-fold integer programming, Theorem 2 can be applied and Theorem 1 is proved.

3 Conclusion

We consider the subtree cover problem in this paper and provide an FPT algorithm parameterized by the makespan. Our FPT algorithm follows from a more general FPT result on the tree-fold integer programming, which extends the existing FPT algorithm on the -fold integer programming. The running times of the FPT algorithms is huge and is only of theoretical interest. Another important open problem is whether we can derive FPT algorithm for integer programming with the matrix that has an even more general structure. It is also interesting to consider approximation schemes for the subtree cover problem.

Appendix A Proofs Omitted in Section 2

a.1 Proof of Theorem 3

Proof of Theorem 3.

We reduce from -partition. In the -partition problem, given is a set of integers with , where . The goal is to determine whether we can partition the integers of subsets , each of size , such that for every .

We construct a subtree cover instance as follows. There is a root . The root has children . Each further has children. We let the weight of every edge be .

We show that the constructed subtree cover instance can be covered by subtrees of makespan if and only if the given 3-partition instance admits a feasible partition.

Suppose the 3-partition instance admits a feasible partition, then each subtree consists of the root, and their children. It is easy to verify that the weight of each subtree is exactly .

Suppose the subtree cover instance admits a solution of makespan . Since all edge weights sum up to , we know each subtree consists of exactly edges, and each edge appears in one subtree. Therefore, if a subtree contains a vertex , it must contain all the children of . As has children, it is easy to see that each subtree contains exactly 3 children of the root, implying readily a solution for the 3-partition instance. ∎

a.2 Preliminaries for Tree-fold Integer Programming

We provide a brief introduction to the notions needed for solving a general integer programming. We refer the readers to a nice book [2] for details.

We define Graver basis, which was introduced in [3] by Graver and is crucial for our algorithm.

We define a partial order in in the following way:

Roughly speaking, implies that and lie in the same orthant, and is “closer”  to the origin than . The partial order , when restricted to , coincides with the classical coordinate-wise partial order .

Given any subset , we say is an -minimal element of if and there does not exist , such that .

According to Gordan’s Lemma, for any subset , the number of -minimal elements in is finite. Indeed, this fact is known as Dickson’s Lemma for the coordinate-wise partial order .

Definition 1.

The Graver basis of an integer matrix is the finite set which consists of all the -minimal elements of .

The Graver basis is only dependent on . Let be the largest absolute value over all entries. For any

, we have the following rough estimation for some constant

 [15]:

The Graver basis has the following positive sum property: for every , there exist a subset such that for every , , and furthermore, for some . See [15, 2] for details.

Given is an integer programming of the following form:

(4)

Let be an arbitrary feasible solution of (4). We say is an augmentation vector for if is a feasible solution of (4) that has an objective value strictly better than , i.e., . Therefore, and .

It is shown by Graver [3] that is an optimal solution of (4) if and only if there does not exist which is an augmentation vector for . Later on, Hemmecke, Onn and Weismantel [5] proved that, starting from an arbitrary feasible solution for (4), the optimal solution could be achieved by iteratively applying the best augmentation via Graver basis, i.e., augmenting by using the best possible augmentation vector of the form , where and . The total number of augmentation vectors needed is bounded by , where is the length of the binary encoding of the vector (There may exist an augmentation vector which is better than any Graver basis, however, the result of [5] allows us to restrict our attention to Graver basis). This statement remains true if, instead of choosing the best possible augmentation vector of the form , say, , we choose an augmentation vector which is at least as good as . That is, if in each augmentation vector we choose an augmentation vector such that , the optimal solution could also be achieved after augmentation vectors [4, 2]. Notice that does not necessarily belong to . Such greedy algorithm is called Graver-best augmentation algorithm.

The results by Hemmecke et al. [4, 2] imply that, to design a polynomial time algorithm for (4), it suffices to handle the following two problems:

  • finding a feasible initial solution for (4) in polynomial time;

  • finding a Graver-best augmentation algorithm that runs in polynomial time.

In Subsection A.5 we show in detail how to find a feasible initial solution for (4) in polynomial time. Roughly speaking this could be handled by establishing another ILP with a trivial initial feasible solution and finding its optimal solution.

We focus on problem [b]. A natural algorithm is that, given the current feasible solution , for every , we find integer such that is still feasible and is minimized, and among all the we pick the best one. For any fixed we can easily find by solving an integer programming with only one integral variable . Therefore the overall running time depends on the cardinality of the Graver bais . Unfortunately could be huge in general. However, if the matrix has some special structure, then could be significantly smaller.

From now on we focus on a tree-fold matrix consisting of copies of submatrices , , , and write it as for simplicity. Recall that each is an -matrix, whereas we are restricting to the following

Notice that if , is called an -fold matrix. In 2013, Hemmecke et al. provided a Graver-best augmentation algorithm for -fold integer programming that runs in time (here the big- hides all coefficients that only depend on and ). The following lemma is the key ingredient to their algorithm. It strengthens the fitness theorem in [7].

Consider any . We write as a tuple where . Each is called a brick of .

Lemma 5 ([4]).

Let . There exists some integer that only depends on matrices and , and

such that for any we have for any .

We further generalize the algorithm of Hemmecke et al. [4] to tree-fold integer programming. Towards this, we first give a generalization of the above lemma, and then we show how to further generalize their algorithm.

a.3 Proof of Lemma 1

Proof of Lemma 1.

Throughout this proof, for an arbitrary matrix , we list its Graver bases (in an arbitrary order) as , and let be the matrix with each of the bases being its column.

Consider . For any , it follows directly that for every . According to the positive sum property of the Graver basis, there exist such that

(5)

where . Notice that is only dependent on matrix . In order to show that for some , it suffices to show that