Search

Reachability and shortest path problems are NL-complete for general graphs. They are known to be in L for graphs of tree-width 2 (Jakoby and Tantau in Proceedings of FSTTCS'07: The 27th Annual Conference on Foundations of Software Technology and Theoretical Computer Science, pp. 216-227, ). In this paper, we improve these bounds for k-trees, where k is a constant. In particular, the main results of our paper are log-space algorithms for reachability in directed k-trees, and for computation of shortest and longest paths in directed acyclic k-trees. Besides the path problems mentioned above, we also consider the problem of deciding whether a k-tree has a perfect matching (decision version), and if so, finding a perfect matching (search version), and prove that these two problems are L-complete. These problems are known to be in P and in RNC for general graphs, and in SPL for planar bipartite graphs, as shown in Datta et al. (Theory Comput. Syst. 47:737-757, ). Our results settle the complexity of these problems for the class of k-trees. The results are also applicable for bounded tree-width graphs, when a tree-decomposition is given as input. The technique central to our algorithms is a careful implementation of the divide-and-conquer approach in log-space, along with some ideas from Jakoby and Tantau (Proceedings of FSTTCS'07: The 27th Annual Conference on Foundations of Software Technology and Theoretical Computer Science, pp. 216-227, ) and Limaye et al. (Theory Comput. Syst. 46(3):499-522, ). [ABSTRACT FROM AUTHOR]

Grammar-based compression, where one replaces a long string by a small context-free grammar that generates the string, is a simple and powerful paradigm that captures many popular compression schemes. Given a grammar, the random access problem is to compactly represent the grammar while supporting random access, that is, given a position in the original uncompressed string report the character at that position. In this paper we study the random access problem with the finger search property, that is, the time for a random access query should depend on the distance between a specified index f, called the finger, and the query index i. We consider both a static variant, where we first place a finger and subsequently access indices near the finger efficiently, and a dynamic variant where also moving the finger such that the time depends on the distance moved is supported. Let n be the size the grammar, and let N be the size of the string. For the static variant we give a linear space representation that supports placing the finger in O(log N) time and subsequently accessing in O(log D) time, where D is the distance between the finger and the accessed index. For the dynamic variant we give a linear space representation that supports placing the finger in O(log N) time and accessing and moving the finger in O(log D + log log N) time. Compared to the best linear space solution to random access, we improve a O(log N) query bound to O(log D) for the static variant and to O(log D + log log N) for the dynamic variant, while maintaining linear space. As an application of our results we obtain an improved solution to the longest common extension problem in grammar compressed strings. To obtain our results, we introduce several new techniques of independent interest, including a novel van Emde Boas style decomposition of grammars. [ABSTRACT FROM AUTHOR]

We consider combinatorial algorithms for the minimum-cost flow problem on networks with unit capacities, and special cases of the problem. Historically, researchers have developed special-purpose algorithms that exploit unit capacities. In contrast, for the maximum flow problem, the classical blocking flow and push-relabel algorithms for the general case also have the best bounds known for the special case of unit capacities. In this paper we show that the classical blocking flow push-relabel cost-scaling algorithms of Goldberg and Tarjan (Math. Oper. Res. 15, 430-466, 1990) for general minimum-cost flow problems achieve the best known bounds for unit-capacity problems as well. We also develop a cycle-canceling algorithm that extends Goldberg's shortest path algorithm (Goldberg SIAM J. Comput. 24, 494-504, 1995) to minimum-cost, unit-capacity flow problems. Finally, we combine our ideas to obtain an algorithm that solves the minimum-cost bipartite matching problem in $O(r^{1/2} m \log C)$ time, where m is the number of edges, C is the largest arc cost (assumed to be greater than 1), and r is the number of vertices on the small side of the vertex bipartition. This result generalizes (and simplifies) a result of Duan et al. (2011) and solves an open problem of Ramshaw and Tarjan (2012). [ABSTRACT FROM AUTHOR]

