4 research outputs found

    Fast Algorithms for Parameterized Problems with Relaxed Disjointness Constraints

    Full text link
    In parameterized complexity, it is a natural idea to consider different generalizations of classic problems. Usually, such generalization are obtained by introducing a "relaxation" variable, where the original problem corresponds to setting this variable to a constant value. For instance, the problem of packing sets of size at most pp into a given universe generalizes the Maximum Matching problem, which is recovered by taking p=2p=2. Most often, the complexity of the problem increases with the relaxation variable, but very recently Abasi et al. have given a surprising example of a problem --- rr-Simple kk-Path --- that can be solved by a randomized algorithm with running time O(2O(klogrr))O^*(2^{O(k \frac{\log r}{r})}). That is, the complexity of the problem decreases with rr. In this paper we pursue further the direction sketched by Abasi et al. Our main contribution is a derandomization tool that provides a deterministic counterpart of the main technical result of Abasi et al.: the O(2O(klogrr))O^*(2^{O(k \frac{\log r}{r})}) algorithm for (r,k)(r,k)-Monomial Detection, which is the problem of finding a monomial of total degree kk and individual degrees at most rr in a polynomial given as an arithmetic circuit. Our technique works for a large class of circuits, and in particular it can be used to derandomize the result of Abasi et al. for rr-Simple kk-Path. On our way to this result we introduce the notion of representative sets for multisets, which may be of independent interest. Finally, we give two more examples of problems that were already studied in the literature, where the same relaxation phenomenon happens. The first one is a natural relaxation of the Set Packing problem, where we allow the packed sets to overlap at each element at most rr times. The second one is Degree Bounded Spanning Tree, where we seek for a spanning tree of the graph with a small maximum degree

    A time- and space-optimal algorithm for the many-visits TSP

    Full text link
    The many-visits traveling salesperson problem (MV-TSP) asks for an optimal tour of nn cities that visits each city cc a prescribed number kck_c of times. Travel costs may be asymmetric, and visiting a city twice in a row may incur a non-zero cost. The MV-TSP problem finds applications in scheduling, geometric approximation, and Hamiltonicity of certain graph families. The fastest known algorithm for MV-TSP is due to Cosmadakis and Papadimitriou (SICOMP, 1984). It runs in time nO(n)+O(n3logckc)n^{O(n)} + O(n^3 \log \sum_c k_c ) and requires nΘ(n)n^{\Theta(n)} space. An interesting feature of the Cosmadakis-Papadimitriou algorithm is its \emph{logarithmic} dependence on the total length ckc\sum_c k_c of the tour, allowing the algorithm to handle instances with very long tours. The \emph{superexponential} dependence on the number of cities in both the time and space complexity, however, renders the algorithm impractical for all but the narrowest range of this parameter. In this paper we improve upon the Cosmadakis-Papadimitriou algorithm, giving an MV-TSP algorithm that runs in time 2O(n)2^{O(n)}, i.e.\ \emph{single-exponential} in the number of cities, using \emph{polynomial} space. Our algorithm is deterministic, and arguably both simpler and easier to analyse than the original approach of Cosmadakis and Papadimitriou. It involves an optimization over directed spanning trees and a recursive, centroid-based decomposition of trees.Comment: Small fixes, journal versio

    Generalized Set and Graph Packing Problems

    Get PDF
    Many complex systems that exist in nature and society can be expressed in terms of networks (e.g., social networks, communication networks, biological networks, Web graph, among others). Usually a node represents an entity while an edge represents an interaction between two entities. A community arises in a network when two or more entities have common interests, e.g., related proteins, industrial sectors, groups of people, documents of a collection. There exist applications that model a community as a fixed graph H [98, 10, 119, 2, 142, 136]. Additionally, it is not expected that an entity of the network belongs to only one community; that is, communities tend to share their members. The community discovering or community detection problem consists on finding all communities in a given network. This problem has been extensively studied from a practical perspective [61, 137, 122, 116]. However, we believe that this problem also brings many interesting theoretical questions. Thus in this thesis, we will address this problem using a more rigorous approach. To that end, we first introduce graph problems that we consider capture well the community discovering problem. These graph problems generalize the classical H-Packing problem [88] in two different ways. In the H-Packing with t-Overlap problem, the goal is to find in a given graph G (the network) at least k subgraphs (the communities) isomorphic to a member of a family of graphs H (the community models) such that each pair of subgraphs overlaps in at most t vertices (the shared members). On the other hand, in the H-Packing with t-Membership problem instead of limiting the pairwise overlap, each vertex of G is contained in at most t subgraphs of the solution. For both problems each member of H has at most r vertices and m edges. An instance of the H-Packing with t-Overlap and t-Membership problems corresponds to an instance of the H-Packing problem for t = 0 and t = 1, respectively. We also restrict the overlap between the edges of the subgraphs in the solution instead of the vertices (called H-Packing with t-Edge Overlap and t-Edge Membership problems). Given the closeness of the r-Set Packing problem [87] to the H-Packing problem, we also consider overlap in the problem of packing disjoint sets of size at most r. As usual for set packing problems, given a collection S drawn from a universe U, we seek a sub-collection S'⊆S consisting of at least k sets subject to certain disjointness restrictions. In the r-Set Packing with t-Membership, each element of U belongs to at most t sets of S' while in the r-Set Packing with t-Overlap each pair of sets in S' overlaps in at most t elements. For both problems, each set of S has at most r elements. We refer to all the problems introduced in this thesis simply as packing problems with overlap. Also, we group as the family of t-Overlap problems: H-Packing with t-Overlap, H-Packing with t-Edge Overlap, and r-Set Packing with t-Overlap. While we call the family of t-Membership problems: H-Packing with t-Membership, H-Packing with t-Edge Membership, and r-Set Packing with t-Membership. The classical H-Packing and r-Set Packing problems are NP-complete [87, 88]. We will show in this thesis that allowing overlap in a packing does not make the problems "easier". More precisely, we show that the H-Packing with t-Membership and the r-Set Packing with t-Membership are NP-complete when H = {H'} and H' is an arbitrary connected graph with at least three vertices and r≥3, respectively. Parameterized complexity, introduced by Downey and Fellows [44], is an exciting and interesting approach to deal with NP-complete problems. The underlying idea of this approach is to isolate some aspects or parts of the input (known as the parameters) to investigate whether these parameters make the problem tractable or intractable. The main goal of this thesis is to study the parameterized complexity of our packing problems with overlap. We set up as a parameter k the size of the solution (number of communities), and we consider as fixed-constants r, m and t. We show that our problems admit polynomial kernels via two types of techniques: polynomial parametric transformations (PPTs) [16] and classical reduction algorithms [43]. PPTs are mainly used to show lower bounds and as far as we know they have not been used as extensively to obtain kernel results as classical kernelization techniques [96, 42]. Thus, we believe that employing PPTs is a promising approach to obtain kernel reductions for other problems as well. On the other hand, with non-trivial generalizations of kernelization algorithms for the classical H-Packing problem [114], we are able to improve our kernel sizes obtained via PPTs. These improved kernel sizes are equivalent to the kernel sizes for the disjoint version when t = 0 and t = 1 for the t-Overlap and t-Membership problems, respectively. We also obtain fixed-parameter algorithms for our packing problems with overlap (other than running brute force on the kernel). Our algorithms combine a search tree and a greedy localization technique and generalize a fixed-parameter algorithm for the problem of packing disjoint triangles [54]. In addition, we obtain faster FPT-algorithms by transforming our overlapping problems into an instance of the disjoint version of our problems. Finally, we introduce the Π-Packing with α()-Overlap problem to allow for more complex overlap constraints than the ones considered by the t-Overlap and t-Membership problems and also to include more general communities definitions. This problem seeks at least k induced subgraphs in a graph G subject to: each subgraph has at most r vertices and obeys a property Π (a community definition) and for any pair of subgraphs Hi,Hj, with i≠j, we have that α(Hi,Hj) = 0 holds (an overlap constraint). We show that the Π-Packing with α()-Overlap problem is fixed-parameter tractable provided that Π is computable in polynomial time in n and α() obeys some natural conditions. Motivated by practical applications we give several examples of α() functions which meet those conditions
    corecore