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 ﬁnd 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 ﬁxed-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 deﬁnitions 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 ﬁnd 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 ﬁnd 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 speciﬁed 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 ﬁnd 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 ﬁnd 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 ﬁnd 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 deﬁned 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 signiﬁcantly increase the diﬃculty 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 ﬁnding 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 ﬁxed-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 ﬁxed-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-

ﬁcation 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 signiﬁcantly

improved time complexity.

Recall that the input graph of the GMWC(T) problem is a tree T. At

the ﬁrst 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: Classiﬁcation 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 classiﬁcation 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 classiﬁed 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 classiﬁed 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 deﬁni-

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 ﬁrst 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 ﬁrst 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 ﬁnished.

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 deﬁned 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 deﬁne 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 deﬁned 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 ﬁnd 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 diﬀerent 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 ﬁnally 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 ﬁnally

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 ﬁrst 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 ﬁrst

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 ﬁrst

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 ﬁrst

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 ﬁxed-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 ﬂow 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 ﬂow 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 ﬁxed-

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