Some measures of randomness have been introduced for Martin-Löf randomness such as K-reducibility, C-reducibility and vL-reducibility. In this paper we study Schnorr-randomness versions of these reducibilities. In particular, we characterize the computably-traceable reducibility via relative Schnorr randomness, which was asked in Nies' book [Nies , Problem 8.4.22]. We also show that Schnorr reducibility implies uniform-Schnorr-randomness version of vL-reducibility, which is the Schnorr-randomness version of the result that K-reducibility implies vL-reducibility. [ABSTRACT FROM AUTHOR]

In this paper, a compressed membership problem for finite automata, both deterministic (DFAs) and non-deterministic (NFAs), with compressed transition labels is studied. The compression is represented by straight-line programs (SLPs), i.e. context-free grammars generating exactly one string. A novel technique of dealing with SLPs is employed: the SLPs are recompressed, so that substrings of the input word are encoded in SLPs labelling the transitions of the NFA (DFA) in the same way, as in the SLP representing the input text. To this end, the SLPs are locally decompressed and then recompressed in a uniform way. Furthermore, in order to reflect the recompression in the NFA, we need to modify it only a little, in particular its size stays polynomial in the input size. Using this technique it is shown that the compressed membership for NFA with compressed labels is in NP, thus confirming the conjecture of Plandowski and Rytter (Jewels Are Forever, pp. 262-272, Springer, Berlin, ) and extending the partial result of Lohrey and Mathissen (in CSR, LNCS, vol. 6651, pp. 275-288, Springer, Berlin, ); as this problem is known to be NP-hard (in Plandowski and Rytter, Jewels Are Forever, pp. 262-272, Springer, Berlin, ), we settle its exact computational complexity. Moreover, the same technique applied to the compressed membership for DFA with compressed labels yields that this problem is in P, and this problem is known to be P-hard (in Markey and Schnoebelen, Inf. Process. Lett. 90(1):3-6, ; Beaudry et al., SIAM J. Comput. 26(1):138-152, ). [ABSTRACT FROM AUTHOR]

The Travelling Salesman Problem is one of the fundamental and intensively studied problems in approximation algorithms. For more than 30 years, the best algorithm known for general metrics has been Christofides's algorithm with an approximation factor of $\frac{3}{2}$, even though the so-called Held-Karp LP relaxation of the problem is conjectured to have the integrality gap of only $\frac{4}{3}$. Very recently, significant progress has been made for the important special case of graphic metrics, first by Oveis Gharan et al. (FOCS, 550-559, ), and then by Mömke and Svensson (FOCS, 560-569, ). In this paper, we provide an improved analysis of the approach presented in Mömke and Svensson (FOCS, 560-569, ) yielding a bound of $\frac{13}{9}$ on the approximation factor, as well as a bound of $\frac{19}{12}+\varepsilon$ for any ε>0 for a more general Travelling Salesman Path Problem in graphic metrics. [ABSTRACT FROM AUTHOR]

This paper continues the STACS contribution by Diekert, Ushakov, and the author as well as the IJAC publication by the same authors. We extend the results published there in two ways. First, we show that the data structure of power circuits can be generalized to work with arbitrary bases q≥2. This results in a data structure that can hold huge integers, arising by iteratively forming powers of q. We show that the properties of power circuits known for q=2 translate to the general case. This generalization is non-trivial and additional techniques are required to preserve the time bounds of arithmetic operations that were shown for the case q=2. The extended power circuit model permits us to conduct operations in the Baumslag-Solitar group BS(1, q) as efficiently as in BS(1,2). This allows us to solve the word problem in the generalization H(1, q) of Higman's group in polynomial time. The group H(1, q) is an amalgamated product of four copies of the Baumslag-Solitar group BS(1, q) rather than BS(1,2) in the original group H= H(1,2). As a second result, we allow arbitrary numbers f≥4 of copies of BS(1, q), leading to an even more generalized notion of Higman groups H(1, q). We prove that the word problem of the latter can still be solved within the ${\mathcal {O}}(n^{6})$ time bound that was shown for H(1,2). [ABSTRACT FROM AUTHOR]

