This is the nineteenth edition of a (usually) quarterly column that covers new developments in the theory of NP-completeness. The presentation is modeled on that used by M. R. Garey and myself in our book ‘‘Computers and Intractability: A Guide to the Theory of NP-Completeness,’ ’ W. H. Freeman & Co., New York, 1979 (hereinafter referred to as ‘‘[G&J]’’; previous columns will be referred to by their dates). A background equivalent to that provided by [G&J] is assumed, and, when appropriate, cross-references will be given to that book and the list of problems (NP-complete and harder) presented there. Readers who have results they would like mentioned (NP-hardness, PSPACE-hardness, polynomial-time-solvability, etc.) or open problems they would like publicized, should

This talk presents the derivation of an\Omega\Gamma/28 log m) lower bound on the number of rounds necessary for finding occurrences of a pattern string P [1::m] in a text string T [1::2m] in parallel using m comparisons in each round. The parallel complexity of the string matching problem using p processors for general alphabets follows. 1. Introduction Better and better parallel algorithms have been designed for string-matching. All are on CRCW-PRAM with the weakest form of simultaneous write conflict resolution: all processors which write into the same memory location must write the same value of 1. The best CREW-PRAM algorithms are those obtained from the CRCW algorithms for a logarithmic loss of efficiency. Optimal algorithms have been designed: O(logm) time in [8, 17] and O(log log m) time in [4]. (An optimal algorithm is one with pt = O(n) where t is the time and p is the number of processors used.) Recently, Vishkin [18] developed an optimal O(log m) time algorithm. Unlike...

We consider the classical problem of clock synchronization in distributed systems. Previously, this problem was solved optimally and efficiently only in the case when all individual clocks are non-drifting, i.e., only for systems where all clocks advance at the rate of real time. In this paper, we present a new algorithm for systems with drifting clocks, which is the first optimal algorithm to solve the problem efficiently: clock drift bounds and message latency bounds may be arbitrary; the computational complexity depends on the communication pattern of the system in a way which is bounded by a polynomial in the network size for most systems. More specifically, the complexity is polynomial in the maximal number of messages known to be sent but not received, the relative system speed, and time-stamp s...

Abstract not found

. The first result concerns branching programs having width (log n) O(1) . We give an \Omega\Gamma n log n= log log n) lower bound for the size of such branching programs computing almost any symmetric Boolean function and in particular the following explicit function: "the sum of the input variables is a quadratic residue mod p" where p is any given prime between n 1=4 and n 1=3 . This is a strengthening of previous nonlinear lower bounds obtained by Chandra, Furst, Lipton and by Pudl'ak. We mention that by iterating our method the result can be further strengthened to \Omega\Gamma n log n). The second result is a C n lower bound for read-once-only branching programs computing an explicit Boolean function. For n = \Gamma v 2 \Delta , the function computes the parity of the number of triangles in a graph on v vertices. This improves previous exp(c p n) lower bounds for other graph functions by Wegener and Z'ak. The result implies a linear lower bound for the space comp...

Directed s-t connectivity is the problem of detecting whether there is a path from a distinguished vertex s to a distinguished vertex t in a directed graph. We prove time-space lower bounds of ST = \Omega\Gamma n 2 = log n) and S 1=2 T = \Omega\Gamma mn 1=2 ) for Cook and Rackoff's JAG model [8], where n is the number of vertices and m the number of edges in the input graph, and S is the space and T the time used by the JAG. We also prove a timespace lower bound of S 1=3 T = \Omega\Gamma m 2=3 n 2=3 ) on the more powerful node-named JAG model of Poon [13]. These bounds approach the known upper bound of T = O(m) when S = \Theta(n log n).

This paper introduces communicating branching programs, and develops a general technique for demonstrating communication-space tradeoffs for pairs of communicating branching programs. This technique is then used to prove communication-space tradeoffs for any pair of communicating branching programs that hashes according to a universal family of hash functions. Other tradeoffs follow from this result. As an example, any pair of communicating Boolean branching programs that computes matrix-vector products over GF(2) requires communication-space product Ω(n 2), provided the space used is o(n / log n). These are the first examples of communication-space tradeoffs on a completely general model of communicating processes.

Problems involving strings arise in many areas of computer science and have numerous practical applications. We consider several problems from a theoretical perspective and provide efficient algorithms and lower bounds for these problems in sequential and parallel models of computation. In the sequential setting, we present new algorithms for the string matching problem improving the previous bounds on the number of comparisons performed by such algorithms. In parallel computation, we present tight algorithms and lower bounds for the string matching problem, for finding the periods of a string, for detecting squares and for finding initial palindromes.

Crochemore and Perrin discovered an elegant linear-time constant-space string matching algorithm that makes at most 2n \Gamma m symbol comparison. This paper shows how to modify their algorithm to use fewer comparisons. Given any fixed ffl ? 0, the modified algorithm takes linear time, uses constant space and makes at most n+ b 1+ffl 2 (n \Gamma m)c comparisons. If O(log m) space is available, then the algorithm makes at most n + b 1 2 (n \Gamma m)c comparisons. The pattern preprocessing step also takes linear time and uses constant space. These are the first string matching algorithms that make fewer than 2n \Gamma m comparisons and use sub-linear space.

We study the fundamental problem of sorting in a sequential model of computation and in particular consider the time-space trade-off (product of time and space) for this problem.