René van Bevern

@article{BS24,
  title =	 {A quadratic-order problem kernel for the traveling
                  salesman problem parameterized by the vertex cover
                  number},
  author =	 {René van Bevern and Daniel A. Skachkov},
  year =	 {2024},
  date =	 {2024-01},
  pages =	 {107065},
  volume =	 {52},
  journal =	 {Operations Research Letters},
  doi =		 {10.1016/j.orl.2024.107065},
  url_Preprint = {10.48550/arXiv.2207.08678}
}

@article{BKS+24,
  url_Preprint = {10.48550/ARXIV.2109.06042},
  doi =		 {10.1016/j.jcss.2023.103479},
  author =	 {van Bevern, René and Kirilin, Artem M. and Skachkov,
                  Daniel A. and Smirnov, Pavel V. and Tsidulko, Oxana},
  title =	 {Serial and parallel kernelization of Multiple
                  Hitting Set parameterized by the Dilworth number,
                  implemented on the GPU},
  journal =	 {Journal of Computer and System Sciences},
  year =	 {2024},
  date =	 {2024-02},
  volume =	 {139},
  pages =	 {103479}
}

@article{BKK+24,
  url =		 {https://jgaa.info/index.php/jgaa/article/view/2927},
  author =	 {van Bevern, René and Kanj, Iyad A. and Komusiewicz,
                  Christian and Niedermeier, Rolf and Sorge, Manuel},
  keywords =	 {Discrete Mathematics (cs.DM), Combinatorics
                  (math.CO), FOS: Computer and information sciences,
                  FOS: Computer and information sciences, FOS:
                  Mathematics, FOS: Mathematics},
  title =	 {The role of twins in computing planar supports of
                  hypergraphs},
  journal =	 {Journal of Graph Algorithms and Applications},
  volume =	 28,
  number =	 1,
  pages =	 {51--79},
  year =	 {2024},
}

@article{BMST23,
  url_Preprint = {http://doi.org/10.48550/ARXIV.2205.08769},
  doi =		 {10.1016/j.orl.2023.06.005},
  author =	 {van Bevern, René and Melnikov, Andrey and Smirnov,
                  Pavel and Tsidulko, Oxana},
  title =	 {On data reduction for dynamic vector bin packing},
  journal =	 {Operations Research Letters},
  volume =	 {51},
  pages =	 {446-452},
  year =	 {2023},
  date =	 {2023-07-04}
}

@article{BBF+23,
  doi =		 {10.1016/j.dam.2022.11.018},
  url_Preprint = {https://doi.org/10.1016/j.dam.2022.11.018},
  year =	 {2023},
  month =	 mar,
  publisher =	 {Elsevier {BV}},
  volume =	 {328},
  pages =	 {117--133},
  author =	 {Matthias Bentert and Ren{\'{e}} van Bevern and Till
                  Fluschnik and Andr{\'{e}} Nichterlein and Rolf
                  Niedermeier},
  title =	 {Polynomial-time data reduction for weighted problems
                  beyond additive goal functions},
  journal =	 {Discrete Applied Mathematics}
}

@article{BBN+22,
  author =	 {{Bentert}, Matthias and René van Bevern and
                  {Nichterlein}, André and {Niedermeier}, Rolf and
                  Smirnov, Pavel V.},
  title =	 {Parameterized algorithms for power-efficiently
                  connecting wireless sensor networks: Theory and
                  experiments},
  journal =	 {INFORMS Journal on Computing},
  year =	 2022,
  abstract =	 {We study an NP-hard problem motivated by
                  energy-efficiently maintaining the connectivity of a
                  symmetric wireless sensor communication network:
                  Given an edge-weighted n-vertex graph, find a
                  connected spanning subgraph of minimum cost, where
                  the cost is determined by letting each vertex pay
                  the most expensive edge incident to it in the
                  subgraph. On the negative side, we show that
                  o(logn)-approximating the difference d between the
                  optimal solution cost and a natural lower bound is
                  NP-hard and that, under the Exponential Time
                  Hypothesis, there are no exact algorithms running in
                  2^o(n) time or in f(d)⋅n^O(1) time for any
                  computable function f. On the positive side, we
                  provide an algorithm that reconnects O(logn)
                  connected components with minimum additional cost in
                  polynomial time. These algorithms are motivated by
                  application scenarios of monitoring areas or where
                  an existing sensor network may fall apart into
                  several connected components due to sensor
                  faults. In experiments, the algorithm solves
                  instances with four such connected components and
                  about 8 000 vertices in five minutes, outperforming
                  CPLEX with known ILP formulations for the problem.},
  url_Code =	 {https://gitlab.com/rvb/mpsc},
  url_Slides =
                  {https://www.researchgate.net/publication/328262005_The_min-power_symmetric_connectivity_problem_with_few_obligatory_network_components},
  doi =		 {10.1287/ijoc.2020.1045},
  url_Preprint = {https://arxiv.org/abs/1706.03177},
  volume =	 34,
  number =	 1,
  pages =	 {55--75},
  date =	 {2022-03-22},
  keywords =	 {connected spanning subgraphs, monitoring areas,
                  reconnecting sensor networks, parameterized
                  complexity analysis, approximation hardness,
                  parameterization above lower bounds, color-coding,
                  experimental comparison},
}

We study an NP-hard problem motivated by energy-efficiently maintaining the connectivity of a symmetric wireless sensor communication network: Given an edge-weighted n-vertex graph, find a connected spanning subgraph of minimum cost, where the cost is determined by letting each vertex pay the most expensive edge incident to it in the subgraph. On the negative side, we show that o(logn)-approximating the difference d between the optimal solution cost and a natural lower bound is NP-hard and that, under the Exponential Time Hypothesis, there are no exact algorithms running in 2^o(n) time or in f(d)⋅n^O(1) time for any computable function f. On the positive side, we provide an algorithm that reconnects O(logn) connected components with minimum additional cost in polynomial time. These algorithms are motivated by application scenarios of monitoring areas or where an existing sensor network may fall apart into several connected components due to sensor faults. In experiments, the algorithm solves instances with four such connected components and about 8 000 vertices in five minutes, outperforming CPLEX with known ILP formulations for the problem.

@article{BTZ21,
  author =	 {Ren{\'{e}} van Bevern and Oxana Tsidulko and Philipp
                  Zschoche},
  title =	 {Representative families for matroid intersections,
                  with applications to location, packing, and covering
                  problems},
  year =	 {2021},
  journal =	 {Discrete Applied Mathematics},
  volume =	 {298},
  pages =	 {110-128},
  date =	 {2021-03-22},
  url_Preprint = {https://arxiv.org/abs/1806.11527},
  doi =		 {10.1016/j.dam.2021.03.014},
  url_Slides =
                  {https://figshare.com/articles/presentation/Facility_location_under_matroid_constraints_fixed-parameter_algorithms_and_applications/13536788},
  abstract =	 {We show algorithms for computing representative
                  families for matroid intersections and use them in
                  fixed-parameter algorithms for set packing, set
                  covering, and facility location problems with
                  multiple matroid constraints. We complement our
                  tractability results by hardness results. },
}

We show algorithms for computing representative families for matroid intersections and use them in fixed-parameter algorithms for set packing, set covering, and facility location problems with multiple matroid constraints. We complement our tractability results by hardness results.

@article{BK21,
  doi =		 {10.1007/s00224-021-10033-0},
  year =	 {2021},
  month =	 apr,
  publisher =	 {Springer},
  author =	 {Ren{\'{e}} van Bevern and Gregory Kucherov},
  title =	 {Special Issue on Computer Science Symposium in
                  Russia (2019)},
  journal =	 {Theory of Computing Systems},
  volume =	 65,
  number =	 3,
  pages =	 {441--443},
}

@article{ABT21,
  title =	 {The Hierarchical Chinese Postman Problem: the
                  slightest disorder makes it hard, yet
                  disconnectedness is manageable},
  author =	 {Vsevolod A. Afanasev and René van Bevern and Oxana
                  Tsidulko},
  journal =	 {Operations Research Letters},
  year =	 2021,
  volume =	 49,
  number =	 2,
  pages =	 {270--277},
  doi =		 {10.1016/j.orl.2021.01.017},
  date =	 {2021-02-05},
  url_Preprint = {https://arxiv.org/abs/2011.04022},
  url_Poster =	 {https://doi.org/10.6084/m9.figshare.13536797},
  url_Slides =
                  {https://www.researchgate.net/publication/346675762_Hierarchical_Chinese_Postman_Problem_slightest_disorder_makes_it_hard_disconnectedness_is_manageable},
  keywords =	 {approximation algorithm, fixed-parameter algorithm,
                  NP-hardness, arc routing, rural postman problem,
                  temporal graphs},
  abstract =	 {The Hierarchical Chinese Postman Problem is finding
                  a shortest traversal of all edges of a graph
                  respecting precedence constraints given by a partial
                  order on classes of edges. We show that the special
                  case with connected classes is NP-hard even on
                  orders decomposable into a chain and an incomparable
                  class. For the case with linearly ordered (possibly
                  disconnected) classes, we get 5/3-approximations and
                  fixed-parameter algorithms by transferring results
                  from the Rural Postman Problem.}
}

The Hierarchical Chinese Postman Problem is finding a shortest traversal of all edges of a graph respecting precedence constraints given by a partial order on classes of edges. We show that the special case with connected classes is NP-hard even on orders decomposable into a chain and an incomparable class. For the case with linearly ordered (possibly disconnected) classes, we get 5/3-approximations and fixed-parameter algorithms by transferring results from the Rural Postman Problem.

@article{BS20b,
  title =	 {A historical note on the 3/2-approximation algorithm
                  for the metric traveling salesman problem},
  author =	 {René van Bevern and Viktoriia A. Slugina},
  year =	 {2020},
  date =	 {2020-11-17},
  journal =	 {Historia Mathematica},
  url_Preprint = {https://arxiv.org/abs/2004.02437},
  url_Poster =
                  {https://figshare.com/articles/poster/Parallel_Roads_to_the_Traveling_Salesman_3_2-Approximation/12728723},
  url_Slides =
                  {https://www.researchgate.net/publication/348297719_Algoritm_Kristofidesa_ili_Kristofidesa-Serdukova_Istoria_otkrytia_i_publikacii},
  volume =	 53,
  pages =	 {118-127},
  doi =		 {10.1016/j.hm.2020.04.003},
  abstract =	 {One of the most fundamental results in combinatorial
                  optimization is the polynomial-time
                  3/2-approximation algorithm for the metric traveling
                  salesman problem. It was presented by Christofides
                  in 1976 and is well known as "the Christofides
                  algorithm". Recently, some authors started calling
                  it "Christofides-Serdyukov algorithm", pointing out
                  that the same result was published independently in
                  the USSR in 1978. We provide some historic
                  background on Serdyukov's findings and a translation
                  of his article.}
}

One of the most fundamental results in combinatorial optimization is the polynomial-time 3/2-approximation algorithm for the metric traveling salesman problem. It was presented by Christofides in 1976 and is well known as "the Christofides algorithm". Recently, some authors started calling it "Christofides-Serdyukov algorithm", pointing out that the same result was published independently in the USSR in 1978. We provide some historic background on Serdyukov's findings and a translation of his article.

@article{BKM+20,
  title =	 {H-Index Manipulation by Undoing Merges},
  author =	 {René van Bevern and Christian Komusiewicz and
                  Hendrik Molter and Rolf Niedermeier and Manuel Sorge
                  and Toby Walsh},
  doi =		 {10.1162/qss_a_00093},
  url_Preprint = {http://arxiv.org/abs/1604.04827},
  url_Code =	 {https://gitlab.com/rvb/split-index},
  url_Poster =
                  {https://figshare.com/articles/poster/H-index_manipulation_by_undoing_merges/13521758},
  journal =	 {Quantitative Science Studies},
  volume =	 1,
  number =	 4,
  pages =	 {1529--1552},
  abstract =	 {The h-index is an important bibliographic measure
                  used to assess the performance of
                  researchers. Dutiful researchers merge different
                  versions of their articles in their Google Scholar
                  profile even though this can decrease their
                  h-index. In this article, we study the manipulation
                  of the h-index by undoing such merges. In contrast
                  to manipulation by merging articles (van Bevern et
                  al. [Artif. Intel. 240:19-35, 2016]) such
                  manipulation is harder to detect. We present
                  numerous results on computational complexity (from
                  linear-time algorithms to parameterized
                  computational hardness results) and empirically
                  indicate that at least small improvements of the
                  h-index by splitting merged articles are
                  unfortunately easily achievable.},
  year =	 2020,
  date =	 {2020-10-13},
}

The h-index is an important bibliographic measure used to assess the performance of researchers. Dutiful researchers merge different versions of their articles in their Google Scholar profile even though this can decrease their h-index. In this article, we study the manipulation of the h-index by undoing such merges. In contrast to manipulation by merging articles (van Bevern et al. [Artif. Intel. 240:19-35, 2016]) such manipulation is harder to detect. We present numerous results on computational complexity (from linear-time algorithms to parameterized computational hardness results) and empirically indicate that at least small improvements of the h-index by splitting merged articles are unfortunately easily achievable.

@article{BFT20b,
  author =	 {Ren{\'{e}} van Bevern and Till Fluschnik and Oxana
                  Tsidulko},
  title =	 {On approximate data reduction for the {Rural Postman
                  Problem}: Theory and experiments},
  year =	 {2020},
  date =	 {2020-11-02},
  journal =	 {Networks},
  url_Preprint = {https://arxiv.org/abs/1812.10131},
  url_Poster =
                  {https://figshare.com/articles/poster/On_approximate_data_reduction_for_the_Rural_Postman_Problem/13058969},
  url_Slides =
                  {https://www.researchgate.net/publication/348297308_On_approximate_approximate_data_reduction_for_the_Rural_Postman_Problem_Theory_and_Experiments},
  doi =		 {10.1002/net.21985},
  volume =	 76,
  number =	 4,
  pages =	 {485-508},
  url_Code =	 {https://gitlab.com/rvb/rpp-psaks},
  abstract =	 {Given a graph G=(V,E) with edge weights ω:E→N∪{0}
                  and a subset R⊆E of required edges, the Rural
                  Postman Problem (RPP) is to find a closed walk W* of
                  minimum weight ω(W*) containing all edges of R. We
                  prove that RPP is WK[1]-complete parameterized by
                  the number and cost d=ω(W^*)-ω(R)+|W*|-|R| of edges
                  traversed additionally to the required ones, that
                  is, presumably cannot be polynomial-time reduced to
                  solving instances of size polynomial in d. In
                  contrast, denoting by b≤2d the number of vertices
                  incident to an odd number of edges of R and by c≤d
                  the number of connected components formed by the
                  edges in R, we show how to reduce any RPP instance I
                  to an RPP instance I' with 2b+O(c/ε) vertices in
                  O(n³) time so that any α-approximate solution for I'
                  gives an α(1+ε)-approximate solution for I, for any
                  α≥1 and ε>0. That is, we provide a polynomial-size
                  approximate kernelization scheme (PSAKS). We make
                  first steps towards a PSAKS for the parameter c.}
}

Given a graph G=(V,E) with edge weights ω:E→N∪0 and a subset R⊆E of required edges, the Rural Postman Problem (RPP) is to find a closed walk W* of minimum weight ω(W*) containing all edges of R. We prove that RPP is WK[1]-complete parameterized by the number and cost d=ω(W^*)-ω(R)+|W*|-|R| of edges traversed additionally to the required ones, that is, presumably cannot be polynomial-time reduced to solving instances of size polynomial in d. In contrast, denoting by b≤2d the number of vertices incident to an odd number of edges of R and by c≤d the number of connected components formed by the edges in R, we show how to reduce any RPP instance I to an RPP instance I' with 2b+O(c/ε) vertices in O(n³) time so that any α-approximate solution for I' gives an α(1+ε)-approximate solution for I, for any α≥1 and ε>0. That is, we provide a polynomial-size approximate kernelization scheme (PSAKS). We make first steps towards a PSAKS for the parameter c.

@article{BS20,
  title =	 {Optimal-size problem kernels for $d$-Hitting Set in
                  linear time and space},
  author =	 {René van Bevern and Pavel V. Smirnov},
  year =	 {2020},
  date =	 {2020-10-01},
  journal =	 {Information Processing Letters},
  volyme =	 {163},
  pages =	 {105998},
  doi =		 {10.1016/j.ipl.2020.105998},
  url_Preprint = {https://arxiv.org/abs/2003.04578},
  url_Code =	 {https://gitlab.com/PavelSmirnov/hs-lintimespace},
  url_Poster =	 {https://figshare.com/articles/poster/Optimal-size_problem_kernels_for_d-Hitting_Set_in_linear_time_and_space/12782975},
  abstract =	 {We improve two linear-time data reduction algorithms
                  for the d-Hitting Set problem to work in linear
                  space, thus obtaining the first algorithms for
                  computing problem kernels of asymptotically optimal
                  size O(k^d) for d-Hitting Set in linear time and
                  space. We experimentally compare the two algorithms
                  to a classical data reduction algorithm of Weihe and
                  evaluate their combinations.}
}

We improve two linear-time data reduction algorithms for the d-Hitting Set problem to work in linear space, thus obtaining the first algorithms for computing problem kernels of asymptotically optimal size O(k^d) for d-Hitting Set in linear time and space. We experimentally compare the two algorithms to a classical data reduction algorithm of Weihe and evaluate their combinations.

@article{BFT20,
  author =	 {Ren{\'{e}} van Bevern and Till Fluschnik and Oxana
                  Tsidulko},
  title =	 {Parameterized algorithms and data reduction for the
                  short secluded $s$-$t$-path problem},
  journal =	 {Networks},
  year =	 2020,
  date =	 {2020-01-01},
  volume =	 {75},
  number =	 {1},
  pages =	 {34-63},
  url_Preprint = {https://arxiv.org/abs/1806.09540},
  doi =		 {10.1002/net.21904},
  abstract =	 {Given a graph G=(V,E), two vertices s,t∈V, and two
                  integers k,ℓ, we search for a simple s-t-path with
                  at most k vertices and at most ℓ neighbors. For
                  graphs with constant crossing number, we provide a
                  subexponential 2^O(√n)-time algorithm, prove a
                  matching lower bound, and show a polynomial-time
                  data reduction algorithm that reduces any problem
                  instance to an equivalent instance (a so-called
                  problem kernel) of size polynomial in the vertex
                  cover number of the input graph. In contrast, we
                  show that the problem in general graphs is hard to
                  preprocess. We obtain a 2^O(ω)⋅ℓ^2⋅n-time algorithm
                  for graphs of treewidth ω, show that there is no
                  problem kernel with size polynomial in ω, yet show a
                  problem kernels with size polynomial in the feedback
                  edge number of the input graph and with size
                  polynomial in the feedback vertex number, k, and ℓ.}
}

Given a graph G=(V,E), two vertices s,t∈V, and two integers k,ℓ, we search for a simple s-t-path with at most k vertices and at most ℓ neighbors. For graphs with constant crossing number, we provide a subexponential 2^O(√n)-time algorithm, prove a matching lower bound, and show a polynomial-time data reduction algorithm that reduces any problem instance to an equivalent instance (a so-called problem kernel) of size polynomial in the vertex cover number of the input graph. In contrast, we show that the problem in general graphs is hard to preprocess. We obtain a 2^O(ω)⋅ℓ^2⋅n-time algorithm for graphs of treewidth ω, show that there is no problem kernel with size polynomial in ω, yet show a problem kernels with size polynomial in the feedback edge number of the input graph and with size polynomial in the feedback vertex number, k, and ℓ.

@article{BPS19,
  author =	 {René A. van Bevern and Artem V. Pyatkin and Sergey
                  V. Sevastyanov},
  journal =	 {Siberian Electronic Mathematical Reports},
  title =	 {An algorithm with parameterized complexity of
                  constructing the optimal schedule for the routing
                  open shop problem with unit execution times},
  date =	 {2019-01-27},
  year =	 2019,
  volume =	 16,
  pages =	 {42--84},
  doi =		 {10.33048/semi.2019.16.003},
  issn =	 {1813-3304},
  abstract =	 {For the Routing Open Shop problem with unit
                  execution times, the first algorithm with
                  parameterized complexity is designed for
                  constructing an optimal schedule. Its running time
                  is bounded by a function (Pol(|V |) + f(m, g))·|I|,
                  where Pol(|V|) is a polynomial of the number of
                  network nodes, f(m, g) is a function of the number
                  of machines and the number of job locations, and |I|
                  is the input length in its compact encoding.}
}

For the Routing Open Shop problem with unit execution times, the first algorithm with parameterized complexity is designed for constructing an optimal schedule. Its running time is bounded by a function (Pol(|V |) + f(m, g))·|I|, where Pol(|V|) is a polynomial of the number of network nodes, f(m, g) is a function of the number of machines and the number of job locations, and |I| is the input length in its compact encoding.

@proceedings{BK19,
  editor =	 {Ren{\'{e}} van Bevern and Gregory Kucherov},
  title =	 {CSR 2019},
  series =	 {Lecture Notes in Computer Science},
  volume =	 {11532},
  publisher =	 {Springer},
  year =	 {2019},
  doi =		 {10.1007/978-3-030-19955-5},
  timestamp =	 {Tue, 25 Jun 2019 14:30:35 +0200},
  biburl =	 {https://dblp.org/rec/bib/conf/csr/2019},
  bibsource =	 {dblp computer science bibliography,
                  https://dblp.org}
}

@incollection{BTZ19,
  author =	 {Ren{\'{e}} van Bevern and Oxana Tsidulko and Philipp
                  Zschoche},
  year =	 "2019",
  pages =	 "62--74",
  title =	 {Fixed-parameter algorithms for maximum-profit
                  facility location under matroid constraints},
  editor =	 {Pinar Heggernes},
  booktitle =	 {CIAC 2019},
  series =	 {Lecture Notes in Computer Science},
  publisher =	 {Springer},
  volume =	 {11485},
  date =	 {2019-05-27},
  doi =		 {10.1007/978-3-030-17402-6_6},
  abstract =	 {We consider a variant of the matroid median problem
                  introduced by Krishnaswamy et al. [SODA 2011]: an
                  uncapacitated discrete facility location problem
                  where the task is to decide which facilities to open
                  and which clients to serve for maximum profit so
                  that the facilities form an independent set in given
                  facility-side matroids and the clients form an
                  independent set in given client-side matroids. We
                  show that the problem is fixed-parameter tractable
                  parameterized by the number of matroids and the
                  minimum rank among the client-side matroids. To this
                  end, we derive fixed-parameter algorithms for
                  computing representative families for matroid
                  intersections and maximum-weight set packings with
                  multiple matroid constraints. To illustrate the
                  modeling capabilities of the new problem, we use it
                  to obtain algorithms for a problem in social network
                  analysis. We complement our tractability results by
                  lower bounds.}
}

We consider a variant of the matroid median problem introduced by Krishnaswamy et al. [SODA 2011]: an uncapacitated discrete facility location problem where the task is to decide which facilities to open and which clients to serve for maximum profit so that the facilities form an independent set in given facility-side matroids and the clients form an independent set in given client-side matroids. We show that the problem is fixed-parameter tractable parameterized by the number of matroids and the minimum rank among the client-side matroids. To this end, we derive fixed-parameter algorithms for computing representative families for matroid intersections and maximum-weight set packings with multiple matroid constraints. To illustrate the modeling capabilities of the new problem, we use it to obtain algorithms for a problem in social network analysis. We complement our tractability results by lower bounds.

@article{BBN19,
  author =	 {Matthias Bentert and Ren{\'{e}} van Bevern and Rolf
                  Niedermeier},
  journal =	 {Journal of Scheduling},
  date =	 {2019-02-01},
  title =	 {Inductive $k$-independent graphs and $c$-colorable
                  subgraphs in scheduling: A review},
  year =	 2019,
  doi =		 {10.1007/s10951-018-0595-8},
  volume =	 {22},
  number =	 1,
  pages =	 {3--20},
  url_Preprint = {https://arxiv.org/abs/1712.06481},
  url_Poster =
                  {https://www.researchgate.net/publication/342122158_Wireless_Scheduling_Graph_Classes_and_c-Colorable_Subgraphs},
  abstract =	 {Inductive k-independent graphs generalize chordal
                  graphs and have recently been advocated in the
                  context of interference-avoiding wireless
                  communication scheduling. The NP-hard problem of
                  finding maximum-weight induced c-colorable
                  subgraphs, which is a generalization of finding
                  maximum independent sets, naturally occurs when
                  selecting c sets of pairwise non-conflicting jobs
                  (modeled as graph vertices). We investigate the
                  parameterized complexity of this problem on
                  inductive k-independent graphs. We show that the
                  Independent Set problem is W[1]-hard even on
                  2-simplicial 3-minoes---a subclass of inductive
                  2-independent graphs. In contrast, we prove that the
                  more general Maximum c-Colorable Subgraph problem is
                  fixed-parameter tractable on edge-wise unions of
                  cluster and chordal graphs, which are
                  2-simplicial. In both cases, the parameter is the
                  solution size. Aside from this, we survey other
                  graph classes between inductive 1-inductive and
                  inductive 2-inductive graphs with applications in
                  scheduling.}
}

Inductive k-independent graphs generalize chordal graphs and have recently been advocated in the context of interference-avoiding wireless communication scheduling. The NP-hard problem of finding maximum-weight induced c-colorable subgraphs, which is a generalization of finding maximum independent sets, naturally occurs when selecting c sets of pairwise non-conflicting jobs (modeled as graph vertices). We investigate the parameterized complexity of this problem on inductive k-independent graphs. We show that the Independent Set problem is W[1]-hard even on 2-simplicial 3-minoes—a subclass of inductive 2-independent graphs. In contrast, we prove that the more general Maximum c-Colorable Subgraph problem is fixed-parameter tractable on edge-wise unions of cluster and chordal graphs, which are 2-simplicial. In both cases, the parameter is the solution size. Aside from this, we survey other graph classes between inductive 1-inductive and inductive 2-inductive graphs with applications in scheduling.

@incollection{BFT19,
  volume =	 {11548},
  pages =	 {279--294},
  author =	 {Ren{\'{e}} van Bevern and Till Fluschnik and Oxana
                  Tsidulko},
  title =	 {On $(1+\varepsilon)$-approximate data reduction for
                  the {Rural Postman Problem}},
  year =	 2019,
  date =	 {2019-07-06},
  booktitle =	 {MOTOR 2019},
  editor =	 {Michael Khachay and Yury Kochetov and Panos
                  Pardalos},
  series =	 {Lecture Notes in Computer Science},
  publisher =	 {Springer},
  url_Preprint = {https://arxiv.org/abs/1812.10131v1},
  url_Slides =
                  {https://www.researchgate.net/publication/342122216_On_1e-approximate_data_reduction_for_the_Rural_Postman_Problem},
  doi =		 {10.1007/978-3-030-22629-9_20},
  abstract =	 {Given a graph G=(V,E) with edge weights ω:E→N∪{0}
                  and a subset R⊆E of required edges, the Rural
                  Postman Problem (RPP) is to find a closed walk W* of
                  minimum weight ω(W*) containing all edges of R. We
                  prove that RPP is WK[1]-complete parameterized by
                  the number and cost d=ω(W^*)-ω(R)+|W*|-|R| of edges
                  traversed additionally to the required ones, that
                  is, presumably cannot be polynomial-time reduced to
                  solving instances of size polynomial in d. In
                  contrast, denoting by b≤2d the number of vertices
                  incident to an odd number of edges of R and by c≤d
                  the number of connected components formed by the
                  edges in R, we show how to reduce any RPP instance I
                  to an RPP instance I' with 2b+O(c/ε) vertices in
                  O(n³) time so that any α-approximate solution for I'
                  gives an α(1+ε)-approximate solution for I, for any
                  α≥1 and ε>0. That is, we provide a polynomial-size
                  approximate kernelization scheme (PSAKS). We make
                  first steps towards a PSAKS for the parameter c.}
}

Given a graph G=(V,E) with edge weights ω:E→N∪0 and a subset R⊆E of required edges, the Rural Postman Problem (RPP) is to find a closed walk W* of minimum weight ω(W*) containing all edges of R. We prove that RPP is WK[1]-complete parameterized by the number and cost d=ω(W^*)-ω(R)+|W*|-|R| of edges traversed additionally to the required ones, that is, presumably cannot be polynomial-time reduced to solving instances of size polynomial in d. In contrast, denoting by b≤2d the number of vertices incident to an odd number of edges of R and by c≤d the number of connected components formed by the edges in R, we show how to reduce any RPP instance I to an RPP instance I' with 2b+O(c/ε) vertices in O(n³) time so that any α-approximate solution for I' gives an α(1+ε)-approximate solution for I, for any α≥1 and ε>0. That is, we provide a polynomial-size approximate kernelization scheme (PSAKS). We make first steps towards a PSAKS for the parameter c.

@incollection{BFT18,
  author =	 {Ren{\'{e}} van Bevern and Till Fluschnik and Oxana
                  Tsidulko},
  title =	 {Parameterized algorithms and data reduction for safe
                  convoy routing},
  year =	 2018,
  date =	 {2018-08-29},
  doi =		 {10.4230/OASIcs.ATMOS.2018.10},
  editor =	 {Ralf Borndörfer and Sabine Storandt},
  booktitle =	 {ATMOS 2018},
  publisher =	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},
  series =	 {OpenAccess Series in Informatics (OASIcs)},
  pages =	 {10:1--10:19},
  volume =	 65,
  keywords =	 {NP-hard problem, fixed-parameter tractability,
                  problem kernelization, shortest path, secluded
                  solution},
  abstract =	 {We study a problem that models safely routing a
                  convoy through a transportation network, where any
                  vertex adjacent to the travel path of the convoy
                  requires additional precaution: Given a graph
                  G=(V,E), two vertices s,t∈V, and two integers k,ℓ,
                  we search for a simple s-t-path with at most k
                  vertices and at most ℓ neighbors. We study the
                  problem in two types of transportation networks:
                  graphs with small crossing number, as formed by road
                  networks, and tree-like graphs, as formed by
                  waterways. For graphs with constant crossing number,
                  we provide a subexponential 2^O(√n)-time algorithm
                  and prove a matching lower bound. We also show a
                  polynomial-time data reduction algorithm that
                  reduces any problem instance to an equivalent
                  instance (a so-called problem kernel) of size
                  polynomial in the vertex cover number of the input
                  graph. In contrast, we show that the problem in
                  general graphs is hard to preprocess. Regarding
                  tree-like graphs, we obtain a 2^O(tw)⋅ℓ^2⋅n-time
                  algorithm for graphs of treewidth tw, show that
                  there is no problem kernel with size polynomial in
                  tw, yet show a problem kernel with size polynomial
                  in the feedback edge number of the input graph.}
}

We study a problem that models safely routing a convoy through a transportation network, where any vertex adjacent to the travel path of the convoy requires additional precaution: Given a graph G=(V,E), two vertices s,t∈V, and two integers k,ℓ, we search for a simple s-t-path with at most k vertices and at most ℓ neighbors. We study the problem in two types of transportation networks: graphs with small crossing number, as formed by road networks, and tree-like graphs, as formed by waterways. For graphs with constant crossing number, we provide a subexponential 2^O(√n)-time algorithm and prove a matching lower bound. We also show a polynomial-time data reduction algorithm that reduces any problem instance to an equivalent instance (a so-called problem kernel) of size polynomial in the vertex cover number of the input graph. In contrast, we show that the problem in general graphs is hard to preprocess. Regarding tree-like graphs, we obtain a 2^O(tw)⋅ℓ^2⋅n-time algorithm for graphs of treewidth tw, show that there is no problem kernel with size polynomial in tw, yet show a problem kernel with size polynomial in the feedback edge number of the input graph.

@article{MB18,
  title =	 "Parameterized complexity of machine scheduling: 15
                  open problems",
  journal =	 "Computers \& Operations Research",
  volume =	 "100",
  pages =	 "254--261",
  year =	 "2018",
  issn =	 "0305-0548",
  doi =		 "10.1016/j.cor.2018.07.020",
  author =	 "Matthias Mnich and René van Bevern",
  keywords =	 "Parallel machines, Shop scheduling, Makespan, Total
                  completion time, Total tardiness, Throughput, Number
                  of tardy jobs",
  abstract =	 "Machine scheduling problems are a long-time key
                  domain of algorithms and complexity research. A
                  novel approach to machine scheduling problems are
                  fixed-parameter algorithms. To stimulate this
                  thriving research direction, we propose 15 open
                  questions in this area whose resolution we expect to
                  lead to the discovery of new approaches and
                  techniques both in scheduling and parameterized
                  complexity theory.",
  date =	 {2018-08-16},
  url_Preprint = {http://arxiv.org/abs/1709.01670},
  url_Slides =
                  {https://www.researchgate.net/publication/342122033_Open_problems_on_the_parameterized_complexity_of_scheduling_problems}
}

Machine scheduling problems are a long-time key domain of algorithms and complexity research. A novel approach to machine scheduling problems are fixed-parameter algorithms. To stimulate this thriving research direction, we propose 15 open questions in this area whose resolution we expect to lead to the discovery of new approaches and techniques both in scheduling and parameterized complexity theory.

@article{BFK18,
  title =	 {Parameterizing edge modification problems above
                  lower bounds},
  author =	 {René van Bevern and Vincent Froese and Christian
                  Komusiewicz},
  url_Preprint = {http://arxiv.org/abs/1512.04047},
  doi =		 {10.1007/s00224-016-9746-5},
  url_Slides =	 {http://rvb.su/pdf/above-guarantee-editing-csr16.pdf},
  year =	 2018,
  date =	 {2018-04-01},
  journal =	 {Theory of Computing Systems},
  abstract =	 {We study the parameterized complexity of a variant
                  of the F-free Editing problem: Given a graph G and a
                  natural number k, is it possible to modify at most k
                  edges in G so that the resulting graph contains no
                  induced subgraph isomorphic to F?  In our variant,
                  the input additionally contains a vertex-disjoint
                  packing H of induced subgraphs of G, which provides
                  a lower bound h(H) on the number of edge
                  modifications required to transform G into an F-free
                  graph.  While earlier works used the number k as
                  parameter or structural parameters of the input
                  graph G, we consider instead the parameter
                  l:=k-h(H), that is, the number of edge modifications
                  above the lower bound h(H).  We develop a framework
                  of generic data reduction rules to show
                  fixed-parameter tractability with respect to l for
                  K_3-Free Editing, Feedback Arc Set in Tournaments,
                  and Cluster Editing when the packing H contains
                  subgraphs with bounded solution size.  For K_3-Free
                  Editing, we also prove NP-hardness in case of
                  edge-disjoint packings of K_3s and l=0, while for
                  K_q-Free Editing and qge 6, NP-hardness for l=0 even
                  holds for vertex-disjoint packings of K_qs.  In
                  addition, we provide NP-hardness results for F-free
                  Vertex Deletion, were the aim is to delete a minimum
                  number of vertices to make the input graph F-free.},
  keywords =	 {algorithmic graph theory, graph modification,
                  invited, network analysis, NP-hard, parameterized
                  complexity},
  volume =	 "62",
  number =	 "3",
  pages =	 "739--770",
}

We study the parameterized complexity of a variant of the F-free Editing problem: Given a graph G and a natural number k, is it possible to modify at most k edges in G so that the resulting graph contains no induced subgraph isomorphic to F? In our variant, the input additionally contains a vertex-disjoint packing H of induced subgraphs of G, which provides a lower bound h(H) on the number of edge modifications required to transform G into an F-free graph. While earlier works used the number k as parameter or structural parameters of the input graph G, we consider instead the parameter l:=k-h(H), that is, the number of edge modifications above the lower bound h(H). We develop a framework of generic data reduction rules to show fixed-parameter tractability with respect to l for K_3-Free Editing, Feedback Arc Set in Tournaments, and Cluster Editing when the packing H contains subgraphs with bounded solution size. For K_3-Free Editing, we also prove NP-hardness in case of edge-disjoint packings of K_3s and l=0, while for K_q-Free Editing and qge 6, NP-hardness for l=0 even holds for vertex-disjoint packings of K_qs. In addition, we provide NP-hardness results for F-free Vertex Deletion, were the aim is to delete a minimum number of vertices to make the input graph F-free.

@article{BFM+18,
  title =	 {The parameterized complexity of finding secluded
                  solutions to some classical optimization problems on
                  graphs},
  author =	 {René van Bevern and Till Fluschnik and George
                  B. Mertzios and Hendrik Molter and Manuel Sorge and
                  Ondřej Suchý},
  date =	 {2018-11-01},
  year =	 2018,
  journal =	 {Discrete Optimzation},
  volume =	 30,
  pages =	 {20--50},
  url_Preprint = {https://arxiv.org/abs/1606.09000},
  doi =		 {10.1016/j.disopt.2018.05.002},
  abstract =	 {This work studies the parameterized complexity of
                  finding secluded solutions to classical
                  combinatorial optimization problems on graphs such
                  as finding minimum s-t separators, feedback vertex
                  sets, dominating sets, maximum independent sets, and
                  vertex deletion problems for hereditary graph
                  properties: Herein, one searches not only to
                  minimize or maximize the size of the solution, but
                  also to minimize the size of its neighborhood. This
                  restriction has applications in secure routing and
                  community detection.}
}

This work studies the parameterized complexity of finding secluded solutions to classical combinatorial optimization problems on graphs such as finding minimum s-t separators, feedback vertex sets, dominating sets, maximum independent sets, and vertex deletion problems for hereditary graph properties: Herein, one searches not only to minimize or maximize the size of the solution, but also to minimize the size of its neighborhood. This restriction has applications in secure routing and community detection.

@article{BKS17,
  title =	 {A parameterized approximation algorithm for the
                  mixed and windy Capacitated Arc Routing Problem:
                  theory and experiments},
  author =	 {René van Bevern and Christian Komusiewicz and Manuel
                  Sorge},
  journal =	 {Networks},
  volume =	 {70},
  number =	 {3},
  issn =	 {1097-0037},
  doi =		 {10.1002/net.21742},
  pages =	 {262--278},
  keywords =	 {vehicle routing, transportation, Rural Postman,
                  Chinese Postman, NP-hard problem, fixed-parameter
                  algorithm, combinatorial optimization},
  year =	 {2017},
  url_Preprint = {https://arxiv.org/abs/1506.05620},
  url_Slides =
                  {http://rvb.su/pdf/approximation-directed-arc-routing-atmos15.pdf},
  url_Code =	 {https://gitlab.com/rvb/mwcarp-approx},
  date =	 {2017-10-01},
  abstract =	 {We prove that any polynomial-time α(n)-approximation
                  algorithm for the n-vertex metric asymmetric
                  Traveling Salesperson Problem yields a
                  polynomial-time O(α(C))-approximation algorithm for
                  the mixed and windy Capacitated Arc Routing Problem,
                  where C is the number of weakly connected components
                  in the subgraph induced by the positive-demand
                  arcs---a small number in many applications.  In
                  conjunction with known results, we obtain
                  constant-factor approximations for C∈O(log n) and
                  O(log C/log log C)-approximations in general.
                  Experiments show that our algorithm, together with
                  several heuristic enhancements, outperforms many
                  previous polynomial-time heuristics.  Finally, since
                  the solution quality achievable in polynomial time
                  appears to mainly depend on C and since C=1 in
                  almost all benchmark instances, we propose the Ob
                  benchmark set, simulating cities that are divided
                  into several components by a river.}
}

We prove that any polynomial-time α(n)-approximation algorithm for the n-vertex metric asymmetric Traveling Salesperson Problem yields a polynomial-time O(α(C))-approximation algorithm for the mixed and windy Capacitated Arc Routing Problem, where C is the number of weakly connected components in the subgraph induced by the positive-demand arcs—a small number in many applications. In conjunction with known results, we obtain constant-factor approximations for C∈O(log n) and O(log C/log log C)-approximations in general. Experiments show that our algorithm, together with several heuristic enhancements, outperforms many previous polynomial-time heuristics. Finally, since the solution quality achievable in polynomial time appears to mainly depend on C and since C=1 in almost all benchmark instances, we propose the Ob benchmark set, simulating cities that are divided into several components by a river.

@article{BNS17,
  title =	 {A parameterized complexity view on non-preemptively
                  scheduling interval-constrained jobs: few machines,
                  small looseness, and small slack},
  author =	 {René van Bevern and Rolf Niedermeier and Ondřej
                  Suchý},
  url_Preprint = {http://arxiv.org/abs/1508.01657},
  doi =		 {10.1007/s10951-016-0478-9},
  url_Slides =	 {http://rvb.su/pdf/looseness-slack-door16.pdf},
  issn =	 {1094-6136},
  year =	 2017,
  date =	 {2017-06-01},
  journal =	 {Journal of Scheduling},
  publisher =	 {Springer},
  abstract =	 {We study the problem of non-preemptively scheduling
                  n jobs, each job j with a release time t_j, a
                  deadline d_j, and a processing time p_j, on m
                  parallel identical machines.  Cieliebak et
                  al. considered the two constraints |d_j-t_j| ≤ λp_j
                  and |d_j-t_j| ≤ p_j+σ and showed the problem to be
                  NP-hard for any λ>1 and for any σ≥2.  We complement
                  their results by parameterized complexity studies:
                  we show that, for any λ>1, the problem remains
                  weakly NP-hard even for m=2 and strongly W[1]-hard
                  parameterized by m.  We present a
                  pseudo-polynomial-time algorithm for constant m and
                  λ and a fixed-parameter tractability result for the
                  parameter m combined with σ.},
  volume =	 20,
  number =	 3,
  pages =	 {255–265}
}

We study the problem of non-preemptively scheduling n jobs, each job j with a release time t_j, a deadline d_j, and a processing time p_j, on m parallel identical machines. Cieliebak et al. considered the two constraints |d_j-t_j| ≤ λp_j and |d_j-t_j| ≤ p_j+σ and showed the problem to be NP-hard for any λ>1 and for any σ≥2. We complement their results by parameterized complexity studies: we show that, for any λ>1, the problem remains weakly NP-hard even for m=2 and strongly W[1]-hard parameterized by m. We present a pseudo-polynomial-time algorithm for constant m and λ and a fixed-parameter tractability result for the parameter m combined with σ.

@incollection{BFM+17,
  author =	 {René van Bevern and Till Fluschnik and George
                  B. Mertzios and Hendrik Molter and Manuel Sorge and
                  Ondřej Suchý},
  title =	 {Finding Secluded Places of Special Interest in
                  Graphs},
  date =	 {2017-02-10},
  booktitle =	 {IPEC 2016},
  editor =	 {Jiong Guo and Danny Hermelin},
  abstract =	 {Finding a vertex subset in a graph that satisfies a
                  certain property is one of the most-studied topics
                  in algorithmic graph theory. The focus herein is
                  often on minimizing or maximizing the size of the
                  solution, that is, the size of the desired vertex
                  set. In several applications, however, we also want
                  to limit the "exposure" of the solution to the rest
                  of the graph. This is the case, for example, when
                  the solution represents persons that ought to deal
                  with sensitive information or a segregated
                  community. In this work, we thus explore the
                  (parameterized) complexity of finding such secluded
                  vertex subsets for a wide variety of properties that
                  they shall fulfill. More precisely, we study the
                  constraint that the (open or closed) neighborhood of
                  the solution shall be bounded by a parameter and the
                  influence of this constraint on the complexity of
                  minimizing separators, feedback vertex sets, F-free
                  vertex deletion sets, dominating sets, and the
                  maximization of independent sets.},
  pages =	 {5:1--5:16},
  series =	 {Leibniz International Proceedings in Informatics
                  (LIPIcs)},
  ISBN =	 {978-3-95977-023-1},
  ISSN =	 {1868-8969},
  year =	 {2017},
  volume =	 {63},
  publisher =	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},
  doi =		 {10.4230/LIPIcs.IPEC.2016.5},
}

Finding a vertex subset in a graph that satisfies a certain property is one of the most-studied topics in algorithmic graph theory. The focus herein is often on minimizing or maximizing the size of the solution, that is, the size of the desired vertex set. In several applications, however, we also want to limit the "exposure" of the solution to the rest of the graph. This is the case, for example, when the solution represents persons that ought to deal with sensitive information or a segregated community. In this work, we thus explore the (parameterized) complexity of finding such secluded vertex subsets for a wide variety of properties that they shall fulfill. More precisely, we study the constraint that the (open or closed) neighborhood of the solution shall be bounded by a parameter and the influence of this constraint on the complexity of minimizing separators, feedback vertex sets, F-free vertex deletion sets, dominating sets, and the maximization of independent sets.

@article{BBC+17,
  title =	 "Fixed-parameter algorithms for {DAG} Partitioning",
  journal =	 "Discrete Applied Mathematics",
  volume =	 220,
  pages =	 "134--160",
  year =	 2017,
  issn =	 "0166-218X",
  doi =		 "10.1016/j.dam.2016.12.002",
  author =	 "René van Bevern and Robert Bredereck and Morgan
                  Chopin and Sepp Hartung and Falk Hüffner and André
                  Nichterlein and Ondřej Suchý",
  keywords =	 "NP-hard problem",
  keywords =	 "Graph algorithms",
  keywords =	 "Polynomial-time data reduction",
  keywords =	 "Multiway cut",
  keywords =	 "Linear-time algorithms",
  keywords =	 "Algorithm engineering",
  keywords =	 "Evaluating heuristics ",
  abstract =	 "Abstract Finding the origin of short phrases
                  propagating through the web has been formalized by
                  Leskovec et al. (2009) as \{DAG\} Partitioning:
                  given an arc-weighted directed acyclic graph on n
                   vertices and m  arcs, delete arcs with total weight
                  at most  k such that each resulting weakly-connected
                  component contains exactly one sink—a vertex without
                  outgoing arcs. \{DAG\} Partitioning is NP-hard. We
                  show an algorithm to solve \{DAG\} Partitioning in O
                  ( 2 k ⋅ ( n + m ) )  time, that is, in linear time
                  for fixed  k . We complement it with linear-time
                  executable data reduction rules. Our experiments
                  show that, in combination, they can optimally solve
                  \{DAG\} Partitioning on simulated citation networks
                  within five minutes for k ≤ 190 and m being  10 7
                  and larger. We use our obtained optimal solutions to
                  evaluate the solution quality of Leskovec et al.’s
                  heuristic. We show that Leskovec et al.’s heuristic
                  works optimally on trees and generalize this result
                  by showing that \{DAG\} Partitioning is solvable in
                  2 O ( t 2 ) ⋅ n time if a width- t tree
                  decomposition of the input graph is given. Thus, we
                  improve an algorithm and answer an open question of
                  Alamdari and Mehrabian (2012). We complement our
                  algorithms by lower bounds on the running time of
                  exact algorithms and on the effectivity of data
                  reduction. ",
  url_Preprint = {https://arxiv.org/abs/1611.08809},
  url_Code =	 {https://gitlab.com/rvb/dagpart/}
}

Abstract Finding the origin of short phrases propagating through the web has been formalized by Leskovec et al. (2009) as \DAG\ Partitioning: given an arc-weighted directed acyclic graph on n  vertices and m  arcs, delete arcs with total weight at most  k such that each resulting weakly-connected component contains exactly one sink—a vertex without outgoing arcs. \DAG\ Partitioning is NP-hard. We show an algorithm to solve \DAG\ Partitioning in O ( 2 k ⋅ ( n + m ) )  time, that is, in linear time for fixed  k . We complement it with linear-time executable data reduction rules. Our experiments show that, in combination, they can optimally solve \DAG\ Partitioning on simulated citation networks within five minutes for k ≤ 190 and m being  10 7 and larger. We use our obtained optimal solutions to evaluate the solution quality of Leskovec et al.’s heuristic. We show that Leskovec et al.’s heuristic works optimally on trees and generalize this result by showing that \DAG\ Partitioning is solvable in 2 O ( t 2 ) ⋅ n time if a width- t tree decomposition of the input graph is given. Thus, we improve an algorithm and answer an open question of Alamdari and Mehrabian (2012). We complement our algorithms by lower bounds on the running time of exact algorithms and on the effectivity of data reduction.

@incollection{BBNN17,
  author =	 {{Bentert}, M. and R. van Bevern and {Nichterlein},
                  A. and {Niedermeier}, R.},
  title =	 {Parameterized algorithms for power-efficient
                  connected symmetric wireless sensor networks},
  booktitle =	 {ALGOSENSORS 2017},
  editor =	 {Antonio Fernández Anta and Tomasz Jurdzinski and
                  Miguel A. Mosteiro and Yanyong Zhang},
  year =	 2017,
  series =	 {Lecture Notes in Computer Science},
  volume =	 {10718},
  pages =	 "26--40",
  doi =		 "10.1007/978-3-319-72751-6_3",
  url_Slides =
                  {https://www.researchgate.net/publication/328262005_The_min-power_symmetric_connectivity_problem_with_few_obligatory_network_components},
  publisher =	 {Springer},
  date =	 {2017-12-31},
  abstract =	 {We study an NP-hard problem motivated by
                  energy-efficiently maintaining the connectivity of a
                  symmetric wireless sensor communication
                  network. Given an edge-weighted n-vertex graph, find
                  a connected spanning subgraph of minimum cost, where
                  the cost is determined by letting each vertex pay
                  the most expensive edge incident to it in the
                  subgraph. We provide an algorithm that works in
                  polynomial time if one can find a set of obligatory
                  edges that yield a spanning subgraph with O(logn)
                  connected components. We also provide a linear-time
                  algorithm that reduces any input graph that consists
                  of a tree together with g additional edges to an
                  equivalent graph with O(g) vertices. Based on this,
                  we obtain a polynomial-time algorithm for
                  g∈O(logn). On the negative side, we show that
                  o(logn)-approximating the difference d between the
                  optimal solution cost and a natural lower bound is
                  NP-hard and that there are presumably no exact
                  algorithms running in 2o(n) time or in f(d)⋅nO(1)
                  time for any computable function f.}
}

We study an NP-hard problem motivated by energy-efficiently maintaining the connectivity of a symmetric wireless sensor communication network. Given an edge-weighted n-vertex graph, find a connected spanning subgraph of minimum cost, where the cost is determined by letting each vertex pay the most expensive edge incident to it in the subgraph. We provide an algorithm that works in polynomial time if one can find a set of obligatory edges that yield a spanning subgraph with O(logn) connected components. We also provide a linear-time algorithm that reduces any input graph that consists of a tree together with g additional edges to an equivalent graph with O(g) vertices. Based on this, we obtain a polynomial-time algorithm for g∈O(logn). On the negative side, we show that o(logn)-approximating the difference d between the optimal solution cost and a natural lower bound is NP-hard and that there are presumably no exact algorithms running in 2o(n) time or in f(d)⋅nO(1) time for any computable function f.

@article{BBB+17,
  title =	 {Partitioning perfect graphs into stars},
  author =	 {René van Bevern and Robert Bredereck and Laurent
                  Bulteau and Jiehua Chen and Vincent Froese and Rolf
                  Niedermeier and Gerhard J. Woeginger},
  url_Preprint = {http://arxiv.org/abs/1402.2589},
  doi =		 {10.1002/jgt.22062},
  year =	 2017,
  date =	 {2017-06-01},
  journal =	 {Journal of Graph Theory},
  abstract =	 {The partition of graphs into nice subgraphs is a
                  central algorithmic problem with strong ties to
                  matching theory. We study the partitioning of
                  undirected graphs into stars of the same size, a
                  problem known to be NP-complete even for the case of
                  stars on three vertices. We perform a thorough
                  computational complexity study of the problem on
                  subclasses of perfect graphs and identify several
                  polynomial-time solvable cases, for example, on
                  interval graphs and bipartite permutation graphs,
                  and also NP-complete cases, for example, on grid
                  graphs and chordal graphs.},
  volume =	 85,
  number =	 2,
  pages =	 {297--335},
  keywords =	 {algorithmic graph theory}
}

The partition of graphs into nice subgraphs is a central algorithmic problem with strong ties to matching theory. We study the partitioning of undirected graphs into stars of the same size, a problem known to be NP-complete even for the case of stars on three vertices. We perform a thorough computational complexity study of the problem on subclasses of perfect graphs and identify several polynomial-time solvable cases, for example, on interval graphs and bipartite permutation graphs, and also NP-complete cases, for example, on grid graphs and chordal graphs.

@incollection{BP16,
  title =	 {Completing partial schedules for Open Shop with unit
                  processing times and routing},
  doi =		 {10.1007/978-3-319-34171-2_6},
  author =	 {René van Bevern and Artem V. Pyatkin},
  url_Slides =	 {http://rvb.su/pdf/routing-open-shop-csr16.pdf},
  isbn =	 {978-3-319-34170-5},
  year =	 {2016},
  date =	 {2016-05-31},
  booktitle =	 {CSR 2016},
  editor =	 {Alexander S. Kulikov and Gerhard J. Woeginger},
  volume =	 {9691},
  pages =	 {73-87},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {Open Shop is a classical scheduling problem: given a
                  set J of jobs and a set M of machines, find a
                  minimum-makespan schedule to process each job J_i∈J
                  on each machine M_q∈M for a given amount p_iq of
                  time such that each machine processes only one job
                  at a time and each job is processed by only one
                  machine at a time. In Routing Open Shop, the jobs
                  are located in the vertices of an edge-weighted
                  graph G=(V,E) whose edge weights determine the time
                  needed for the machines to travel between
                  jobs. Routing Open Shop is NP-hard for
                  |V|=|M|=2. For the special case of unit processing
                  times p_iq=1, we exploit Galvin's theorem about
                  list-coloring edges of bipartite graphs to prove a
                  theorem that gives a sufficient condition for the
                  completability of partial schedules. Exploiting this
                  schedule completion theorem and integer linear
                  programming, we show that Routing Open Shop with
                  unit processing times is solvable in 2^O(|V||M|^2
                  log |V||M|) poly(|J|)) time, that is,
                  fixed-parameter tractable parameterized by
                  |V|+|M|. Various upper bounds shown using the
                  schedule completion theorem suggest it to be
                  likewise beneficial for the development of
                  approximation algorithms.},
  keywords =	 {NP-hard, parameterized complexity, routing,
                  scheduling}
}

Open Shop is a classical scheduling problem: given a set J of jobs and a set M of machines, find a minimum-makespan schedule to process each job J_i∈J on each machine M_q∈M for a given amount p_iq of time such that each machine processes only one job at a time and each job is processed by only one machine at a time. In Routing Open Shop, the jobs are located in the vertices of an edge-weighted graph G=(V,E) whose edge weights determine the time needed for the machines to travel between jobs. Routing Open Shop is NP-hard for |V|=|M|=2. For the special case of unit processing times p_iq=1, we exploit Galvin's theorem about list-coloring edges of bipartite graphs to prove a theorem that gives a sufficient condition for the completability of partial schedules. Exploiting this schedule completion theorem and integer linear programming, we show that Routing Open Shop with unit processing times is solvable in 2^O(|V||M|^2 log |V||M|) poly(|J|)) time, that is, fixed-parameter tractable parameterized by |V|+|M|. Various upper bounds shown using the schedule completion theorem suggest it to be likewise beneficial for the development of approximation algorithms.

@article{FBNS16,
  title =	 {Exploiting hidden structure in selecting dimensions
                  that distinguish vectors},
  author =	 {Vincent Froese and René van Bevern and Rolf
                  Niedermeier and Manuel Sorge},
  url_Preprint = {http://arxiv.org/abs/1512.01150},
  doi =		 {10.1016/j.jcss.2015.11.011},
  issn =	 {0022-0000},
  year =	 2016,
  date =	 {2016-05-01},
  journal =	 {Journal of Computer and System Sciences},
  volume =	 82,
  number =	 3,
  pages =	 {521--535},
  abstract =	 {The NP-hard Distinct Vectors problem asks to delete
                  as many columns as possible from a matrix such that
                  all rows in the resulting matrix are still pairwise
                  distinct. Our main result is that, for binary
                  matrices, there is a complexity dichotomy for
                  Distinct Vectors based on the maximum (H) and the
                  minimum (h) pairwise Hamming distance between matrix
                  rows: Distinct Vectors can be solved in polynomial
                  time if H≤2⌈h/2⌉+1, and is NP-complete
                  otherwise. Moreover, we explore connections of
                  Distinct Vectors to hitting sets, thereby providing
                  several fixed-parameter tractability and
                  intractability results also for general matrices.}
}

The NP-hard Distinct Vectors problem asks to delete as many columns as possible from a matrix such that all rows in the resulting matrix are still pairwise distinct. Our main result is that, for binary matrices, there is a complexity dichotomy for Distinct Vectors based on the maximum (H) and the minimum (h) pairwise Hamming distance between matrix rows: Distinct Vectors can be solved in polynomial time if H≤2⌈h/2⌉+1, and is NP-complete otherwise. Moreover, we explore connections of Distinct Vectors to hitting sets, thereby providing several fixed-parameter tractability and intractability results also for general matrices.

@article{BKN+16,
  title =	 {H-Index Manipulation by Merging Articles: Models,
                  Theory, and Experiments},
  author =	 {René van Bevern and Christian Komusiewicz and Rolf
                  Niedermeier and Manuel Sorge and Toby Walsh},
  url_Preprint = {http://arxiv.org/abs/1412.5498},
  url_Code =	 {http://fpt.akt.tu-berlin.de/hindex/},
  year =	 2016,
  date =	 {2016-11-01},
  journal =	 {Artificial Intelligence},
  volume =	 240,
  pages =	 {19--35},
  abstract =	 {An author's profile on Google Scholar consists of
                  indexed articles and associated data, such as the
                  number of citations and the H-index. The author is
                  allowed to merge articles, which may affect the
                  H-index. We analyze the (parameterized)
                  computational complexity of maximizing the H-index
                  using article merges. Herein, to model realistic
                  manipulation scenarios, we define a compatibility
                  graph whose edges correspond to plausible
                  merges. Moreover, we consider several different
                  measures for computing the citation count of a
                  merged article. For the measure used by Google
                  Scholar, we give an algorithm that maximizes the
                  H-index in linear time if the compatibility graph
                  has constant-size connected components. In contrast,
                  if we allow to merge arbitrary articles (that is,
                  for arbitrary compatibility graphs), then already
                  increasing the H-index by one is
                  NP-hard. Experiments on Google Scholar profiles of
                  AI researchers show that the H-index can be
                  manipulated substantially only if one merges
                  articles with highly dissimilar titles.},
  doi =		 {10.1016/j.artint.2016.08.001},
  keywords =	 {network analysis, parameterized complexity}
}

An author's profile on Google Scholar consists of indexed articles and associated data, such as the number of citations and the H-index. The author is allowed to merge articles, which may affect the H-index. We analyze the (parameterized) computational complexity of maximizing the H-index using article merges. Herein, to model realistic manipulation scenarios, we define a compatibility graph whose edges correspond to plausible merges. Moreover, we consider several different measures for computing the citation count of a merged article. For the measure used by Google Scholar, we give an algorithm that maximizes the H-index in linear time if the compatibility graph has constant-size connected components. In contrast, if we allow to merge arbitrary articles (that is, for arbitrary compatibility graphs), then already increasing the H-index by one is NP-hard. Experiments on Google Scholar profiles of AI researchers show that the H-index can be manipulated substantially only if one merges articles with highly dissimilar titles.

@incollection{BKM+16,
  title =	 {H-Index Manipulation by Undoing Merges},
  author =	 {René van Bevern and Christian Komusiewicz and
                  Hendrik Molter and Rolf Niedermeier and Manuel Sorge
                  and Toby Walsh},
  doi =		 {10.3233/978-1-61499-672-9-895},
  year =	 {2016},
  date =	 {2016-08-29},
  booktitle =	 {ECAI 2016},
  editor =	 {Gal A. Kaminka and Maria Fox and Paolo Bouquet and
                  Eyke Hüllermeier and Virginia Dignum and Frank
                  Dignum and Frank van Harmelen},
  publisher =	 {IOS Press},
  abstract =	 {The h-index is one of the most important
                  bibliographic measures used to assess the
                  performance of researchers. Van Bevern et
                  al. [Artif. Intel., in press] showed that, despite
                  computational worst-case hardness results,
                  substantial manipulation of the h-index of Google
                  Scholar author profiles is possible by merging
                  articles. Complementing previous work, we study the
                  opposite operation, the splitting of articles, which
                  is arguably the more natural operation for
                  manipulation and which is also allowed within Google
                  Scholar. We present numerous results on
                  computational complexity (from linear-time
                  algorithms to parameterized hardness results) and
                  empirically indicate that at least small
                  improvements of the h-index by splitting merged
                  articles are easily achievable.},
  volume =	 {285},
  pages =	 {895--903},
  series =	 {Frontiers in Artificial Intelligence and
                  Applications},
  keywords =	 {graph modification, NP-hard, parameterized
                  complexity}
}

The h-index is one of the most important bibliographic measures used to assess the performance of researchers. Van Bevern et al. [Artif. Intel., in press] showed that, despite computational worst-case hardness results, substantial manipulation of the h-index of Google Scholar author profiles is possible by merging articles. Complementing previous work, we study the opposite operation, the splitting of articles, which is arguably the more natural operation for manipulation and which is also allowed within Google Scholar. We present numerous results on computational complexity (from linear-time algorithms to parameterized hardness results) and empirically indicate that at least small improvements of the h-index by splitting merged articles are easily achievable.

@incollection{BFK16,
  title =	 {Parameterizing edge modification problems above
                  lower bounds},
  doi =		 {10.1007/978-3-319-34171-2_5},
  author =	 {René van Bevern and Vincent Froese and Christian
                  Komusiewicz},
  url_Slides =	 {http://rvb.su/pdf/above-guarantee-editing-csr16.pdf},
  isbn =	 {978-3-319-34170-5},
  year =	 {2016},
  date =	 {2016-05-31},
  booktitle =	 {CSR 2016},
  editor =	 {Alexander S. Kulikov and Gerhard J. Woeginger},
  volume =	 {9691},
  pages =	 {57-72},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {For a fixed graph F, we study the parameterized
                  complexity of a variant of the F-Free Editing
                  problem: Given a graph G and a natural number k, is
                  it possible to modify at most k edges in G so that
                  the resulting graph contains no induced subgraph
                  isomorphic to F? In our variant, the input
                  additionally contains a vertex-disjoint packing H of
                  induced subgraphs of G, which provides a lower bound
                  h(H) on the number of edge modifications required to
                  transform G into an F-free graph. While earlier
                  works used the number k as parameter or structural
                  parameters of the input graph G, we consider the
                  parameter l:=k-h(H) instead, that is, the number of
                  edge modifications above the lower bound h(H). We
                  show fixed-parameter tractability with respect to l
                  for K_3-Free Editing, Feedback Arc Set in
                  Tournaments, and Cluster Editing when the packing H
                  contains subgraphs with bounded modification
                  cost. For K3-Free Editing, we also prove NP-hardness
                  in case of edge-disjoint packings of K3s and l=0,
                  while for Kq-Free Editing and q≥6, NP-hardness for
                  l=0 even holds for vertex-disjoint packings of Kq.},
  keywords =	 {graph modification, parameterized complexity},
}

For a fixed graph F, we study the parameterized complexity of a variant of the F-Free Editing problem: Given a graph G and a natural number k, is it possible to modify at most k edges in G so that the resulting graph contains no induced subgraph isomorphic to F? In our variant, the input additionally contains a vertex-disjoint packing H of induced subgraphs of G, which provides a lower bound h(H) on the number of edge modifications required to transform G into an F-free graph. While earlier works used the number k as parameter or structural parameters of the input graph G, we consider the parameter l:=k-h(H) instead, that is, the number of edge modifications above the lower bound h(H). We show fixed-parameter tractability with respect to l for K_3-Free Editing, Feedback Arc Set in Tournaments, and Cluster Editing when the packing H contains subgraphs with bounded modification cost. For K3-Free Editing, we also prove NP-hardness in case of edge-disjoint packings of K3s and l=0, while for Kq-Free Editing and q≥6, NP-hardness for l=0 even holds for vertex-disjoint packings of Kq.

@incollection{BBB+16,
  title =	 {Precedence-constrained scheduling problems
                  parameterized by partial order width},
  author =	 {René van Bevern and Robert Bredereck and Laurent
                  Bulteau and Christian Komusiewicz and Nimrod Talmon
                  and Gerhard J. Woeginger},
  url_Preprint = {http://arxiv.org/abs/1605.00901},
  doi =		 {10.1007/978-3-319-44914-2_9},
  url_Slides =	 {http://rvb.su/pdf/p-prec-cmax-door16.pdf},
  year =	 {2016},
  date =	 {2016-09-19},
  booktitle =	 {DOOR 2016},
  editor =	 {Yury Kochetov and Michael Khachay and Vladimir
                  Beresnev and Evgeni Nurminski and Panos Pardalos},
  publisher =	 {Springer},
  abstract =	 {Negatively answering a question posed by Mnich and
                  Wiese (Math. Program. 154(1-2):533-562), we show
                  that P2|prec,pj∈{1,2}|Cmax, the problem of finding a
                  non-preemptive minimum-makespan schedule for
                  precedence-constrained jobs of lengths 1 and 2 on
                  two parallel identical machines, is W[2]-hard
                  parameterized by the width of the partial order
                  giving the precedence constraints. To this end, we
                  show that Shuffle Product, the problem of deciding
                  whether a given word can be obtained by interleaving
                  the letters of k other given words, is W[2]-hard
                  parameterized by k, thus additionally answering a
                  question posed by Rizzi and Vialette (CSR
                  2013). Finally, refining a geometric algorithm due
                  to Servakh
                  (Diskretn. Anal. Issled. Oper. 7(1):75-82), we show
                  that the more general Resource-Constrained Project
                  Scheduling problem is fixed-parameter tractable
                  parameterized by the partial order width combined
                  with the maximum allowed difference between the
                  earliest possible and factual starting time of a
                  job. },
  pages =	 {105-120},
  volume =	 {9869},
  series =	 {Lecture Notes in Computer Science},
  keywords =	 {NP-hard, parameterized complexity, scheduling}
}

Negatively answering a question posed by Mnich and Wiese (Math. Program. 154(1-2):533-562), we show that P2|prec,pj∈1,2|Cmax, the problem of finding a non-preemptive minimum-makespan schedule for precedence-constrained jobs of lengths 1 and 2 on two parallel identical machines, is W[2]-hard parameterized by the width of the partial order giving the precedence constraints. To this end, we show that Shuffle Product, the problem of deciding whether a given word can be obtained by interleaving the letters of k other given words, is W[2]-hard parameterized by k, thus additionally answering a question posed by Rizzi and Vialette (CSR 2013). Finally, refining a geometric algorithm due to Servakh (Diskretn. Anal. Issled. Oper. 7(1):75-82), we show that the more general Resource-Constrained Project Scheduling problem is fixed-parameter tractable parameterized by the partial order width combined with the maximum allowed difference between the earliest possible and factual starting time of a job.

@incollection{BKK+16,
  title =	 {Twins in Subdivision Drawings of Hypergraphs},
  author =	 {René van Bevern and Iyad Kanj and Christian
                  Komusiewicz and Rolf Niedermeier and Manuel Sorge},
  year =	 2016,
  date =	 {2016-12-08},
  booktitle =	 {GD 2016},
  editor =	 {Yifan Hu and Martin Nöllenburg},
  volume =	 {9801},
  series =	 {Lecture Notes in Computer Science},
  publisher =	 {Springer},
  url_Preprint = {http://arxiv.org/abs/1511.09389v4},
  abstract =	 {Visualizing hypergraphs, systems of subsets of some
                  universe, has continuously attracted research
                  interest in the last decades. We study a natural
                  kind of hypergraph visualization called subdivision
                  drawings.  Dinkla et al. [Comput. Graph. Forum ’12]
                  claimed that only few hypergraphs have a subdivision
                  drawing. However, this statement seems to be based
                  on the assumption (also used in previous work) that
                  the input hypergraph does not contain twins, pairs
                  of vertices which are in precisely the same
                  hyperedges (subsets of the universe). We show that
                  such vertices may be necessary for a hypergraph to
                  admit a subdivision drawing. As a counterpart, we
                  show that the number of such “necessary twins” is
                  upper-bounded by a function of the number m of
                  hyperedges and a further parameter r of the desired
                  drawing related to its number of layers. This leads
                  to a linear-time algorithm for determining such
                  subdivision draw- ings if m and r are constant; in
                  other words, the problem is linear-time
                  fixed-parameter tractable with respect to the
                  parameters m and r.},
  keywords =	 {algorithmic graph theory, graph modification},
  pages =	 "67--80",
  isbn =	 "978-3-319-50106-2",
  doi =		 "10.1007/978-3-319-50106-2_6",
}

Visualizing hypergraphs, systems of subsets of some universe, has continuously attracted research interest in the last decades. We study a natural kind of hypergraph visualization called subdivision drawings. Dinkla et al. [Comput. Graph. Forum ’12] claimed that only few hypergraphs have a subdivision drawing. However, this statement seems to be based on the assumption (also used in previous work) that the input hypergraph does not contain twins, pairs of vertices which are in precisely the same hyperedges (subsets of the universe). We show that such vertices may be necessary for a hypergraph to admit a subdivision drawing. As a counterpart, we show that the number of such “necessary twins” is upper-bounded by a function of the number m of hyperedges and a further parameter r of the desired drawing related to its number of layers. This leads to a linear-time algorithm for determining such subdivision draw- ings if m and r are constant; in other words, the problem is linear-time fixed-parameter tractable with respect to the parameters m and r.

@article{BCH+15,
  title =	 {Approximability and parameterized complexity of
                  multicover by $c$-intervals},
  author =	 {René van Bevern and Jiehua Chen and Falk Hüffner and
                  Stefan Kratsch and Nimrod Talmon and Gerhard
                  J. Woeginger},
  url_Preprint =
                  {https://fpt.akt.tu-berlin.de/publications/c-interval-cover-IPL.pdf},
  doi =		 {10.1016/j.ipl.2015.03.004},
  issn =	 {0020-0190},
  year =	 2015,
  date =	 {2015-10-01},
  journal =	 {Information Processing Letters},
  volume =	 115,
  number =	 10,
  pages =	 {744--749},
  abstract =	 {A c-interval is the disjoint union of c intervals over
                  N. The c-Interval Multicover problem is the special
                  case of Set Multicover where all sets available for
                  covering are c-intervals. We strengthen known
                  APX-hardness results for c-Interval Multicover, show
                  W[1]-hardness when parameterized by the solution size,
                  and present fixed-parameter algorithms for alternative
                  parameterizations.},
  keywords =	 {scheduling}
}

A c-interval is the disjoint union of c intervals over N. The c-Interval Multicover problem is the special case of Set Multicover where all sets available for covering are c-intervals. We strengthen known APX-hardness results for c-Interval Multicover, show W[1]-hardness when parameterized by the solution size, and present fixed-parameter algorithms for alternative parameterizations.

@incollection{BKS15,
  title =	 {Approximation Algorithms for Mixed, Windy, and
                  Capacitated Arc Routing Problems},
  doi =		 {10.4230/OASIcs.ATMOS.2015.130},
  author =	 {René van Bevern and Christian Komusiewicz and Manuel
                  Sorge},
  url_Slides =
                  {http://rvb.su/pdf/approximation-directed-arc-routing-atmos15.pdf},
  url_Code =	 {https://gitlab.com/rvb/mwcarp-approx},
  issn =	 {2190-6807},
  year =	 {2015},
  date =	 {2015-09-17},
  booktitle =	 {ATMOS 2015},
  editor =	 {Giuseppe F. Italiano and Marie Schmidt},
  volume =	 {48},
  pages =	 {130--143},
  publisher =	 {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik},
  series =	 {OpenAccess Series in Informatics (OASIcs)},
  abstract =	 {We show that any alpha(n)-approximation algorithm
                  for the n-vertex metric asymmetric Traveling
                  Salesperson problem yields O(alpha(C))-approximation
                  algorithms for various mixed, windy, and capacitated
                  arc routing problems. Herein, C is the number of
                  weakly-connected components in the subgraph induced
                  by the positive-demand arcs, a number that can be
                  expected to be small in applications. In conjunction
                  with known results, we derive constant-factor
                  approximations if C is in O(log n) and
                  O(log(C)/log(log(C)))-approximations in general.},
  keywords =	 {routing},
  url_Code =	 {http://gitlab.com/rvb/mwcarp-approx/},
}

We show that any alpha(n)-approximation algorithm for the n-vertex metric asymmetric Traveling Salesperson problem yields O(alpha(C))-approximation algorithms for various mixed, windy, and capacitated arc routing problems. Herein, C is the number of weakly-connected components in the subgraph induced by the positive-demand arcs, a number that can be expected to be small in applications. In conjunction with known results, we derive constant-factor approximations if C is in O(log n) and O(log(C)/log(log(C)))-approximations in general.

@InCollection{BNSW15,
  author =	 {René van Bevern and Rolf Niedermeier and Manuel
                  Sorge and Mathias Weller},
  booktitle =	 {Arc Routing},
  publisher =	 {SIAM},
  title =	 {Complexity of arc routing problems},
  year =	 {2015},
  chapter =	 {2},
  editor =	 {{\'{A}}ngel Corberán and Gilbert Laporte},
  isbn =	 {978-1-61197-366-2},
  month =	 feb,
  pages =	 {19--52},
  series =	 {MOS-SIAM Series on Optimization},
  type =	 {chapter},
  volume =	 {20},
  doi =		 {10.1137/1.9781611973679.ch2},
  file =	 {BNSW14.pdf:BNSW14.pdf:PDF},
  groups =	 {hs-survey grant},
  keywords =	 {routing},
  timestamp =	 {2020-05-19},
}

@incollection{BKN+15,
  title =	 {H-Index Manipulation by Merging Articles: Models,
                  Theory, and Experiments},
  url =		 {http://ijcai.org/Abstract/15/119},
  author =	 {René van Bevern and Christian Komusiewicz and Rolf
                  Niedermeier and Manuel Sorge and Toby Walsh},
  isbn =	 {978-1-57735-738-4},
  year =	 {2015},
  date =	 {2015-07-01},
  editor =	 {Qiang Yang and Michael J. Wooldridge},
  booktitle =	 {IJCAI 2015},
  pages =	 {808--814},
  publisher =	 {AAAI Press},
  abstract =	 {An author's profile on Google Scholar consists of
                  indexed articles and associated data, such as the
                  number of citations and the H-index. The author is
                  allowed to merge articles, which may affect the
                  H-index. We analyze the parameterized complexity of
                  maximizing the H-index using article merges. Herein,
                  to model realistic manipulation scenarios, we define
                  a compatability graph whose edges correspond to
                  plausible merges. Moreover, we consider multiple
                  possible measures for computing the citation count
                  of a merged article. For the measure used by Google
                  Scholar, we give an algorithm that maximizes the
                  H-index in linear time if the compatibility graph
                  has constant-size connected components. In contrast,
                  if we allow to merge arbitrary articles, then
                  already increasing the H-index by one is
                  NP-hard. Experiments on Google Scholar profiles of
                  AI researchers show that the H-index can be
                  manipulated substantially only by merging articles
                  with highly dissimilar titles, which would be easy
                  to discover.},
  keywords =	 {network analysis},
}

An author's profile on Google Scholar consists of indexed articles and associated data, such as the number of citations and the H-index. The author is allowed to merge articles, which may affect the H-index. We analyze the parameterized complexity of maximizing the H-index using article merges. Herein, to model realistic manipulation scenarios, we define a compatability graph whose edges correspond to plausible merges. Moreover, we consider multiple possible measures for computing the citation count of a merged article. For the measure used by Google Scholar, we give an algorithm that maximizes the H-index in linear time if the compatibility graph has constant-size connected components. In contrast, if we allow to merge arbitrary articles, then already increasing the H-index by one is NP-hard. Experiments on Google Scholar profiles of AI researchers show that the H-index can be manipulated substantially only by merging articles with highly dissimilar titles, which would be easy to discover.

@article{BMNW15,
  title =	 {Interval scheduling and colorful independent sets},
  author =	 {René van Bevern and Matthias Mnich and Rolf
                  Niedermeier and Mathias Weller},
  url_Preprint = {http://arxiv.org/abs/1402.0851},
  doi =		 {10.1007/s10951-014-0398-5},
  url_Code =	 {http://fpt.akt.tu-berlin.de/cis},
  issn =	 {1094-6136},
  year =	 2015,
  date =	 {2015-10-01},
  journal =	 {Journal of Scheduling},
  volume =	 18,
  number =	 5,
  pages =	 {449-469},
  publisher =	 {Springer},
  abstract =	 {Numerous applications in scheduling, such as
                  resource allocation or steel manufacturing, can be
                  modeled using the NP-hard Independent Set problem
                  (given an undirected graph and an integer k, find a
                  set of at least k pairwise non-adjacent
                  vertices). Here, one encounters special graph
                  classes like 2-union graphs (edge-wise unions of two
                  interval graphs) and strip graphs (edge-wise unions
                  of an interval graph and a cluster graph), on which
                  Independent Set remains NP-hard but admits constant
                  ratio approximations in polynomial time. We study
                  the parameterized complexity of Independent Set on
                  2-union graphs and on subclasses like strip
                  graphs. Our investigations significantly benefit
                  from a new structural “compactness” parameter of
                  interval graphs and novel problem formulations using
                  vertex-colored interval graphs. Our main
                  contributions are as follows: 1. We show a
                  complexity dichotomy: restricted to graph classes
                  closed under induced subgraphs and disjoint unions,
                  Independent Set is polynomial-time solvable if both
                  input interval graphs are cluster graphs, and is
                  NP-hard otherwise. 2. We chart the possibilities and
                  limits of effective polynomial-time preprocessing
                  (also known as kernelization). 3. We extend
                  Halldórsson and Karlsson (2006)’s fixed-parameter
                  algorithm for Independent Set on strip graphs
                  parameterized by the structural parameter “maximum
                  number of live jobs” to show that the problem (also
                  known as Job Interval Selection) is fixed-parameter
                  tractable with respect to the parameter k and
                  generalize their algorithm from strip graphs to
                  2-union graphs. Preliminary experiments with random
                  data indicate that Job Interval Selection with up to
                  15 jobs and 5⋅10^5 intervals can be solved optimally
                  in less than 5 min.},
  keywords =	 {scheduling}
}

Numerous applications in scheduling, such as resource allocation or steel manufacturing, can be modeled using the NP-hard Independent Set problem (given an undirected graph and an integer k, find a set of at least k pairwise non-adjacent vertices). Here, one encounters special graph classes like 2-union graphs (edge-wise unions of two interval graphs) and strip graphs (edge-wise unions of an interval graph and a cluster graph), on which Independent Set remains NP-hard but admits constant ratio approximations in polynomial time. We study the parameterized complexity of Independent Set on 2-union graphs and on subclasses like strip graphs. Our investigations significantly benefit from a new structural “compactness” parameter of interval graphs and novel problem formulations using vertex-colored interval graphs. Our main contributions are as follows: 1. We show a complexity dichotomy: restricted to graph classes closed under induced subgraphs and disjoint unions, Independent Set is polynomial-time solvable if both input interval graphs are cluster graphs, and is NP-hard otherwise. 2. We chart the possibilities and limits of effective polynomial-time preprocessing (also known as kernelization). 3. We extend Halldórsson and Karlsson (2006)’s fixed-parameter algorithm for Independent Set on strip graphs parameterized by the structural parameter “maximum number of live jobs” to show that the problem (also known as Job Interval Selection) is fixed-parameter tractable with respect to the parameter k and generalize their algorithm from strip graphs to 2-union graphs. Preliminary experiments with random data indicate that Job Interval Selection with up to 15 jobs and 5⋅10^5 intervals can be solved optimally in less than 5 min.

@article{BDF+15,
  title =	 {Myhill-Nerode Methods for Hypergraphs},
  author =	 {René van Bevern and Rodney G. Downey and Michael
                  R. Fellows and Serge Gaspers and Frances
                  A. Rosamond},
  url_Preprint = {http://arxiv.org/abs/1211.1299},
  doi =		 {10.1007/s00453-015-9977-x},
  url_Slides =
                  {http://rvb.su/pdf/myhill-nerode-hypergraphs-isaac13.pdf},
  issn =	 {0178-4617},
  year =	 2015,
  date =	 {2015-02-27},
  journal =	 {Algorithmica},
  volume =	 73,
  number =	 4,
  pages =	 {696-729},
  publisher =	 {Springer},
  abstract =	 {We give an analog of the Myhill–Nerode theorem from
                  formal language theory for hypergraphs and use it to
                  derive the following results for two NP-hard
                  hypergraph problems. (1) We provide an algorithm for
                  testing whether a hypergraph has cutwidth at most k
                  that runs in linear time for constant k. In terms of
                  parameterized complexity theory, the problem is
                  fixed-parameter linear parameterized by k. (2) We
                  show that it is not expressible in monadic
                  second-order logic whether a hypergraph has bounded
                  (fractional, generalized) hypertree width. The proof
                  leads us to conjecture that, in terms of
                  parameterized complexity theory, these problems are
                  W[1]-hard parameterized by the incidence treewidth
                  (the treewidth of the incidence graph). Thus, in the
                  form of the Myhill–Nerode theorem for hypergraphs,
                  we obtain a method to derive linear-time algorithms
                  and to obtain indicators for intractability for
                  hypergraph problems parameterized by incidence
                  treewidth.},
  keywords =	 {hypergraphs, invited}
}

We give an analog of the Myhill–Nerode theorem from formal language theory for hypergraphs and use it to derive the following results for two NP-hard hypergraph problems. (1) We provide an algorithm for testing whether a hypergraph has cutwidth at most k that runs in linear time for constant k. In terms of parameterized complexity theory, the problem is fixed-parameter linear parameterized by k. (2) We show that it is not expressible in monadic second-order logic whether a hypergraph has bounded (fractional, generalized) hypertree width. The proof leads us to conjecture that, in terms of parameterized complexity theory, these problems are W[1]-hard parameterized by the incidence treewidth (the treewidth of the incidence graph). Thus, in the form of the Myhill–Nerode theorem for hypergraphs, we obtain a method to derive linear-time algorithms and to obtain indicators for intractability for hypergraph problems parameterized by incidence treewidth.

@article{BBC+15,
  title =	 {Network-Based Vertex Dissolution},
  author =	 {René van Bevern and Robert Bredereck and Jiehua Chen
                  and Vincent Froese and Rolf Niedermeier and Gerhard
                  J. Woeginger},
  url_Preprint = {http://arxiv.org/abs/1402.2664},
  doi =		 {10.1137/140978880},
  year =	 2015,
  date =	 {2015-05-01},
  journal =	 {SIAM Journal on Discrete Mathematics},
  volume =	 29,
  number =	 2,
  pages =	 {888-914},
  abstract =	 {We introduce a graph-theoretic vertex dissolution
                  model that applies to a number of redistribution
                  scenarios, such as gerrymandering in political
                  districting or work balancing in an online
                  situation. The central aspect of our model is the
                  deletion of certain vertices and the redistribution
                  of their load to neighboring vertices in a
                  completely balanced way. We investigate how the
                  underlying graph structure, the knowledge of which
                  vertices should be deleted, and the relation between
                  old and new vertex loads influence the computational
                  complexity of the underlying graph problems. Our
                  results establish a clear borderline between
                  tractable and intractable cases.},
  keywords =	 {network analysis}
}

We introduce a graph-theoretic vertex dissolution model that applies to a number of redistribution scenarios, such as gerrymandering in political districting or work balancing in an online situation. The central aspect of our model is the deletion of certain vertices and the redistribution of their load to neighboring vertices in a completely balanced way. We investigate how the underlying graph structure, the knowledge of which vertices should be deleted, and the relation between old and new vertex loads influence the computational complexity of the underlying graph problems. Our results establish a clear borderline between tractable and intractable cases.

@article{BFSS15,
  title =	 {On the Parameterized Complexity of Computing
                  Balanced Partitions in Graphs},
  author =	 {René van Bevern and Andreas Emil Feldmann and Manuel
                  Sorge and Ondřej Suchý},
  url_Preprint = {http://arxiv.org/abs/1312.7014},
  doi =		 {10.1007/s00224-014-9557-5},
  url_Slides =	 {http://rvb.su/pdf/bipartition.pdf},
  issn =	 {1432-4350},
  year =	 2015,
  date =	 {2015-07-08},
  journal =	 {Theory of Computing Systems},
  volume =	 57,
  number =	 1,
  pages =	 {1-35},
  publisher =	 {Springer},
  abstract =	 {A balanced partition is a clustering of a graph into
                  a given number of equal-sized parts. For instance,
                  the Bisection problem asks to remove at most k edges
                  in order to partition the vertices into two
                  equal-sized parts. We prove that Bisection is FPT
                  for the distance to constant cliquewidth if we are
                  given the deletion set. This implies FPT algorithms
                  for some well-studied parameters such as cluster
                  vertex deletion number and feedback vertex
                  set. However, we show that Bisection does not admit
                  polynomial-size kernels for these parameters. For
                  the Vertex Bisection problem, vertices need to be
                  removed in order to obtain two equal-sized parts. We
                  show that this problem is FPT for the number of
                  removed vertices k if the solution cuts the graph
                  into a constant number c of connected
                  components. The latter condition is unavoidable,
                  since we also prove that Vertex Bisection is
                  W[1]-hard w.r.t. (k,c). Our algorithms for finding
                  bisections can easily be adapted to finding
                  partitions into d equal-sized parts, which entails
                  additional running time factors of n^O(d). We show
                  that a substantial speed-up is unlikely since the
                  corresponding task is W[1]-hard w.r.t. d, even on
                  forests of maximum degree two. We can, however, show
                  that it is FPT for the vertex cover number.},
  keywords =	 {graph modification}
}

A balanced partition is a clustering of a graph into a given number of equal-sized parts. For instance, the Bisection problem asks to remove at most k edges in order to partition the vertices into two equal-sized parts. We prove that Bisection is FPT for the distance to constant cliquewidth if we are given the deletion set. This implies FPT algorithms for some well-studied parameters such as cluster vertex deletion number and feedback vertex set. However, we show that Bisection does not admit polynomial-size kernels for these parameters. For the Vertex Bisection problem, vertices need to be removed in order to obtain two equal-sized parts. We show that this problem is FPT for the number of removed vertices k if the solution cuts the graph into a constant number c of connected components. The latter condition is unavoidable, since we also prove that Vertex Bisection is W[1]-hard w.r.t. (k,c). Our algorithms for finding bisections can easily be adapted to finding partitions into d equal-sized parts, which entails additional running time factors of n^O(d). We show that a substantial speed-up is unlikely since the corresponding task is W[1]-hard w.r.t. d, even on forests of maximum degree two. We can, however, show that it is FPT for the vertex cover number.

@article{BHNS14,
  title =	 {Constant-factor approximations for Capacitated Arc
                  Routing without triangle inequality},
  author =	 {René van Bevern and Sepp Hartung and André
                  Nichterlein and Manuel Sorge},
  url_Preprint = {http://arxiv.org/abs/1404.3660},
  doi =		 {10.1016/j.orl.2014.05.002},
  issn =	 {0167-6377},
  year =	 2014,
  date =	 {2014-06-01},
  journal =	 {Operations Research Letters},
  volume =	 42,
  number =	 4,
  pages =	 {290-292},
  abstract =	 {Abstract Given an undirected graph with edge costs
                  and edge demands, the Capacitated Arc Routing
                  problem (CARP) asks for minimum-cost routes for
                  equal-capacity vehicles so as to satisfy all
                  demands. Constant-factor polynomial-time
                  approximation algorithms were proposed for CARP with
                  triangle inequality, while CARP was claimed to be
                  NP-hard to approximate within any constant factor in
                  general. Correcting this claim, we show that any
                  factor α approximation for CARP with triangle
                  inequality yields a factor α approximation for the
                  general CARP.},
  keywords =	 {routing, scheduling}
}

Abstract Given an undirected graph with edge costs and edge demands, the Capacitated Arc Routing problem (CARP) asks for minimum-cost routes for equal-capacity vehicles so as to satisfy all demands. Constant-factor polynomial-time approximation algorithms were proposed for CARP with triangle inequality, while CARP was claimed to be NP-hard to approximate within any constant factor in general. Correcting this claim, we show that any factor α approximation for CARP with triangle inequality yields a factor α approximation for the general CARP.

@incollection{BBC+14b,
  title =	 {Network-Based Dissolution},
  doi =		 {10.1007/978-3-662-44465-8_7},
  author =	 {René van Bevern and Robert Bredereck and Jiehua Chen
                  and Vincent Froese and Rolf Niedermeier and Gerhard
                  J. Woeginger},
  isbn =	 {978-3-662-44464-1},
  year =	 {2014},
  date =	 {2014-08-25},
  booktitle =	 {MFCS 2014},
  editor =	 {Erzsébet Csuhaj-Varjú and Martin Dietzfelbinger and Zoltán Ésik},
  volume =	 {8635},
  pages =	 {69-80},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {We introduce a graph-theoretic dissolution model
                  that applies to a number of redistribution scenarios
                  such as gerrymandering in political districting or
                  work balancing in an online situation. The central
                  aspect of our model is the deletion of certain
                  vertices and the redistribution of their loads to
                  neighboring vertices in a perfectly balanced way. We
                  investigate how the underlying graph structure, the
                  pre-knowledge of which vertices should be deleted,
                  and the relation between old and new vertex loads
                  influence the computational complexity of the
                  underlying graph problems. Our results establish a
                  clear borderline between tractable and intractable
                  cases.},
  keywords =	 {network analysis}
}

We introduce a graph-theoretic dissolution model that applies to a number of redistribution scenarios such as gerrymandering in political districting or work balancing in an online situation. The central aspect of our model is the deletion of certain vertices and the redistribution of their loads to neighboring vertices in a perfectly balanced way. We investigate how the underlying graph structure, the pre-knowledge of which vertices should be deleted, and the relation between old and new vertex loads influence the computational complexity of the underlying graph problems. Our results establish a clear borderline between tractable and intractable cases.

@incollection{BBB+14,
  title =	 {Star Partitions of Perfect Graphs},
  doi =		 {10.1007/978-3-662-43948-7_15},
  author =	 {René van Bevern and Robert Bredereck and Laurent
                  Bulteau and Jiehua Chen and Vincent Froese and Rolf
                  Niedermeier and Gerhard J. Woeginger},
  isbn =	 {978-3-662-43947-0},
  year =	 {2014},
  date =	 {2014-07-01},
  booktitle =	 {ICALP 2014},
  editor =	 {Javier Esparza and Pierre Fraigniaud and Thore Husfeldt and Elias Koutsoupias},
  volume =	 {8572},
  pages =	 {174-185},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {The partition of graphs into nice subgraphs is a
                  central algorithmic problem with strong ties to
                  matching theory. We study the partitioning of
                  undirected graphs into stars, a problem known to be
                  NP-complete even for the case of stars on three
                  vertices. We perform a thorough computational
                  complexity study of the problem on subclasses of
                  perfect graphs and identify several polynomial-time
                  solvable cases, for example, on interval graphs and
                  bipartite permutation graphs, and also NP-hard
                  cases, for example, on grid graphs and chordal
                  graphs.},
  keywords =	 {algorithmic graph theory}
}

The partition of graphs into nice subgraphs is a central algorithmic problem with strong ties to matching theory. We study the partitioning of undirected graphs into stars, a problem known to be NP-complete even for the case of stars on three vertices. We perform a thorough computational complexity study of the problem on subclasses of perfect graphs and identify several polynomial-time solvable cases, for example, on interval graphs and bipartite permutation graphs, and also NP-hard cases, for example, on grid graphs and chordal graphs.

@article{Bev14b,
  title =	 {Towards Optimal and Expressive Kernelization for
                  $d$-Hitting Set},
  author =	 {René van Bevern},
  url_Preprint = {http://arxiv.org/abs/1112.2310v3},
  doi =		 {10.1007/s00453-013-9774-3},
  url_Slides =
                  {http://rvb.su/pdf/towards-optimal-and-expressive-kernelization-for-hitting-set-63tt.pdf},
  url_Code =	 {http://fpt.akt.tu-berlin.de/hslinkern/},
  issn =	 {0178-4617},
  year =	 2014,
  date =	 {2014-09-01},
  journal =	 {Algorithmica},
  volume =	 70,
  number =	 1,
  pages =	 {129-147},
  publisher =	 {Springer},
  abstract =	 {A sunflower in a hypergraph is a set of hyperedges
                  pairwise intersecting in exactly the same vertex
                  set. Sunflowers are a useful tool in polynomial-time
                  data reduction for problems formalizable as
                  d-Hitting Set, the problem of covering all
                  hyperedges (whose cardinality is bounded from above
                  by a constant d) of a hypergraph by at most k
                  vertices. Additionally, in fault diagnosis,
                  sunflowers yield concise explanations for “highly
                  defective structures”. We provide a linear-time
                  algorithm that, by finding sunflowers, transforms an
                  instance of d-Hitting Set into an equivalent
                  instance comprising at most O(k^d) hyperedges and
                  vertices. In terms of parameterized complexity, we
                  show a problem kernel with asymptotically optimal
                  size (unless coNP⊆NP/poly) and provide experimental
                  results that show the practical applicability of our
                  algorithm. Finally, we show that the number of
                  vertices can be reduced to O(k^(d−1)) with
                  additional processing in O(k^(1.5d))
                  time—nontrivially combining the sunflower technique
                  with problem kernels due to Abu-Khzam and Moser.},
  keywords =	 {hypergraphs, invited}
}

A sunflower in a hypergraph is a set of hyperedges pairwise intersecting in exactly the same vertex set. Sunflowers are a useful tool in polynomial-time data reduction for problems formalizable as d-Hitting Set, the problem of covering all hyperedges (whose cardinality is bounded from above by a constant d) of a hypergraph by at most k vertices. Additionally, in fault diagnosis, sunflowers yield concise explanations for “highly defective structures”. We provide a linear-time algorithm that, by finding sunflowers, transforms an instance of d-Hitting Set into an equivalent instance comprising at most O(k^d) hyperedges and vertices. In terms of parameterized complexity, we show a problem kernel with asymptotically optimal size (unless coNP⊆NP/poly) and provide experimental results that show the practical applicability of our algorithm. Finally, we show that the number of vertices can be reduced to O(k^(d−1)) with additional processing in O(k^(1.5d)) time—nontrivially combining the sunflower technique with problem kernels due to Abu-Khzam and Moser.

@incollection{FBNS13,
  title =	 {A Parameterized Complexity Analysis of Combinatorial
                  Feature Selection Problems},
  doi =		 {10.1007/978-3-642-40313-2_40},
  author =	 {Vincent Froese and René van Bevern and Rolf
                  Niedermeier and Manuel Sorge},
  isbn =	 {978-3-642-40312-5},
  year =	 {2013},
  date =	 {2013-08-26},
  booktitle =	 {MFCS 2013},
  editor =	 {Krishnendu Chatterjee and Jirí Sgall},
  volume =	 {8087},
  pages =	 {445-456},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {We examine the algorithmic tractability of NP-hard
                  combinatorial feature selection problems in terms of
                  parameterized complexity theory. In combinatorial
                  feature selection, one seeks to discard dimensions
                  from high-dimensional data such that the resulting
                  instances fulfill a desired property. In
                  parameterized complexity analysis, one seeks to
                  identify relevant problem-specific quantities and
                  tries to determine their influence on the
                  computational complexity of the considered
                  problem. In this paper, for various combinatorial
                  feature selection problems, we identify
                  parameterizations and reveal to what extent these
                  govern computational complexity. We provide
                  tractability as well as intractability results; for
                  example, we show that the Distinct Vectors problem
                  on binary points is polynomial-time solvable if each
                  pair of points differs in at most three dimensions,
                  whereas it is NP-hard otherwise.},
}

We examine the algorithmic tractability of NP-hard combinatorial feature selection problems in terms of parameterized complexity theory. In combinatorial feature selection, one seeks to discard dimensions from high-dimensional data such that the resulting instances fulfill a desired property. In parameterized complexity analysis, one seeks to identify relevant problem-specific quantities and tries to determine their influence on the computational complexity of the considered problem. In this paper, for various combinatorial feature selection problems, we identify parameterizations and reveal to what extent these govern computational complexity. We provide tractability as well as intractability results; for example, we show that the Distinct Vectors problem on binary points is polynomial-time solvable if each pair of points differs in at most three dimensions, whereas it is NP-hard otherwise.

@incollection{BFGR13,
  title =	 {Myhill-Nerode Methods for Hypergraphs},
  doi =		 {10.1007/978-3-642-45030-3_35},
  author =	 {René van Bevern and Michael R. Fellows and Serge
                  Gaspers and Frances A. Rosamond},
  url_Slides =
                  {http://rvb.su/pdf/myhill-nerode-hypergraphs-isaac13.pdf},
  isbn =	 {978-3-642-45029-7},
  year =	 {2013},
  date =	 {2013-12-13},
  booktitle =	 {ISAAC 2013},
  editor =	 {Leizhen Cai and Siu-Wing Cheng and Tak-Wah Lam},
  volume =	 {8283},
  pages =	 {372-382},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {We introduce a method of applying Myhill-Nerode
                  methods from formal language theory to hypergraphs
                  and show how this method can be used to obtain the
                  following parameterized complexity
                  results. Hypergraph Cutwidth (deciding whether a
                  hypergraph on n vertices has cutwidth at most k) is
                  linear-time solvable for constant k. For hypergraphs
                  of constant incidence treewidth (treewidth of the
                  incidence graph), Hypertree Width and variants
                  cannot be solved by simple finite tree automata. The
                  proof leads us to conjecture that Hypertree Width is
                  W[1]-hard for this parameter.},
  keywords =	 {hypergraphs}
}

We introduce a method of applying Myhill-Nerode methods from formal language theory to hypergraphs and show how this method can be used to obtain the following parameterized complexity results. Hypergraph Cutwidth (deciding whether a hypergraph on n vertices has cutwidth at most k) is linear-time solvable for constant k. For hypergraphs of constant incidence treewidth (treewidth of the incidence graph), Hypertree Width and variants cannot be solved by simple finite tree automata. The proof leads us to conjecture that Hypertree Width is W[1]-hard for this parameter.

@incollection{BFSS13,
  title =	 {On the Parameterized Complexity of Computing Graph
                  Bisections},
  doi =		 {10.1007/978-3-642-45043-3_8},
  author =	 {René van Bevern and Andreas Emil Feldmann and Manuel
                  Sorge and Ondřej Suchý},
  isbn =	 {978-3-642-45042-6},
  year =	 {2013},
  date =	 {2013-06-19},
  booktitle =	 {WG 2013},
  editor =	 {Andreas Brandstädt and Klaus Jansen and Rüdiger Reischuk},
  volume =	 {8165},
  pages =	 {76-87},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {The Bisection problem asks for a partition of the
                  vertices of a graph into two equally sized sets,
                  while minimizing the cut size. This is the number of
                  edges connecting the two vertex sets. Bisection has
                  been thoroughly studied in the past. However, only
                  few results have been published that consider the
                  parameterized complexity of this problem. We show
                  that Bisection is FPT w.r.t. the minimum cut size if
                  there is an optimum bisection that cuts into a given
                  constant number of connected components. Our
                  algorithm applies to the more general Balanced
                  Biseparator problem where vertices need to be
                  removed instead of edges. We prove that this problem
                  is W[1]-hard w.r.t. the minimum cut size and the
                  number of cut out components. For Bisection we
                  further show that no polynomial-size kernels exist
                  for the cut size parameter. In fact, we show this
                  for all parameters that are polynomial in the input
                  size and that do not increase when taking disjoint
                  unions of graphs. We prove fixed-parameter
                  tractability for the distance to constant
                  cliquewidth if we are given the deletion set. This
                  implies fixed-parameter algorithms for some
                  well-studied parameters such as cluster vertex
                  deletion number and feedback vertex set.},
  url_Slides =	 {http://rvb.su/pdf/bipartition.pdf},
  keywords =	 {graph modification}
}

The Bisection problem asks for a partition of the vertices of a graph into two equally sized sets, while minimizing the cut size. This is the number of edges connecting the two vertex sets. Bisection has been thoroughly studied in the past. However, only few results have been published that consider the parameterized complexity of this problem. We show that Bisection is FPT w.r.t. the minimum cut size if there is an optimum bisection that cuts into a given constant number of connected components. Our algorithm applies to the more general Balanced Biseparator problem where vertices need to be removed instead of edges. We prove that this problem is W[1]-hard w.r.t. the minimum cut size and the number of cut out components. For Bisection we further show that no polynomial-size kernels exist for the cut size parameter. In fact, we show this for all parameters that are polynomial in the input size and that do not increase when taking disjoint unions of graphs. We prove fixed-parameter tractability for the distance to constant cliquewidth if we are given the deletion set. This implies fixed-parameter algorithms for some well-studied parameters such as cluster vertex deletion number and feedback vertex set.

@incollection{BBC+13,
  title =	 {Parameterized Complexity of {DAG} Partitioning},
  doi =		 {10.1007/978-3-642-38233-8_5},
  author =	 {René van Bevern and Robert Bredereck and Morgan
                  Chopin and Sepp Hartung and Falk Hüffner and André
                  Nichterlein and Ondřej Suchý},
  isbn =	 {978-3-642-38232-1},
  year =	 {2013},
  date =	 {2013-05-22},
  booktitle =	 {CIAC 2013},
  editor =	 {Paul G. Spirakis and Maria Serna},
  volume =	 {7878},
  pages =	 {49-60},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {The goal of tracking the origin of short,
                  distinctive phrases (memes) that propagate through
                  the web in reaction to current events has been
                  formalized as DAG Partitioning: given a directed
                  acyclic graph, delete edges of minimum weight such
                  that each resulting connected component of the
                  underlying undirected graph contains only one
                  sink. Motivated by NP-hardness and hardness of
                  approximation results, we consider the parameterized
                  complexity of this problem. We show that it can be
                  solved in O(2^k·n^2) time, where k is the number of
                  edge deletions, proving fixed-parameter tractability
                  for parameter k. We then show that unless the
                  Exponential Time Hypothesis (ETH) fails, this cannot
                  be improved to 2^o(k)·n^O(1); further, DAG
                  Partitioning does not have a polynomial kernel
                  unless NP ⊆ coNP/poly. Finally, given a tree
                  decomposition of width w, we show how to solve DAG
                  Partitioning in 2^O(w^2)⋅n time, improving a known
                  algorithm for the parameter pathwidth.},
  keywords =	 {graph modification, network analysis},
}

The goal of tracking the origin of short, distinctive phrases (memes) that propagate through the web in reaction to current events has been formalized as DAG Partitioning: given a directed acyclic graph, delete edges of minimum weight such that each resulting connected component of the underlying undirected graph contains only one sink. Motivated by NP-hardness and hardness of approximation results, we consider the parameterized complexity of this problem. We show that it can be solved in O(2^k·n^2) time, where k is the number of edge deletions, proving fixed-parameter tractability for parameter k. We then show that unless the Exponential Time Hypothesis (ETH) fails, this cannot be improved to 2^o(k)·n^O(1); further, DAG Partitioning does not have a polynomial kernel unless NP ⊆ coNP/poly. Finally, given a tree decomposition of width w, we show how to solve DAG Partitioning in 2^O(w^2)⋅n time, improving a known algorithm for the parameter pathwidth.

@article{SBNW12,
  title =	 {A new view on Rural Postman based on Eulerian
                  Extension and Matching},
  author =	 {Manuel Sorge and René van Bevern and Rolf Niedermeier
                  and Mathias Weller},
  url_Preprint =
                  {http://fpt.akt.tu-berlin.de/publications/A_New_View_on_Rural_Postman_Based_on_Eulerian_Extension_and_Matching-JDA.pdf},
  doi =		 {10.1016/j.jda.2012.04.007},
  issn =	 {1570-8667},
  year =	 2012,
  date =	 {2012-10-01},
  journal =	 {Journal of Discrete Algorithms},
  volume =	 16,
  pages =	 {12--33},
  abstract =	 {We provide a new characterization of the NP-hard arc
                  routing problem Rural Postman in terms of a
                  constrained variant of minimum-weight perfect matching
                  on bipartite graphs. To this end, we employ a
                  parameterized equivalence between Rural Postman and
                  Eulerian Extension, a natural arc addition problem in
                  directed multigraphs. We indicate the NP-hardness of
                  the introduced matching problem. In particular, we use
                  the matching problem to make partial progress towards
                  answering the open question about the parameterized
                  complexity of Rural Postman with respect to the
                  parameter “number of weakly connected components in
                  the graph induced by the required arcs”. This is a
                  more than thirty years open and long-neglected
                  question with significant practical relevance.},
  keywords =	 {graph modification, invited, routing}
}

We provide a new characterization of the NP-hard arc routing problem Rural Postman in terms of a constrained variant of minimum-weight perfect matching on bipartite graphs. To this end, we employ a parameterized equivalence between Rural Postman and Eulerian Extension, a natural arc addition problem in directed multigraphs. We indicate the NP-hardness of the introduced matching problem. In particular, we use the matching problem to make partial progress towards answering the open question about the parameterized complexity of Rural Postman with respect to the parameter “number of weakly connected components in the graph induced by the required arcs”. This is a more than thirty years open and long-neglected question with significant practical relevance.

@article{BMN12,
  title =	 {Approximation and Tidying---A Problem Kernel for
                  $s$-Plex Cluster Vertex Deletion},
  author =	 {René van Bevern and Hannes Moser and Rolf Niedermeier},
  url_Preprint =
                  {http://www.akt.tu-berlin.de/fileadmin/fg34/publications-akt/approximation-and-tidying.pdf},
  url_Slides =	 {http://rvb.su/pdf/kernelization-through-tidying-talk-latin10.pdf},
  doi =		 {10.1007/s00453-011-9492-7},
  issn =	 {0178-4617},
  year =	 2012,
  date =	 {2012-04-01},
  journal =	 {Algorithmica},
  volume =	 62,
  number =	 {3-4},
  pages =	 {930-950},
  publisher =	 {Springer},
  abstract =	 {We introduce the NP-hard graph-based data clustering
                  problem s-Plex Cluster Vertex Deletion, where the task
                  is to delete at most k vertices from a graph so that
                  the connected components of the resulting graph are
                  s-plexes. In an s-plex, every vertex has an edge to
                  all but at most s−1 other vertices; cliques are
                  1-plexes. We propose a new method based on
                  “approximation and tidying” for kernelizing vertex
                  deletion problems whose goal graphs can be
                  characterized by forbidden induced subgraphs. The
                  method exploits polynomial-time approximation results
                  and thus provides a useful link between approximation
                  and kernelization. Employing “approximation and
                  tidying”, we develop data reduction rules that, in
                  O(ksn^2) time, transform an s-Plex Cluster Vertex
                  Deletion instance with n vertices into an equivalent
                  instance with O(k^2 s^3) vertices, yielding a problem
                  kernel. To this end, we also show how to exploit
                  structural properties of the specific problem in order
                  to significantly improve the running time of the
                  proposed kernelization method.},
  keywords =	 {graph modification}
}

We introduce the NP-hard graph-based data clustering problem s-Plex Cluster Vertex Deletion, where the task is to delete at most k vertices from a graph so that the connected components of the resulting graph are s-plexes. In an s-plex, every vertex has an edge to all but at most s−1 other vertices; cliques are 1-plexes. We propose a new method based on “approximation and tidying” for kernelizing vertex deletion problems whose goal graphs can be characterized by forbidden induced subgraphs. The method exploits polynomial-time approximation results and thus provides a useful link between approximation and kernelization. Employing “approximation and tidying”, we develop data reduction rules that, in O(ksn^2) time, transform an s-Plex Cluster Vertex Deletion instance with n vertices into an equivalent instance with O(k^2 s^3) vertices, yielding a problem kernel. To this end, we also show how to exploit structural properties of the specific problem in order to significantly improve the running time of the proposed kernelization method.

@incollection{BMNW12,
  title =	 {Interval Scheduling and Colorful Independent Sets},
  doi =		 {10.1007/978-3-642-35261-4_28},
  author =	 {René van Bevern and Matthias Mnich and Rolf
                  Niedermeier and Mathias Weller},
  isbn =	 {978-3-642-35260-7},
  year =	 {2012},
  date =	 {2012-12-19},
  booktitle =	 {ISAAC 2012},
  editor =	 {Kun-Mao Chao and Tsan-sheng Hsu and Der-Tsai Lee},
  volume =	 {7676},
  pages =	 {247--256},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {The NP-hard Independent Set problem is to determine
                  for a given graph G and an integer k whether G
                  contains a set of k pairwise non-adjacent
                  vertices. The problem has numerous applications in
                  scheduling, including resource allocation and steel
                  manufacturing. There, one encounters restricted
                  graph classes such as 2-union graphs, which are
                  edge-wise unions of two interval graphs on the same
                  vertex set, or strip graphs, where additionally one
                  of the two interval graphs is a disjoint union of
                  cliques. We prove NP-hardness of Independent Set on
                  a very restricted subclass of 2-union graphs and
                  identify natural parameterizations to chart the
                  possibilities and limitations of effective
                  polynomial-time preprocessing (kernelization) and
                  fixed-parameter algorithms. Our algorithms benefit
                  from novel formulations of the computational
                  problems in terms of (list-)colored interval
                  graphs.},
  keywords =	 {scheduling}
}

The NP-hard Independent Set problem is to determine for a given graph G and an integer k whether G contains a set of k pairwise non-adjacent vertices. The problem has numerous applications in scheduling, including resource allocation and steel manufacturing. There, one encounters restricted graph classes such as 2-union graphs, which are edge-wise unions of two interval graphs on the same vertex set, or strip graphs, where additionally one of the two interval graphs is a disjoint union of cliques. We prove NP-hardness of Independent Set on a very restricted subclass of 2-union graphs and identify natural parameterizations to chart the possibilities and limitations of effective polynomial-time preprocessing (kernelization) and fixed-parameter algorithms. Our algorithms benefit from novel formulations of the computational problems in terms of (list-)colored interval graphs.

@incollection{BHK+11,
  title =	 {Linear-Time Computation of a Linear Problem Kernel
                  for Dominating Set on Planar Graphs},
  author =	 {René van Bevern and Sepp Hartung and Frank Kammer
                  and Rolf Niedermeier and Mathias Weller},
  url_Preprint =
                  {http://fpt.akt.tu-berlin.de/publications/Linear-Time_Computation_of_a_Linear_Problem_Kernel_for_Dominating_set_on_Planar_Graphs-IPEC.pdf},
  url_Slides =
                  {http://rvb.su/pdf/linear-time-linear-kernel-dominating-set.pdf},
  doi =		 {10.1007/978-3-642-28050-4_16},
  isbn =	 {978-3-642-28049-8},
  year =	 {2012},
  date =	 {2012-09-06},
  booktitle =	 {IPEC 2011},
  editor =	 {Dániel Marx and Peter Rossmanith},
  volume =	 {7112},
  pages =	 {194--206},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {We present a linear-time kernelization algorithm
                  that transforms a given planar graph G with
                  domination number γ(G) into a planar graph G' of
                  size O(γ(G)) with γ(G) = γ(G'). In addition, a
                  minimum dominating set for G can be inferred from a
                  minimum dominating set for G'. In terms of
                  parameterized algorithmics, this implies a
                  linear-size problem kernel for the NP-hard
                  Dominating Set problem on planar graphs, where the
                  kernelization takes linear time. This improves on
                  previous kernelization algorithms that provide
                  linear-size kernels in cubic time.},
  keywords =	 {algorithmic graph theory}
}

We present a linear-time kernelization algorithm that transforms a given planar graph G with domination number γ(G) into a planar graph G' of size O(γ(G)) with γ(G) = γ(G'). In addition, a minimum dominating set for G can be inferred from a minimum dominating set for G'. In terms of parameterized algorithmics, this implies a linear-size problem kernel for the NP-hard Dominating Set problem on planar graphs, where the kernelization takes linear time. This improves on previous kernelization algorithms that provide linear-size kernels in cubic time.

@incollection{Bev12,
  title =	 {Towards Optimal and Expressive Kernelization for
                  $d$-Hitting Set},
  doi =		 {10.1007/978-3-642-32241-9_11},
  author =	 {René van Bevern},
  url_Slides =
                  {http://rvb.su/pdf/towards-optimal-and-expressive-kernelization-for-hitting-set-63tt.pdf},
  isbn =	 {978-3-642-32240-2},
  year =	 {2012},
  date =	 {2012-08-20},
  booktitle =	 {COCOON 2012},
  editor =	 {Joachim Gudmundsson and Julián Mestre and Taso Viglas},
  volume =	 {7434},
  pages =	 {121-132},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {A sunflower in a hypergraph is a set of hyperedges
                  pairwise intersecting in exactly the same vertex
                  set. Sunflowers are a useful tool in polynomial-time
                  data reduction for problems formalizable as
                  d-Hitting Set, the problem of covering all
                  hyperedges (of cardinality at most d) of a
                  hypergraph by at most k vertices. Additionally, in
                  fault diagnosis, sunflowers yield concise
                  explanations for “highly defective structures”. We
                  provide a linear-time algorithm that, by finding
                  sunflowers, transforms an instance of d-Hitting Set
                  into an equivalent instance comprising at most
                  O(k^d) hyperedges and vertices. In terms of
                  parameterized complexity, we show a problem kernel
                  with asymptotically optimal size (unless
                  coNP ⊆ NP/poly). We show that the number of vertices
                  can be reduced to O(k^(d−1)) with additional
                  processing in O(k^(1.5d)) time—nontrivially
                  combining the sunflower technique with problem
                  kernels due to Abu-Khzam and Moser.},
  keywords =	 {hypergraphs}
}

A sunflower in a hypergraph is a set of hyperedges pairwise intersecting in exactly the same vertex set. Sunflowers are a useful tool in polynomial-time data reduction for problems formalizable as d-Hitting Set, the problem of covering all hyperedges (of cardinality at most d) of a hypergraph by at most k vertices. Additionally, in fault diagnosis, sunflowers yield concise explanations for “highly defective structures”. We provide a linear-time algorithm that, by finding sunflowers, transforms an instance of d-Hitting Set into an equivalent instance comprising at most O(k^d) hyperedges and vertices. In terms of parameterized complexity, we show a problem kernel with asymptotically optimal size (unless coNP ⊆ NP/poly). We show that the number of vertices can be reduced to O(k^(d−1)) with additional processing in O(k^(1.5d)) time—nontrivially combining the sunflower technique with problem kernels due to Abu-Khzam and Moser.

@incollection{SBNW11,
  title =	 {From Few Components to an Eulerian Graph by Adding
                  Arcs},
  author =	 {Manuel Sorge and René van Bevern and Rolf
                  Niedermeier and Mathias Weller},
  url_Preprint =
                  {http://fpt.akt.tu-berlin.de/publications/From_Few_Components_to_an_Eulerian_Graph_by_Adding_Arcs-WG.pdf},
  doi =		 {10.1007/978-3-642-25870-1_28},
  isbn =	 {978-3-642-25869-5},
  year =	 {2011},
  date =	 {2011-06-21},
  booktitle =	 {WG 2011},
  editor =	 {Petr Kolman and Jan Kratochvíl},
  volume =	 {6986},
  pages =	 {307--318},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {Eulerian Extension (EE) is the problem to make an
                  arc-weighted directed multigraph Eulerian by adding
                  arcs of minimum total cost. EE is NP-hard and has
                  been shown fixed-parameter tractable with respect to
                  the number of arc additions. Complementing this
                  result, on the way to answering an open question, we
                  show that EE is fixed-parameter tractable with
                  respect to the combined parameter “number of
                  connected components in the underlying undirected
                  multigraph” and “sum of indeg(v) - outdeg(v) over
                  all vertices v in the input multigraph where this
                  value is positive.” Moreover, we show that EE is
                  unlikely to admit a polynomial-size problem kernel
                  for this parameter combination and for the parameter
                  “number of arc additions”.},
  keywords =	 {graph modification, routing}
}

Eulerian Extension (EE) is the problem to make an arc-weighted directed multigraph Eulerian by adding arcs of minimum total cost. EE is NP-hard and has been shown fixed-parameter tractable with respect to the number of arc additions. Complementing this result, on the way to answering an open question, we show that EE is fixed-parameter tractable with respect to the combined parameter “number of connected components in the underlying undirected multigraph” and “sum of indeg(v) - outdeg(v) over all vertices v in the input multigraph where this value is positive.” Moreover, we show that EE is unlikely to admit a polynomial-size problem kernel for this parameter combination and for the parameter “number of arc additions”.

@article{BBF+11,
  title =	 {Parameterized Algorithmics for Finding Connected
                  Motifs in Biological Networks},
  author =	 {Nadja Betzler and René van Bevern and Michael
                  R. Fellows and Christian Komusiewicz and Rolf
                  Niedermeier},
  url_Preprint =
                  {http://www.akt.tu-berlin.de/fileadmin/fg34/publications-akt/finding-connected-motifs-in-biological-networks.pdf},
  url_Code =	 {http://fpt.akt.tu-berlin.de/graph-motif/},
  doi =		 {10.1109/TCBB.2011.19},
  issn =	 {1545-5963},
  year =	 2011,
  date =	 {2011-09-01},
  journal =	 {IEEE/ACM Transactions on Computational Biology and
                  Bioinformatics},
  volume =	 8,
  number =	 5,
  pages =	 {1296-1308},
  abstract =	 {We study the NP-hard LIST-COLORED GRAPH MOTIF problem
                  which, given an undirected list-colored graph G = (V,
                  E) and a multiset M of colors, asks for
                  maximum-cardinality sets S ⊆ V and M' ⊆ M such that
                  G[S] is connected and contains exactly (with respect
                  to multiplicity) the colors in M'. LIST-COLORED GRAPH
                  MOTIF has applications in the analysis of biological
                  networks. We study LIST-COLORED GRAPH MOTIF with
                  respect to three different parameterizations. For the
                  parameters motif size |M| and solution size |S|, we
                  present fixed-parameter algorithms, whereas for the
                  parameter |V| - |M|, we show W[1]-hardness for general
                  instances and achieve fixed-parameter tractability for
                  a special case of LIST-COLORED GRAPH MOTIF. We
                  implemented the fixed-parameter algorithms for
                  parameters |M| and |S|, developed further speed-up
                  heuristics for these algorithms, and applied them in
                  the context of querying protein-interaction networks,
                  demonstrating their usefulness for realistic
                  instances. Furthermore, we show that extending the
                  request for motif connectedness to stronger demands,
                  such as biconnectedness or bridge-connectedness leads
                  to W[1]-hard problems when the parameter is the motif
                  size |M|.},
  keywords =	 {network analysis}
}

We study the NP-hard LIST-COLORED GRAPH MOTIF problem which, given an undirected list-colored graph G = (V, E) and a multiset M of colors, asks for maximum-cardinality sets S ⊆ V and M' ⊆ M such that G[S] is connected and contains exactly (with respect to multiplicity) the colors in M'. LIST-COLORED GRAPH MOTIF has applications in the analysis of biological networks. We study LIST-COLORED GRAPH MOTIF with respect to three different parameterizations. For the parameters motif size |M| and solution size |S|, we present fixed-parameter algorithms, whereas for the parameter |V| - |M|, we show W[1]-hardness for general instances and achieve fixed-parameter tractability for a special case of LIST-COLORED GRAPH MOTIF. We implemented the fixed-parameter algorithms for parameters |M| and |S|, developed further speed-up heuristics for these algorithms, and applied them in the context of querying protein-interaction networks, demonstrating their usefulness for realistic instances. Furthermore, we show that extending the request for motif connectedness to stronger demands, such as biconnectedness or bridge-connectedness leads to W[1]-hard problems when the parameter is the motif size |M|.

@incollection{BMN10,
  title =	 {Kernelization through Tidying---A Case Study Based
                  on $s$-Plex Cluster Vertex Deletion},
  author =	 {René van Bevern and Hannes Moser and Rolf
                  Niedermeier},
  isbn =	 {978-3-642-12199-9},
  url_Slides =
                  {http://rvb.su/pdf/kernelization-through-tidying-talk-latin10.pdf},
  year =	 {2010},
  date =	 {2010-04-19},
  booktitle =	 {LATIN 2010},
  editor =	 {Alejandro López-Ortiz},
  volume =	 {6034},
  pages =	 {527-538},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {We introduce the NP-hard graph-based data clustering
                  problem s-Plex Cluster Vertex Deletion, where the
                  task is to delete at most k vertices from a graph so
                  that the connected components of the resulting graph
                  are s-plexes. In an s-plex, every vertex has an edge
                  to all but at most s−1 other vertices; cliques are
                  1-plexes. We propose a new method for kernelizing a
                  large class of vertex deletion problems and
                  illustrate it by developing an O(k^2 s^3)-vertex
                  problem kernel for s-Plex Cluster Vertex Deletion
                  that can be computed in O(ksn^2) time, where n is
                  the number of graph vertices. The corresponding
                  “kernelization through tidying” exploits
                  polynomial-time approximation results.},
  doi =		 {10.1007/978-3-642-12200-2_46},
  keywords =	 {graph modification}
}

We introduce the NP-hard graph-based data clustering problem s-Plex Cluster Vertex Deletion, where the task is to delete at most k vertices from a graph so that the connected components of the resulting graph are s-plexes. In an s-plex, every vertex has an edge to all but at most s−1 other vertices; cliques are 1-plexes. We propose a new method for kernelizing a large class of vertex deletion problems and illustrate it by developing an O(k^2 s^3)-vertex problem kernel for s-Plex Cluster Vertex Deletion that can be computed in O(ksn^2) time, where n is the number of graph vertices. The corresponding “kernelization through tidying” exploits polynomial-time approximation results.

@incollection{BKMN10,
  title =	 {Measuring Indifference: Unit Interval Vertex
                  Deletion},
  author =	 {René van Bevern and Christian Komusiewicz and Hannes
                  Moser and Rolf Niedermeier},
  url_Preprint =
                  {http://www.akt.tu-berlin.de/fileadmin/fg34/publications-akt/unit-interval-vertex-deletion-wg10.pdf},
  doi =		 {10.1007/978-3-642-16926-7_22},
  url_Slides =
                  {http://rvb.su/pdf/unit-interval-vertex-deletion-talk-wg2010.pdf},
  isbn =	 {978-3-642-16925-0},
  year =	 {2010},
  date =	 {2010-06-28},
  booktitle =	 {WG 2010},
  editor =	 {Dimitrios M. Thilikos},
  volume =	 {6410},
  pages =	 {232--243},
  publisher =	 {Springer},
  series =	 {Lecture Notes in Computer Science},
  abstract =	 {Making a graph unit interval by a minimum number of
                  vertex deletions is NP-hard. The problem is
                  motivated by applications in seriation and measuring
                  indifference between data items. We present a
                  fixed-parameter algorithm based on the iterative
                  compression technique that finds in
                  O((14k+14)^(k+1)kn^6) time a set of k vertices whose
                  deletion from an n-vertex graph makes it unit
                  interval. Additionally, we show that making a graph
                  chordal by at most k vertex deletions is NP-complete
                  even on claw,net,tent-free graphs.},
  keywords =	 {algorithmic graph theory, graph modification}
}

Making a graph unit interval by a minimum number of vertex deletions is NP-hard. The problem is motivated by applications in seriation and measuring indifference between data items. We present a fixed-parameter algorithm based on the iterative compression technique that finds in O((14k+14)^(k+1)kn^6) time a set of k vertices whose deletion from an n-vertex graph makes it unit interval. Additionally, we show that making a graph chordal by at most k vertex deletions is NP-complete even on claw,net,tent-free graphs.