We study probabilistic bit-probe schemes for the membership problem. Given a set A of at most n elements from the universe of size m we organize such a structure that queries of type ' x∈ A? ' can be answered very quickly. H. Buhrman, P.B. Miltersen, J. Radhakrishnan, and S. Venkatesh proposed a randomized bit-probe scheme that needs space of O( nlog m) bits. That scheme has a randomized algorithm processing queries; it needs to read only one randomly chosen bit from the memory to answer a query. For every x the answer is correct with high probability (with two-sided errors). In this paper we slightly modify the bit-probe model of Buhrman et al. and consider schemes with a small auxiliary information in 'cache' memory. In this model, we show that for the membership problem there exists a bit-probe scheme with one-sided error that needs space of O( nlog m+poly(log m)) bits, which cannot be achieved in the model without cache. We also obtain a slightly weaker result (space of size npoly(log m) bits and two bit probes for every query) for a scheme that is effectively encodable. [ABSTRACT FROM AUTHOR]

A Business Process (BP for short) consists of a set of activities which, combined in a flow, achieve some business goal. A given BP may have a large, possibly infinite, number of possible execution flows (EX-flows for short), each having some probability to occur at run time. This paper studies query evaluation over such probabilistic BPs. We focus on two important classes of queries, namely boolean queries that compute the probability that a random EX-flow of a BP satisfies a given property, and projection queries focusing on portions of EX-flows that are of interest to the user. For the latter queries the answer consists of the top- k instances of these portions that are most likely to occur at run-time. We study the complexity of query evaluation for both kinds of queries, showing in particular that projection queries may be harder to evaluate than boolean queries. We present a picture of which combinations of BP classes and query features lead to PTIME algorithms and which to NP-hard or infeasible problems. [ABSTRACT FROM AUTHOR]

Given an undirected graph G on n nodes and m edges in the form of a data stream we study the problem of finding an Euler tour in G. Our main result is the first one-pass streaming algorithm computing an Euler tour of G in the form of an edge successor function with only O (n log (n)) RAM, which is optimal for this setting (e.g. Sun and Woodruff (2015)). Since the output size can be much larger, we use a write-only tape to gradually output the solution. The previously best-known result for finding Euler tours in data streams is implicitly given by the W-stream algorithm of Demetrescu et al. (2010) using O (m / n) passes under the same RAM limitation. Our approach is to partition the edges into edge-disjoint cycles and to merge the cycles until a single Euler tour is achieved. In the streaming environment such a merging is far from being obvious as the limited RAM allows the processing of only a constant number of cycles at once. This enforces merging of cycles that partially are no longer present in RAM. We solve this problem with a new edge swapping technique, for which storing two certain edges per node is sufficient to merge tours without having all tour edges in RAM. The mathematical key is to model tours and their merging in an algebraic way, where certain equivalence classes represent subtours. This quite general approach might be of interest also in other routing problems. [ABSTRACT FROM AUTHOR]

We explore and demonstrate the feasibility of implementing distributed solutions for advance reservation of network resources. We introduce a new distributed, distance-vector algorithm, called Distributed Advance Reservation (), that provably returns the earliest time possible for setting up a connection between any two nodes. Our main findings are the following: (i) we prove that widest path routing and path switching (i.e, allowing a connection to switch between different paths) are necessary to guarantee earliest scheduling; (ii) we propose and analyze a novel approach for loop-free distributed widest path routing, leveraging the recently proposed framework. Our routing results directly extend to on-demand and inter-domain QoS routing problems. [ABSTRACT FROM AUTHOR]

An orientation of an undirected graph G is a directed graph obtained by replacing each edge { u, v} of G by exactly one of the arcs ( u, v) or ( v, u). In the min-sum k -paths orientation problem, the input is an undirected graph G and ordered pairs ( s, t), where i∈{1,2,..., k}. The goal is to find an orientation of G that minimizes the sum over all i∈{1,2,..., k} of the distance from s to t. In the min-sum k edge-disjoint paths problem, the input is the same, however the goal is to find for every i∈{1,2,..., k} a path between s and t so that these paths are edge-disjoint and the sum of their lengths is minimum. Note that, for every fixed k≥2, the question of N P-hardness for the min-sum k-paths orientation problem and for the min-sum k edge-disjoint paths problem has been open for more than two decades. We study the complexity of these problems when k=2. We exhibit a PTAS for the min-sum 2-paths orientation problem. A by-product of this PTAS is a reduction from the min-sum 2-paths orientation problem to the min-sum 2 edge-disjoint paths problem. The implications of this reduction are: (i) an NP-hardness proof for the min-sum 2-paths orientation problem yields an NP-hardness proof for the min-sum 2 edge-disjoint paths problem, and (ii) any approximation algorithm for the min-sum 2 edge-disjoint paths problem can be used to construct an approximation algorithm for the min-sum 2-paths orientation problem with the same approximation guarantee and only an additive polynomial increase in the running time. [ABSTRACT FROM AUTHOR]

