Content uploaded by Peng Zhang
Author content
All content in this area was uploaded by Peng Zhang on Apr 01, 2018
Content may be subject to copyright.
On the Generalized Multiway Cut in Trees Problem
Hong Liu ∗Peng Zhang †
April 1, 2018
Abstract
Given a tree T= (V, E) with nvertices and a collection of terminal
sets D={S1, S2, . . . , Sc}, where each Siis a subset of Vand cis a
constant, the generalized Multiway Cut in trees problem (GMWC(T))
asks to find a minimum size edge subset E0⊆Esuch that its removal
from the tree separates all terminals in Sifrom each other for each
terminal set Si. The GMWC(T) problem is a natural generalization
of the classical Multiway Cut in trees problem, and has an implicit
relation to the Densest k-Subgraph problem. In this paper, we show
that the GMWC(T) problem is fixed-parameter tractable by giving an
O(n2+ 2k) time algorithm, where kis the size of an optimal solution,
and the GMWC(T) problem is polynomial time solvable when the
problem is restricted in paths. We also discuss some heuristics for
the GMWC(T) problem.
This paper is the author’s version and is for personal use on-
ly. The original paper was published as “Hong Liu, Peng Zhang.
On the generalized multiway cut in trees problem. Journal of
Combinatorial Optimization, 27(1):65–77, 2014”.
∗School of Computer Science and Technology, Shandong University, China. Email:
hong-liu@sdu.edu.cn. The author is supported by the Independent Innovation Founda-
tion of Shandong University (2012TS071).
†Corresponding author. School of Computer Science and Technology, Shandong Uni-
versity, China. Email: algzhang@sdu.edu.cn. The author is supported by the National
Natural Science Foundation of China (60970003), China Postdoctoral Science Founda-
tion (200902562), the Special Foundation of Shandong Province Postdoctoral Innovation
Project (200901010), and the Independent Innovation Foundation of Shandong University
(2012TS072).
1
1 Introduction
The cut problem is a classical and long-standing active topic in combinatorial
optimization. In this paper, we study a generalized version of the Multiway
Cut in trees problem. The related definitions are given below.
Given a graph G= (V, E) and a vertex subset S⊆V, we say that the
removal of an edge subset E0⊆Ecuts Sif every vertex pair coming from
Sis disconnected when E0is removed from G. In this case we say that E0
is a (multiway) cut for S.
The Multiway Cut Problem. Given a graph G= (V, E) and a
terminal set S⊆V, the Multiway Cut Problem asks to find a minimum size
edge subset E0⊆Ewhose removal cuts S.
The Generalized Multiway Cut Problem (GMWC). Given a
graph G= (V, E ) and a collection of terminal sets D={S1, S2, . . . , Sc},
where cis a constant, the problem asks to find a minimum size edge subset
E0⊆Ewhose removal cuts all terminal sets in D.
The GMWC problem generalizes the Multiway Cut problem in the sense
that the number of terminal sets is generalized from one to a constant c.
Note that the terminal set number c, which is a constant, is not a part of the
GMWC instance. We denote by GMWC(T) the GMWC problem when the
input graph is a tree. Actually, we have one specified problem corresponding
to each distinct value of c. We thus denote these problems by 1-MWC(T), 2-
MWC(T), and so on. Note that 1-MWC(T) is just the traditional Multiway
Cut in trees problem.
Throughout the paper, we use nto denote the number of vertices in an
input graph, OP T (I) (or OP T ) to denote the value of the optimal solution
to an instance I. We also use OP T to denote the optimal solution itself by
abusing notations slightly.
1.1 Motivation
Zhang [16, 17] studied the generalized k-Multicut in trees problem (k-GMC(T)),
which is a generalization of the k-Multicut in trees problem [13].
The Multicut Problem. Given a graph G= (V, E) and a collection
of terminal pairs D={(s1, t1),(s2, t2),··· ,(sq, tq)}, the Multicut problem
asks to find a minimum size edge subset E0⊆Esuch that its removal cuts
all terminal pairs in D.
The k-Multicut Problem. Given a graph G= (V, E), a collection of
terminal pairs D={(s1, t1),(s2, t2),··· ,(sq, tq)}, and an integer k > 0, the
k-Multicut problem asks to find a minimum size edge subset E0⊆Esuch
2
that its removal cuts at least kterminal pairs in D.
The Generalized k-Multicut Problem (k-GMC). Given a graph
G= (V, E ), a collection of terminal sets D={S1, S2,··· , Sq}, and an
integer k > 0, the k-GMC problem asks to find a minimum size edge subset
E0⊆Esuch that its removal cuts at least kterminal sets in D.
The k-GMC problem generalizes the k-Multicut problem in the sense
that a terminal pair (s, t) is generalized to a terminal set S.
The generalized k-Multicut problem restricted in trees (i.e., k-GMC(T)),
is a particularly interesting problem, since there is an approximation p-
reserving reduction from the famous Densest k-Subgraph problem (DkS)
to k-GMC(T), which was given in [16]. The reduction says that an f(n)-
approximation algorithm for k-GMC(T) will lead to a 2f2(n)-approximation
algorithm for DkS. A remarkable feature of the k-GMC(T) instance used in
the reduction [16] is that the input tree is only a star and each terminal set
is of size exactly 3.
Therefore, the k-GMC(T) problem is almost as hard as the DkS problem,
although k-GMC(T) is defined in trees. After a series of approximation
results for the DkS problem, an improved ratio O(n1
4+) for the problem
just appeared [1] recently, where > 0 is any constant. By contrast, the k-
Multicut in trees problem admits 2 + -approximation [13]. This means that
for the k-GMC(T) problem, simply augmenting the size of each terminal set
from 2 to 3 significantly increase the difficulty of approximating it.
Very recently, using the linear programming technique, Zhang and Zhu
et al. [17] designed an O(√q)-approximation algorithm for the k-GMC(T)
problem and an O(√qlog n)-approximation algorithm for the k-GMC prob-
lem in general graphs. Then we would like to consider some special cases
of the k-GMC(T) problem. An interesting problem arises: How about the
k-GMC(T) problem when kis a constant? This problem can be solved by
enumerating all q
ksub-collections of Dand solving the resulting problem
corresponding to each enumeration, that is, to cut constant number terminal
sets in a tree, which is precisely the GMWC(T) problem we study in this
paper.
1.2 Related Work
The Multiway Cut in trees problem (that is, 1-MWC(T)) is proved to be
polynomial time solvable [5, 6]. Chopra and Rao [5] gave a polynomial-time
greedy algorithm for 1-MWC(T) and proved that the solution found by their
algorithm is optimal via the optimal criteria in linear programming. Costa
and Billionnet [6] proved that 1-MWC(T) can even be solved in linear time
3
by dynamic programming.
The Multiway Cut in graphs problem was proved to be NP-hard and
APX-hard by Dahlhaus et al. [7]. The current best approximation ratio
for Multiway Cut in graphs is 1.3438, according to Karger et al. [10]. The
Multicut in trees problem is already NP-hard and APX-hard, and its cur-
rent best approximation ratio is 2, according to Garg et al. [8]. From the
negative side, if the Unique Games Conjecture is true, then the Multiway
Cut in graphs problem can not be approximated within a factor equal to the
integrality gap of the so-called earthmover linear program for the problem
[12], and the Multicut in trees problem can not be approximated within 2−
[11].
From the aspect of parameterized algorithms, Xiao [15] gave an O(2krT )
time parameterized algorithm for the Multiway Cut in graphs problem,
where ris the number of terminals and Tis the time of finding a minimum
s-tcut in a graph. Chen et al. [4] gave an O(k4kn3) time parameterized
algorithm for the node version of the Multiway Cut problem. Guo and Nie-
dermeier [9] gave a parameterized algorithm for the Multicut in trees prob-
lem, whose time complexity is O(k3k+q3n+n3q). Very recently, Bousquet
et al. [3] solved a long-standing open problem, showing that the Multicut
in graphs problem is fixed-parameter tractable.
1.3 Our Results
In this paper, we investigate several solving approaches for the GMWC(T)
problem. The precise complexity of GMWC(T) is still unknown at the
current time.
We design an O(n2+ 2k) time algorithm for the GMWC(T) problem,
where the parameter kis the size of an optimal cut for the problem. This
means that GMWC(T) is fixed-parameter tractable. First, we give three
simple data reduction rules which are used to reduce the size of the input
instance, obtaining the so-called problem kernel. Then, by a careful classi-
fication of the vertices in the kernel, we prove that the kernel is of a small
size. Finally, we design a parameterized O(n2+2k) time algorithm based on
the kernel for the GMWC(T) problem, by using the basic depth-bounded
search tree technique and the interleaving technique [14].
Note that GMWC(T) can be solved by converting to the Multicut in trees
problem and hence admits a parameterized algorithm by Guo and Nieder-
meier [9], since there are at most O(n2) terminal pairs for all the cterminal
sets in D. However, the running time of our algorithm for GMWC(T) is
much faster than that of the above trivial conversion approach.
4
We prove that when restricted in paths, the GMWC(T) problem is poly-
nomial time solvable by a dynamic programming approach. We also give
counterexamples for several heuristics for GMWC(T) based on dynamic pro-
gramming and greedy approach.
2 An FPT Algorithm
2.1 Data Reduction Rules
A trivial solution to the GMWC(T) problem is to convert the problem to
the Multicut in trees problem by enumerating all possible terminal pairs
from the terminal set collection D. This will lead to O(n2) terminal pairs
in the worst case. Thus, the time complexity would be O(k3k+n7) by the
parameterized algorithm in [9]. In this section and the subsequent section,
we shall give a parameterized algorithm for GMWC(T) with significantly
improved time complexity.
Recall that the input graph of the GMWC(T) problem is a tree T. At
the first step, we root the tree Tat any non-leaf vertex.
(Remove nonterminal leaves.) If a leaf is not a terminal in any
terminal set, then remove the leaf from the tree.
(Remove nonterminal degree-2 vertices.) If a degree-2 vertex is not
a terminal, then merge its two incident edges into a single edge and delete
this degree-2 vertex from the tree.
The correctness of the removing nonterminal leaves rule and the remov-
ing nonterminal degree-2 vertices rule is straightforward.
(Remove terminal leaves conditionally.) If a terminal leaf vappears
only once in terminal set collection D, and has its parent unot being a
terminal of any terminal set, then replace vby uin terminal set collection
Dand remove vertex vfrom the tree.
Lemma 2.1 The optimal value does not change after applying the condi-
tionally removing terminal leaves rule.
Proof: Let Ibe the instance before applying the conditionally removing
terminal leaves rule, and I0be the new instance after applying the rule.
As the optimal solution to instance I0is a feasible solution to instance I,
obviously we have OP T (I)≤OP T (I0).
For the opposite direction, let O P T (I) be an optimal solution to instance
I. Suppose the edge (u, v) removed by the rule is in OP T (I). (Otherwise
we have OP T (I0)≤OP T (I) and are done.) After removing all edges in
5
0
3
I
1
2
I
1
3
I
1
I
1
I
1
I
1
2
I
0
2
I
1
I
Figure 1: Classification of internal vertices.
OP T (I) from the tree, all terminal sets are cut. If we put edge (u, v) back
to the tree again, then by the optimality of OP T (I), there is a unique vertex
won the tree which is in the same terminal set as that of v, such that vand
ware connected. Since uis not a terminal, uitself can not be vertex w. So,
there is a path Pbetween uand wand we can replace edge (u, v) in OP T (I)
by any edge on path P, without changing the feasibility (w.r.t. instance I)
of OP T (I). This suggests that OP T (I) is also a feasible solution to instance
I0, resulting in OP T (I0)≤OP T (I). This concludes the lemma.
2.2 Problem Kernel and the Algorithm
To show that we can get a small kernel for the GMWC(T) problem by
repeatedly applying the data reduction rules given in Section 2.1 until none
of them can apply further, we need the following classification for vertices
of the input tree.
First, let Ibe the set of all internal vertices, and Lbe the set of all
leaves.
Then, all the internal vertices are classified into four categories according
to the adjacency to other internal vertices. Given a vertex vin the tree, let
N(v) be the neighborhood of v, i.e., the set of all vertices in the tree adjacent
to v.
•I0={v∈I|N(v)∩I= 0}. That is, each internal vertex in I0has no
any adjacent internal vertex.
•I1={v∈I|N(v)∩I= 1}. Each internal vertex in I1has just one
adjacent internal vertex.
6
•I2={v∈I|N(v)∩I= 2}. Each internal vertex in I2has exactly
two adjacent internal vertices.
•I3={v∈I|N(v)∩I≥3}. Each internal vertex in I3has at least
three adjacent internal vertices.
Finally, vertices in I2are further classified into two categories. Suppose
uis a vertex in the tree. Let p(u) be the parent vertex of u.
•I1
2={v∈I2| ∃u∈L, p(u) = v}. That is, I1
2is the set of all I2-vertices
that have at least one leaf child.
•I0
2=I2\I1
2is the set of all I2-vertices that have no leaf child.
Similarly, we have two categories I1
3and I0
3.
•I1
3={v∈I3| ∃u∈L, p(u) = v}.
•I0
3=I3\I1
3.
For a vertex vin subset Ij, we also say that vis of type Ijand call van
Ij-vertex. We note here that I0is a very special internal vertex set, since it
can contain only one element and this will happen only if the input tree is
a star. For a tree that is not a star, there is no any I0-vertex at all.
We bound the size of the problem kernel by parameter k, which is the
size of an optimal multiway cut, i.e., OP T (I).
Lemma 2.2 If the input tree is a star, then |I0|+|L| ≤ c+k.
Proof: By the removing nonterminal leaves rule, each leaf is a terminal.
When all edges in OP T are removed from the star, the star is broken
into k+ 1 connected components, where at least kconnected components
are isolated vertices (leaves).
If the unique I0-vertex, i.e., the star center, also becomes an isolated
vertex, then we have |I0|+|L|=k+ 1 ≤k+c.
Then consider the case that the star center is not an isolated vertex
after removing edges in OP T . Let Cbe the connected component where
the star center exists. If the star center itself is not a terminal, then by
the conditionally removing terminal leaves rule, each leaf in connected com-
ponent Cmust belong to at least two terminal sets. Therefore, there are
at most bc/2cleaves in connected component C. In this subcase we have
|I0|+|L| ≤ 1 + bc/2c+k≤k+c.
If the star center is a terminal, it is easy to see that there are at most
cterminals in connected component C. So, we also have |I0|+|L| ≤ k+c.
This gives the lemma.
7
Lemma 2.3 If the input tree is not a star, then |I1|+|I2|+|I1
3|+|L| ≤
c(k+ 1).
Proof: By the removing nonterminal degree-2 vertices rule, each I0
2-vertex
is a terminal. By the removing nonterminal leaves rule, each leaf is also a
terminal.
If a I1-vertex, to say, uis not a terminal, then by the conditionally
removing terminal leaves rule, umust have at least one leaf vas its child
such that vappears at least twice in terminal set collection D. So we can
charge one terminal appearance on vto the I1-vertex u. The same argument
applies to each I1
2-vertex and each I1
3-vertex.
Therefore, the sum |I1|+|I2|+|I1
3|+|L|is bounded from above by the
total number of terminal appearances.
When all edges in OP T are removed from the input tree, the tree is
broken into k+1 connected components. In each component, by the defini-
tion of the generalized multiway cut, there are at most cdistinct terminals.
Thus there are at most c(k+ 1) terminal appearances in total. The lemma
follows.
Lemma 2.4 If the input tree is not a star, then |I1
3|+|I0
3| ≤ |I1| − 1.
Proof: By removing all leaves from the input tree T, we get a tree T0
whose vertices are all I-vertices of T. Denote by n0
ithe number of vertices
in T0each of which has exactly ichild, for i= 0,1, and by n0
2the number of
vertices in T0that has at least 2 children. Then we have n0
0=|I1|,n0
1=|I2|
and n0
2=|I3|. It is well-known that n0
2=n0
0−1 in a binary tree. For a tree
such as T0in which internal vertices may have more than two children, we
have n0
2≤n0
0−1.
Theorem 2.1 The GMWC(T) problem admits a problem kernel of size at
most 2c(k+ 1).
Proof: By Lemmas 2.2, 2.3 and 2.4.
Lemma 2.5 The problem kernel of GMWC(T) can be obtained in O(n)
time.
Proof: By scanning each vertex in the input tree T, all nonterminal leaves
(corresponding to the removing nonterminal leaves rule) and nonterminal
degree-2 vertices (corresponding to the removing nonterminal degree-2 ver-
tices rule) can be removed in O(n) time.
8
Noticing that the terminal set collection Dcontains only cterminal sets,
which is a constant number, the conditionally removing terminal leaves rule
can also be performed in O(n) time by scanning each terminal in D.
Before giving the the main theorem of this section, we first show that
there is a so-called interleaving technique which can be used to accelerate a
class of FPT algorithms. Let Ibe an instance of a problem Π and (I, k)
be the input to an FPT algorithm Afor Π. Suppose algorithm Aworks
in two stages that the first stage is a reduction to problem kernel and the
second stage is a bounded search tree of size O(ξk), where ξis a constant.
Reduction to problem kernel takes P(|I|) steps and results in an instance
of size at most q(k). The expansion of a node in the search tree takes
R(|I|) steps. All of P,qand Rare polynomially bounded. The overall time
complexity of algorithm Ais then O(P(|I|) + R(q(k))ξk). The following
theorem shows that algorithm Acan be accelerated.
Theorem 2.2 ([14]) Suppose algorithm Ais a two-stage FPT algorithm
for problem Πrunning in O(P(|I|) + R(q(k))ξk)time as described above.
Then there is an FPT algorithm for problem Πwith improved time complex-
ity O(P(|I|) + ξk).
The parameterized algorithm solving the GWMC(T) problem is given
in the proof of the following theorem.
Theorem 2.3 The Generalized Multiway Cut in trees problem can be solved
in O(n2+ 2k)time.
Proof: The basic strategy of solving GMWC(T) is to use a bounded depth
search tree. First we obtain the problem kernel of size at most 2c(k+ 1).
By Theorem 2.1 and Lemma 2.5, this can be done in O(n) time.
Next we convert terminal set collection Dinto a terminal pair set by
generating all possible |S|
2terminal pairs for each terminal set S∈D. Let
LIST be the resulting set of terminal pair. The size of LIST is at most
2c(k+1)
2=O(k2). For each pair in LIS T , we record its least common
ancestor in the kernel. By [2], this will consume a preprocessing time linear
in the size of the kernel and a constant query time for each terminal pair.
Thus the total time of computing least common ancestor for all terminal
pairs in LIST is O(k2).
Then, root the kernel at any vertex. This is the only one node of the
initial search tree at the current time. In the bottom-up manner, we scan
each internal vertex of the kernel. Suppose the current scanned vertex uis
9
the least common ancestor for some pair (s, t) in LI ST . If it is not the case,
then we scan the next vertex.
Let Pbe the unique path between sand tin the kernel. If uis sor t,
then remove the edge on Pincident to ufrom the kernel, and remove all
pairs disconnected by such an edge removal from LIS T , resulting in a new
node of the search tree which is the unique child of the current node. We
get in the new node and scan the next vertex of the kernel. Otherwise uis
an intermediate vertex on P. Let (l, u) and (u, r) be the two edges on P
incident to u. The search tree splits into two branches at the current node,
which corresponds to each of the two edges. In the either new node, we
remove the corresponding edge from the kernel, and remove all pairs thus
disconnected from LI ST . Then we get in each of the two nodes and scan
the next vertex of the kernel recursively.
Since OP T (I) is equal to k, the depth of the search tree is bounded
by k. The work at each node of the search tree (including determining on
u, removing edge from the kernel, and removing disconnected pairs) can
be done in O(k3) time. Therefore, the total time of computing the desired
optimal solution is O(n+k2+k32k) = O(n2+k32k).
Finally, using the interleaving technique introduced in [14], the above
parameterized algorithm can be accelerated to run in O(n2+ 2k) time. The
proof is finished.
3 Some Observations
3.1 About the Complexity of GMWC(T)
It is well-known that the Multiway Cut in trees problem (i.e., 1-MWC(T))
is polynomial-time solvable [5, 6], while the Multicut in trees problem is
NP-hard [8], even the problem is restricted in stars. From the viewpoint
of problem goal, the GMWC(T) problem lies exactly between the Multiway
Cut in trees problem and the Multicut in trees problem. To determine
the precise complexity of GMWC(T) thus becomes an intriguing and subtle
problem.
In the Multicut in trees problem, we have to disconnect qterminal pairs
{(si, ti)}, where qis a part of the problem input. In the GMWC(T) problem,
we have to disconnect cterminal sets {Si}, where cis independent of the
input of the problem. If there is a polynomial time algorithm for GMWC(T)
whose time complexity has nothing to do with the constant c, then we can
solve the Multicut in trees problem in polynomial time, since Multicut in
trees is nothing more than q-MWC(T). However, this would be absurd,
10
since the Multicut in trees problem is NP-hard and P is not equal to NP, as
believed.
Theorem 3.1 If the GMWC(T) problem can be solved in polynomial time,
the time complexity of the supposed algorithm must depend on constant c,
assuming P6=N P .
3.2 A Special Case of GMWC(T)
Suppose we are given a GMWC(T) instance (T, D). Let us consider the
weighted version of GMWC(T) and thus {w(e)}be the weights defined on
edges in T. For each terminal set S∈D, let TSbe the subtree of T
obtained by uniting the unique paths between all the |S|
2possible terminal
pairs coming from S.
Consider an optimal solution E∗⊆E(T) to the instance (T, D). E∗
must contain at least one edge for the subtree TScorresponding to terminal
set S. This observation suggests we can express the optimal value as
OP T = min
E0⊆E(T): |E0|≤cnw(E0) + X
Tj
OP T (Tj)o,(1)
where Tjstands for a tree in the forest led by removing E0from T, and
OP T (Tj) is the optimal value of the instance (T, D) restricted on subtree
Tj.
Equation (1) may suggest a dynamic programming algorithm for GMWC(T):
Just compute the value of the GMWC(T) instance on each subtree of Tin a
systematic way. Unfortunately, the number of subtrees of a tree is unpracti-
cally large and consequently we can not get a polynomial time algorithm for
GMWC(T) by this way. For example, a star with hleaves may have Ω(2h)
subtrees.
When the input tree is simply a path, the number of subtrees is n
2, a
polynomially bounded quantity. The above dynamic programming algorith-
m will work in polynomial time for this special case. So we have
Theorem 3.2 If the input tree is a path, then the GMWC(T) problem can
be solved in polynomial time.
3.3 Counterexamples for Some Heuristics
In this section we show the counterexamples for some simple heuristics for
GMWC(T). First we define two terminologies for the problem. Two termi-
nals are homologous if they come from the same terminal set. Given a tree,
11
RR RG G G
v1v2v3v4v5v6
e1e2e3e4e5
Figure 2: Instance Aof GMWC(T).
a terminal in the tree is called an orphan if there is no any other terminal
in the tree that is homologous with this terminal.
Heuristics based on dynamic programming. Since the GMWC(T)
problem is defined in trees, the heuristic that is easily thought may be the
dynamic programming approach. We root the input tree at an arbitrary
vertex, and then scan each vertex vin the tree from the bottom to the
top one by one. For the subtree T(v) rooted at v, we find by enumerat-
ing the minimum cost edge subset E0⊆E(T(v)) such that the removal of
E0can disconnect all homologous terminal pairs. Note that this dynamic
programming approach is different to the one in Theorem 3.2.
However, the instance Ashown in Figure 2 is a counterexample to the
above dynamic programming approach. In Instance A, there are two (that
is, c= 2) terminal sets with R={v1, v3, v5}and G={v2, v4, v6}. When the
tree is rooted at v6, the dynamic programming approach will finally output
{e1, e3, e5}as a solution. On the other hand, the optimal solution is {e2, e4}.
(Note that Instance Acan be optimally solved by the dynamic programming
approach in Theorem 3.2.) Some other variants of this dynamic program-
ming approach also do not work. We omit their descriptions here due to the
limitation of space.
Heuristics based on greedy approach. Based on the observations
in Theorems 3.1 and 3.2, one can suggest a framework of greedy approach
for GMWC(T) as follows. (i) Find by enumerating an edge subset E0with
|E0| ≤ c0in the current tree T0(which is the input tree Tinitially) such that
a certain criterion is met, where c0is the number of terminal sets (of size
at least 2) in T0. (ii) Remove E0from T0. This will break T0into several
subtrees. (iii) Recursively repeat the above two steps on each resulting
subtree, until all terminal sets are disconnected. (iv) Remove the redundant
edges (with respect to constituting a feasible cut) from the edge set finally
obtained.
We discuss several criteria that can be used in step (i).
Firstly, the criterion could be a minimum weight edge subset E0of size
at most c0such that the removal of E0splits every terminal set. In this case,
Instance Ain Figure 2 acts as a counterexample. The algorithm will pick
12
RR
R
G
G
G
e1
e2
e3e4e5
R
G
e6
e7
Figure 3: Instance Bof GMWC(T).
edge e3in its first iteration, resulting in two subtrees. It will pick edge e1
and then pick edge e5in the two resulting subtrees. Of course, this is not
an optimal solution.
Secondly, the criterion could be an edge subset E0of size at most c0
such that the ratio of the total weight w(E0) to pairs(E0) is minimized,
where pairs(E0) is the number of homologous terminal pairs disconnected
by removing E0. In this case, Instance Ain Figure 2 also acts as a coun-
terexample. The algorithm will pick edge e3(with ratio of 1
4) in its first
iteration, resulting in two subtrees. It will pick edge e1and then pick edge
e5in the two resulting subtrees (with ratio of 1
1in both of the two subcases).
Thirdly, the criterion could be an edge subset E0of size at most c0such
that the ratio of the total weight w(E0) to orphans(E0) is minimized, where
orphans(E0) is the number of orphans generated by removing E0. This
greedy approach will compute the optimal solution to Instance A.
However, the instance Bin Figure 3 is a counterexample. In the first
iteration, the algorithm will remove e4with corresponding ratio being 1
2
(one edge and two resulting orphans). In its subsequent four iterations,
the algorithm will pick e1,e2,e6and e7successively. However, an optimal
solution to Instance Bis {e2, e3, e5, e6}.
Finally, let us consider as the criterion an edge subset E0of size at most
c0such that orphans(E0) is maximized. (In case of ties, a minimum weight
edge subset is picked.) For this greedy approach, Instances Aand Bare no
longer counterexamples. However, there is still a counterexample for this
approach, namely, Instance Cas shown in Figure 4.
When running on Instance C, the algorithm will pick {e3, e5}in its first
iteration, generating four orphans. In its subsequent four iterations, the
algorithm will pick edges e1,e4,e8and e9successively. However, an optimal
solution to Instance Cis {e2, e5, e7, e9}.
13
RR
R
G
G
G
e1e2
e3
e4
e5G
G
R
e6e7
e8
e9
Figure 4: Instance Cof GMWC(T).
4 Conclusions
In this paper, we propose the GMWC(T) problem. We show the GMWC(T)
problem is fixed-parameter tractable and is polynomial time solvable when
restricted in paths. At the current time, we have neither an algorithm to
show the GMWC(T) problem is in P, nor a proof to show the problem is
NP-hard. To determine the complexity of GMWC(T) remains an interesting
open problem.
References
[1] Bhaskara, A., Charikar, M., Chlamtac, E., Feige, U., Vijayaraghavan,
A.: Detecting high log-densities – an O(n1/4) approximation for densest
k-subgraph. In: Schulman, L. (Ed.): Proceedings of the 42nd Annual
ACM Symposium on Theory of Computing (STOC), pp. 201–210, ACM
(2010)
[2] Bender, M.A., Farach-Colton, M.: The LCA problem revisited. In:
Gonnet, G.H., Panario, D., Viola, A. (Eds.): Proceedings of the 4th
Latin American Symposium on Theoretical Informatics (LATIN), L-
NCS, vol. 1776, pp. 88–94, Springer (2000)
[3] Bousquet, N., Daligault, J., Thomass´e, S.: Multicut is FPT. In: Fort-
now, L., Vadhan, S. (Eds.): Proceedings of the 43rd Annual ACM Sym-
posium on Theory of Computing (STOC), pp. 459–468, ACM (2011)
[4] Chen, J.-E., Liu, Y., Lu, S.-J.: An improved parameterized algorithm
for the minimum node multiway cut problem. Algorithmica 55:1–13
(2009)
14
[5] Chopra, S., Rao, M.: On the Multiway Cut Polyhedron. Networks
21:51–89 (1991)
[6] Costa, M.-C., Billionnet, A.: Multiway cut and integer flow problems
in trees. Electronic Notes in Discrete Mathematics 17:105–109 (2004)
[7] Dahlhaus, E., Johnson, D., Papadimitriou, C., Seymour, P., Yan-
nakakis, M.: The complexity of multiterminal cuts. SIAM Journal on
Computing 23:864–894 (1994)
[8] Garg, N., Vazirani, V., Yannakakis, M.: Primal-dual approximation
algorithm for integral flow and multicut in trees. Algorithmica 18:3–20
(1997)
[9] Guo, J., Niedermeier, R.: Fixed-parameter tractability and data reduc-
tion for multicut in trees. Networks 46(3):124–135 (2005)
[10] Karger, D., Klein, P., Stein, C., Thorup, M., Young, N.: Rounding al-
gorithms for a geometric embedding of minimum multiway cut. Math-
ematics of Operations Research 29(3):436–461 (2004)
[11] Subhash Khot, Oded Regev: Vertex cover might be hard to approx-
imate to within 2 −. Journal of Computer and System Sciences
74(3):335–349 (2008)
[12] Manokaran, R., Naor, J., Raghavendra, P., Schwartz, R.: SDP gaps
and UGC hardness for multiway cut, 0-extension, and metric labeling.
In: Dwork, C. (Ed.): Proceedings of the 40th Annual ACM Symposium
on Theory of Computing (STOC), pp. 11–20, ACM (2008)
[13] Mestre, J.: Lagrangian relaxation and partial cover (extended abstrac-
t). In: Albers, S., Weil, P. (Eds.): Proceedings of the 25th International
Symposium on Theoretical Aspects of Computer Science (STACS), pp.
539–550, LIPIcs 1 Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik,
Germany (2008)
[14] Niedermeier, R., Rossmanith, P.: A general method to speed up fixed-
parameter-tractable algorithms. Information Processing Letters 73:125–
129 (2000)
[15] Xiao M.-Y.: Simple and improved parameterized algorithms for multi-
terminal cuts. Theory of Computing Systems 46:723–736 (2010)
15
[16] Zhang, P.: Approximating generalized multicut on trees. In: Cooper,
S.B., L¨owe, B., Sorbi, A. (Eds.): Proceedings of the 3rd International
Conference of Computability in Europe (CiE), LNCS, vol. 4497, pp.
799–808. Springer (2007)
[17] Zhang, P., Zhu, D.-M., Luan J.-F.: An approximation algorithm for the
generalized k-Multicut problem. Discrete Applied Mathematics 160(7-
8):1240–1247 (2012)
16
