Zvi Gotthilf

Improved algorithms for the k simple shortest paths and the replacement paths problems

Given a directed, non-negatively weighted graph G=(V,E) and s,t@?V, we consider two problems. In the k simple shortest paths problem, we want to find the k simple paths from s to t with the k smallest weights. In the replacement paths problem, we want the shortest path from s to t that avoids e, for every edge e in the original shortest path from s to t. The best known algorithm for the k simple shortest paths problem has a running of O(k(mn+n^2logn)). For the replacement paths problem the best known result is the trivial one running in time O(mn+n^2logn). In this paper we present two simple algorithms for the replacement paths problem and the k simple shortest paths problem in weighted directed graphs (using a solution of the All Pairs Shortest Paths problem). The running time of our algorithm for the replacement paths problem is O(mn+n^2loglogn). For the k simple shortest paths we will perform O(k) iterations of the second simple shortest path (each in O(mn+n^2loglogn) running time) using a useful property of Roditty and Zwick [L. Roditty, U. Zwick, Replacement paths and k simple shortest paths in unweighted directed graphs, in: Proc. of International Conference on Automata, Languages and Programming (ICALP), 2005, pp. 249-260]. These running times immediately improve the best known results for both problems over sparse graphs. Moreover, we prove that both the replacement paths and the k simple shortest paths (for constant k) problems are not harder than APSP (All Pairs Shortest Paths) in weighted directed graphs.

Constrained LCS: Hardness and Approximation

The problem of finding the longest common subsequence (LCS) of two given strings A 1 and A 2 is a well-studied problem. The constrained longest common subsequence (C-LCS) for three strings A 1 , A 2 and B 1 is the longest common subsequence of A 1 and A 2 that contains B 1 as a subsequence. The fastest algorithm solving the C-LCS problem has a time complexity of O(m 1 m 2 n 1 ) where m 1 , m 2 and n 1 are the lengths of A 1 , A 2 and B 1 respectively. In this paper we consider two general variants of the C-LCS problem. First we show that in case of two input strings and an arbitrary number of constraint strings, it is NP-hard to approximate the C-LCS problem. Moreover, it is easy to see that in case of an arbitrary number of input strings and a single constraint, the problem of finding the constrained longest common subsequence is NP-hard. Therefore, we propose a linear time approximation algorithm for this variant, our algorithm yields a

Tighter approximations for maximum induced matchings in regular graphs

1 / \sqrt{m_{min}|\Sigma|}

Restricted common superstring and restricted common supersequence

approximation factor, where m min is the length of the shortest input string and |Σ| is the size of the alphabet.

On shortest common superstring and swap permutations

An induced matching is a matching in which each two edges of the matching are not connected by a joint edge. Induced matchings are well-studied combinatorial objects and a lot of consideration has been given to finding maximum induced matchings, which is an NP-complete problem. Specifically, finding maximum induced matchings in regular graphs is well-known to be NP-complete. A couple of papers lately showed a couple of simple greedy algorithm that approximate a maximum induced matching with a factor of

A

d - {\frac{1}{2}}

(2 - c \frac{\log {n}}{n})

and d−1 (different papers – different factors), where d is the degree of regularity. We show here a simple algorithm with an 0.75d + 0.15 approximation factor. The algorithm is simple – the analysis is not.

Approximation Algorithm for the Minimum Maximal Matching Problem

The shortest common superstring and the shortest common supersequence are two well studied problems having a wide range of applications. In this paper we consider both problems with resource constraints, denoted as the Restricted Common Superstring (shortly RCSstr) problem and the Restricted Common Supersequence (shortly RCSseq). In the RCSstr (RCSseq) problem we are given a set S of n strings, s1, s2, ..., sn, and a multiset t = {t1, t2, ..., tm}, and the goal is to find a permutation π : {1,..., m} → {1, ..., m} to maximize the number of strings in S that are substrings (subsequences) of π(t) = tπ(1) tπ(2) ... tπ(m) (we call this ordering of the multiset, π(t), a permutation of t). We first show that in its most general setting the RC-Sstr problem is NP-complete and hard to approximate within a factor of n1-e, for any e > 0, unless P = NP. Afterwards, we present two separate reductions to show that the RCSstr problem remains NP-Hard even in the case where the elements of t are drawn from a binary alphabet or for the case where all input strings are of length two. We then present some approximation results for several variants of the RCSstr problem. In the second part of this paper, we turn to the RCSseq problem, where we present some hardness results, tight lower bounds and approximation algorithms.

Improved Approximation Results on the Shortest Common Supersequence Problem

The Shortest Common Superstring (SCS) is a well studied problem, having a wide range of applications. In this paper we consider two problems closely related to it. First we define the Swapped Restricted Superstring(SRS) problem, where we are given a set S of n strings, s1, s2, . . . , sn, and a text T = t1t2 . . . tm, and our goal is to find a swap permutation π : {1, . . . ,m} → {1, . . . , m} to maximize the number of strings in S that are substrings of tπ(1)tπ(2) . . . tπ(m). We then show that the SRS problem is NP-Complete. Afterwards, we consider a similar variant denoted SRSR, where our goal is to find a swap permutation π : {1, . . . , m} → {1, . . . , m} to maximize the total number of times that the strings of S appear in tπ(1)tπ(2) . . . tπ(m) (we can count the same string si as a substring of tπ(1)tπ(2) . . . tπ(m) more than once). For this problem, we present a polynomial time exact algorithm.

Approximating constrained Lcs

We consider the problem of finding a maximal matching of minimum size, given an unweighted general graph. This problem is a well studied and it is known to be NP-hard even for some restricted classes of graphs. Moreover, in case of general graphs, it is NP-hard to approximate the Minimum Maximal Matching (shortly MMM) within any constant factor smaller than 7 . The current best known approximation algorithm is the straightforward algorithm which yields an approximation ratio of 2. We propose the first nontrivial algorithm yields an approximation ratio of 2−c log n n , for an arbitrarily positive constant c. Our algorithm is based on the local search technique and utilizes an approximate solution of the Minimum Weighted Maximal Matching problem in order to achieve the desirable approximation ratio.