We consider the problem of continuum armed bandits where the arms are indexed by a compact subset of $\mathbb {R}^{d}$. For large d, it is well known that mere smoothness assumptions on the reward functions lead to regret bounds that suffer from the curse of dimensionality. A typical way to tackle this in the literature has been to make further assumptions on the structure of reward functions. In this work we assume the reward functions to be intrinsically of low dimension k ≪ d and consider two models: (i) The reward functions depend on only an unknown subset of k coordinate variables and, (ii) a generalization of (i) where the reward functions depend on an unknown k dimensional subspace of $\mathbb {R}^{d}$. By placing suitable assumptions on the smoothness of the rewards we derive randomized algorithms for both problems that achieve nearly optimal regret bounds in terms of the number of rounds n. [ABSTRACT FROM AUTHOR]

We investigate structural properties of ω-automatic presentations of infinite structures in order to sharpen our methods to determine whether a given structure is ω-automatic. We apply these methods to show that several classes of structures such as pairing functions and infinite integral domains do not have an ω-automatic model. [ABSTRACT FROM AUTHOR]

For a given collection $\mathcal{G}$ of directed graphs we define the join-reachability graph of $\mathcal{G}$, denoted by $\mathcal{J}(\mathcal{G})$, as the directed graph that, for any pair of vertices u and v, contains a path from u to v if and only if such a path exists in all graphs of $\mathcal{G}$. Our goal is to compute an efficient representation of $\mathcal{J}(\mathcal{G})$. In particular, we consider two versions of this problem. In the explicit version we wish to construct the smallest join-reachability graph for $\mathcal{G}$. In the implicit version we wish to build an efficient data structure, in terms of space and query time, such that we can report fast the set of vertices that reach a query vertex in all graphs of $\mathcal{G}$. This problem is related to the well-studied reachability problem and is motivated by emerging applications of graph-structured databases and graph algorithms. We consider the construction of join-reachability structures for two graphs and develop techniques that can be applied to both the explicit and the implicit problems. First we present optimal and near-optimal structures for paths and trees. Then, based on these results, we provide efficient structures for planar graphs and general directed graphs. [ABSTRACT FROM AUTHOR]

We consider the Partition Into Triangles problem on bounded degree graphs. We show that this problem is polynomial-time solvable on graphs of maximum degree three by giving a linear-time algorithm. We also show that this problem becomes $\mathcal{NP}$-complete on graphs of maximum degree four. Moreover, we show that there is no subexponential-time algorithm for this problem on graphs of maximum degree four unless the Exponential-Time Hypothesis fails. However, the Partition Into Triangles problem on graphs of maximum degree at most four is in many cases practically solvable as we give an algorithm for this problem that runs in $\mathcal{O}(1.02220^{n})$ time and linear space. [ABSTRACT FROM AUTHOR]

We study the classical approximate string matching problem, that is, given strings P and Q and an error threshold k, find all ending positions of substrings of Q whose edit distance to P is at most k. Let P and Q have lengths m and n, respectively. On a standard unit-cost word RAM with word size w≥log n we present an algorithm using time When P is short, namely, $m = 2^{o(\sqrt{\log n}\,)}$ or $m =2^{o(\sqrt{w/\log w}\,)}$ this improves the previously best known time bounds for the problem. The result is achieved using a novel implementation of the Landau-Vishkin algorithm based on tabulation and word-level parallelism. [ABSTRACT FROM AUTHOR]