Showing papers in "SIAM Journal on Computing in 1995"

Sparse Approximate Solutions to Linear Systems

Abstract: The following problem is considered: given a matrix $A$ in ${\bf R}^{m \times n}$, ($m$ rows and $n$ columns), a vector $b$ in ${\bf R}^m$, and ${\bf \epsilon} > 0$, compute a vector $x$ satisfying $\| Ax - b \|_2 \leq {\bf \epsilon}$ if such exists, such that $x$ has the fewest number of non-zero entries over all such vectors. It is shown that the problem is NP-hard, but that the well-known greedy heuristic is good in that it computes a solution with at most $\left\lceil 18 \mbox{ Opt} ({\bf \epsilon}/2) \|{\bf A}^+\|^2_2 \ln(\|b\|_2/{\bf \epsilon}) \right\rceil$ non-zero entries, where $\mbox{Opt}({\bf \epsilon}/2)$ is the optimum number of nonzero entries at error ${\bf \epsilon}/2$, ${\bf A}$ is the matrix obtained by normalizing each column of $A$ with respect to the $L_2$ norm, and ${\bf A}^+$ is its pseudo-inverse.

A General Approximation Technique for Constrained Forest Problems

Abstract: We present a general approximation technique for a large class of graph problems. Our technique mostly applies to problems of covering, at minimum cost, the vertices of a graph with trees, cycles or paths satisfying certain requirements. In particular, many basic combinatorial optimization problems fit in this framework, including the shortest path, minimum-cost spanning tree, minimum-weight perfect matching, traveling salesman and Steiner tree problems. Our technique produces approximation algorithms that run in $O(n^2\log n)$ time and come within a factor of 2 of optimal for most of these problems. For instance, we obtain a 2-approximation algorithm for the minimum-weight perfect matching problem under the triangle inequality. Our running time of $O(n^2\log n)$ time compares favorably with the best strongly polynomial exact algorithms running in $O(n^3)$ time for dense graphs. A similar result is obtained for the 2-matching problem and its variants. We also derive the first approximation algorithms for many NP-complete problems, including the non-fixed point-to-point connection problem, the exact path partitioning problem and complex location-design problems. Moreover, for the prize-collecting traveling salesman or Steiner tree problems, we obtain 2-approximation algorithms, therefore improving the previously best-known performance guarantees of 2.5 and 3, respectively [Math. Programming, 59 (1993), pp. 413--420].

Fixed-Parameter Tractability and Completeness I: Basic Results

Abstract: For many fixed-parameter problems that are trivially soluable in polynomial-time, such as ($k$-)DOMINATING SET, essentially no better algorithm is presently known than the one which tries all possible solutions. Other problems, such as ($k$-)FEEDBACK VERTEX SET, exhibit fixed-parameter tractability: for each fixed $k$ the problem is soluable in time bounded by a polynomial of degree $c$, where $c$ is a constant independent of $k$. We establish the main results of a completeness program which addresses the apparent fixed-parameter intractability of many parameterized problems. In particular, we define a hierarchy of classes of parameterized problems $FPT \subseteq W[1] \subseteq W[2] \subseteq \cdots \subseteq W[SAT] \subseteq W[P]$ and identify natural complete problems for $W[t]$ for $t \geq 2$. (In other papers we have shown many problems complete for $W[1]$.) DOMINATING SET is shown to be complete for $W[2]$, and thus is not fixed-parameter tractable unless INDEPENDENT SET, CLIQUE, IRREDUNDANT SET and many other natural problems in $W[2]$ are also fixed-parameter tractable. We also give a compendium of currently known hardness results as an appendix.

Identifying the Minimal Transversals of a Hypergraph and Related Problems

Abstract: The paper considers two decision problems on hypergraphs, hypergraph saturation and recognition of the transversal hypergraph, and discusses their significance for several search problems in applied computer science. Hypergraph saturation (i.e., given a hypergraph $\cal H$, decide if every subset of vertices is contained in or contains some edge of $\cal H$) is shown to be co-NP-complete. A certain subproblem of hypergraph saturation, the saturation of simple hypergraphs (i.e., Sperner families), is shown to be under polynomial transformation equivalent to transversal hypergraph recognition; i.e., given two hypergraphs ${\cal H}_{1}, {\cal H}_{2}$, decide if the sets in ${\cal H}_{2}$ are all the minimal transversals of ${\cal H}_{1}$. The complexity of the search problem related to the recognition of the transversal hypergraph, the computation of the transversal hypergraph, is an open problem. This task needs time exponential in the input size; it is unknown whether an output-polynomial algorithm exists. For several important subcases, for instance if an upper or lower bound is imposed on the edge size or for acyclic hypergraphs, output-polynomial algorithms are presented. Computing or recognizing the minimal transversals of a hypergraph is a frequent problem in practice, which is pointed out by identifying important applications in database theory, Boolean switching theory, logic, and artificial intelligence (AI), particularly in model-based diagnosis.

When Trees Collide: An Approximation Algorithm for theGeneralized Steiner Problem on Networks

Abstract: We give the first approximation algorithm for the generalized network Steiner problem, a problem in network design. An instance consists of a network with link-costs and, for each pair $\{i,j\}$ of nodes, an edge-connectivity requirement $r_{ij}$. The goal is to find a minimum-cost network using the available links and satisfying the requirements. Our algorithm outputs a solution whose cost is within $2\lceil \log_2(r+1)\rceil$ of optimal, where $r$ is the highest requirement value. In the course of proving the performance guarantee, we prove a combinatorial min-max approximate equality relating minimum-cost networks to maximum packings of certain kinds of cuts. As a consequence of the proof of this theorem, we obtain an approximation algorithm for optimally packing these cuts; we show that this algorithm has application to estimating the reliability of a probabilistic network.

Finding Regular Simple Paths in Graph Databases

Abstract: We consider the following problem: given a labelled directed graph $G$ and a regular expression $R$, find all pairs of nodes connected by a simple path such that the concatenation of the labels along the path satisfies $R$ The problem is motivated by the observation that many recursive queries in relational databases can be expressed in this form, and by the implementation of a query language, ${\bf G}^+$, based on this observation We show that the problem is in general intractable, but present an algorithm than runs in polynomial time in the size of the graph when the regular expression and the graph are free of conflicts We also present a class of languages whose expressions can always be evaluated in time polynomial in the size of both the graph and the expression, and characterize syntactically the expressions for such languages

What Can Be Computed Locally

Abstract: The purpose of this paper is a study of computation that can be done locally in a distributed network, where "locally" means within time (or distance) independent of the size of the network. Locally checkable labeling (LCL) problems are considered, where the legality of a labeling can be checked locally (e.g., coloring). The results include the following: There are nontrivial LCL problems that have local algorithms. There is a variant of the dining philosophers problem that can be solved locally. Randomization cannot make an LCL problem local; i.e., if a problem has a local randomized algorithm then it has a local deterministic algorithm. It is undecidable, in general, whether a given LCL has a local algorithm. However, it is decidable whether a given LCL has an algorithm that operates in a given time $t$. Any LCL problem that has a local algorithm has one that is order-invariant (the algorithm depends only on the order of the processor IDs).

A Graph-Theoretic Game and its Application to the $k$-Server Problem

Abstract: This paper investigates a zero-sum game played on a weighted connected graph $G$ between two players, the tree player and the edge player. At each play, the tree player chooses a spanning tree $T$ and the edge player chooses an edge $e$. The payoff to the edge player is $cost(T,e)$, defined as follows: If $e$ lies in the tree $T$ then $cost(T,e)=0$; if $e$ does not lie in the tree then $cost(T,e) = cycle(T,e)/w(e)$, where $w(e)$ is the weight of edge $e$ and $cycle(T,e)$ is the weight of the unique cycle formed when edge $e$ is added to the tree $T$. The main result is that the value of the game on any $n$-vertex graph is bounded above by $\exp(O(\sqrt{\log n \log\log n}))$. It is conjectured that the value of the game is $O(\log n)$. The game arises in connection with the $k$-server problem on a road network; i.e., a metric space that can be represented as a multigraph $G$ in which each edge $e$ represents a road of length $w(e)$. It is shown that, if the value of the game on $G$ is $Val(G,w)$, then there is a randomized strategy that achieves a competitive ratio of $k(1 + Val(G,w))$ against any oblivious adversary. Thus, on any $n$-vertex road network, there is a randomized algorithm for the $k$-server problem that is $k\cdot\exp(O(\sqrt{\log n \log\log n}))$ competitive against oblivious adversaries. At the heart of the analysis of the game is an algorithm that provides an approximate solution for the simple network design problem. Specifically, for any $n$-vertex weighted, connected multigraph, the algorithm constructs a spanning tree $T$ such that the average, over all edges $e$, of $cost(T,e)$ is less than or equal to $\exp(O(\sqrt{\log n \log\log n}))$. This result has potential application to the design of communication networks. It also improves substantially known estimates concerning the existence of a sparse basis for the cycle space of a graph.

On the Approximation of Shortest Common Supersequencesand Longest Common Subsequences

Abstract: The problems of finding shortest common supersequences (SCS) and longest common subsequences (LCS) are two well-known {\bf NP}-hard problems that have applications in many areas including computational molecular biology, data compression, robot motion planning and scheduling, text editing, etc. A lot of fruitless effort has been spent in searching for good approximation algorithms for these problems. In this paper, we show that these problems are inherently hard to approximate in the worst case. In particular, we prove that (i) SCS does not have a polynomial time linear approximation algorithm, unless {\bf P} = {\bf NP}; (ii) There exists a constant $\delta > 0$ such that, if SCS has a polynomial time approximation algorithm with ratio $\log^{\delta} n$, where $n$ is the number of input sequences, then {\bf NP} is contained in {\bf DTIME}$(2^{\polylog n})$; (iii) There exists a constant $\delta > 0$ such that, if LCS has a polynomial time approximation algorithm with performance ratio $n^{\delta}$, then {\bf P} = {\bf NP}. The proofs utilize the recent results of Arora et al. [Proc. 23rd IEEE Symposium on Foundations of Computer Science, 1992, pp. 14-23] on the complexity of approximation problems. In the second part of the paper, we introduce a new method for analyzing the average-case performance of algorithms for sequences, based on Kolmogorov complexity. Despite the above nonapproximability results, we show that near optimal solutions for both SCS and LCS can be found on the average. More precisely, consider a fixed alphabet $\Sigma$ and suppose that the input sequences are generated randomly according to the uniform probability distribution and are of the same length $n$. Moreover, assume that the number of input sequences is polynomial in $n$. Then, there are simple greedy algorithms which approximate SCS and LCS with expected additive errors $O(n^{0.707})$ and $O(n^{\frac{1}{2}+\epsilon})$ for any $\epsilon > 0$, respectively. Incidentally, our analyses also provide tight upper and lower bounds on the expected LCS and SCS lengths for a set of random sequences, solving a generalization of another well-known open question on the expected LCS length for two random sequences [K. Alexander, The rate of convergence of the mean length of the longest common subsequence, 1992, manuscript],[V. Chvatal and D. Sankoff, J. Appl. Probab., 12 (1975), pp. 306-315], [D. Sankoff and J. Kruskall, eds., Time Warps, String Edits, and Macromolecules: The Theory and Practice of Sequence Comparison, Addison-Wesley, Reading, MA, 1983].

Ordered and Unordered Tree Inclusion

Abstract: The following tree-matching problem is considered: Given labeled trees $P$ and $T$, can $P$ be obtained from $T$ by deleting nodes? Deleting a node $u$ entails removing all edges incident to $u$ and, if $u$ has a parent $v$, replacing the edge from $v$ to $u$ by edges from $v$ to the children of $u$. The problem is motivated by the study of query languages for structured text databases. Simple solutions to this problem require exponential time. For ordered trees an algorithm is presented that requires $O(|P| |T|)$ time and space. The corresponding problem for unordered trees is also considered and a proof of its NP-completeness is given. An algorithm is presented for the unordered problem. This algorithm works in $O(|P| |T|)$ time if the out-degrees of the nodes in $P$ are bounded by a constant, and in polynomial time if they are $O(\log |T|)$.

Scheduling Parallel Machines On-line

Abstract: The problem of scheduling jobs on parallel machines is studied when (1) the existence of a job is not known until its unknown release date and (2) the processing requirement of a job is not known until the job is processed to completion. Two general algorithmic techniques are demonstrated for converting existing polynomial-time algorithms that require complete knowledge about the input data into algorithms that need less advance knowledge. Information-theoretic lower bounds on the length of on-line schedules are proven for several basic parallel machine models, and that almost all of our algorithms construct schedules with lengths that either match or come within a constant factor of the lower bound.

D over : An Optimal On-Line Scheduling Algorithm for Overloaded Uniprocessor Real-Time Systems

Abstract: Consider a real-time system in which every task has a value that it obtains only if it completes by its deadline. The problem is to design an on-line scheduling algorithm (i.e., the scheduler has no knowledge of a task until it is released) that maximizes the guaranteed value obtained by the system. When such a system is underloaded (i.e., there exists a schedule for which all tasks meet their deadlines), Dertouzos [Proceedings IFIF Congress, 1974, pp.\ 807--813] showed that the earliest deadline first algorithm will achieve 100% of the possible value. Locke [Ph. D. thesis, Computer Science Dept., Carnegie-Mellon Univ., Pittsburgh, PA] showed that earliest deadline first performs very badly, however, when the system is overloaded, and he proposed heuristics to deal with overload. This paper presents an optimal on-line scheduling algorithm for overloaded uniprocessor systems. It is optimal in the sense that it gives the best competitive ratio possible relative to an off-line scheduler.

Finding $k$ Cuts within Twice the Optimal

Abstract: Two simple approximation algorithms for the minimum $k$-cut problem are presented. Each algorithm finds a $k$ cut having weight within a factor of $(2-2/k)$ of the optimal. One of our algorithms is particularly efficient---it requires a total of only $n-1$ maximum flow computations for finding a set of near-optimal $k$ cuts, one for each value of $k$ between 2 and $n$.

Randomized Interpolation and Approximationof Sparse Polynomials

Abstract: We present a randomized algorithm that interpolates a sparse polynomial in polynomial time in the bit complexity model. The algorithm can be also applied to approximate polynomials that can be approximated by sparse polynomials (the approximation is in the $L_2$ norm).

Scaling Algorithms for the Shortest Paths Problem

Abstract: We describe a new method for designing scaling algorithms for the single-source shortest paths problem and use this method to obtain an $O(\sqrt n m \log N)$ algorithm for the problem. (Here $n$ and $m$ is the number of nodes and arcs in the input network and $N$ is essentially the absolute value of the most negative arc length, and arc lengths are assumed to be integral.) This improves previous bounds for the problem. The method extends to related problems.

Flow in Planar Graphs with Multiple Sources and Sinks

Abstract: The problem of maximum flow in planar graphs has always been investigated under the assumption that there is only one source and one sink. Here we consider the case where there are many sources and sinks (single commodity) in a directed planar graph. An algorithm for the case when the demands of the sources and sinks are fixed and given in advance is presented. It can be implemented efficiently sequentially and in parallel and its complexity is dominated by the complexity of computing all shortest paths from a single source in a planar graph. If the demands are not known, an algorithm for computing the maximum flow is presented for the case where the number of faces that contain sources and sinks is bounded by a slowly growing function. Our result places the problem of computing a perfect matching in a planar bipartite graph in NC and it improves a previous parallel algorithm for the case of a single source, single sink in a planar directed1nd undirected) graph, both in terms of processor bounds and in its simple presentation.

Amortized Communication Complexity

Abstract: In this work we study the direct-sum problem with respect to communication complexity: Consider a relation $f$ defined over $\{0,1\}^{n} \times \{0,1\}^{n}$. Can the communication complexity of simultaneously computing $f$ on $\cal l$ instances $(x_1,y_1),\ldots,(x_{\cal l},y_{\cal l})$ be smaller than the communication complexity of computing $f$ on the $\cal l$ instances, separately? Let the amortized communication complexity of $f$ be the communication complexity of simultaneously computing $f$ on $\cal l$ instances, divided by $\cal l$. We study the properties of the amortized communication complexity. We show that the amortized communication complexity of a relation can be smaller than its communication complexity. More precisely, we present a partial function whose (deterministic) communication complexity is $\Theta(\log n)$ and its amortized (deterministic) communication complexity is $O(1)$. Similarly, for randomized protocols, we present a function whose randomized communication complexity is $\Theta(\log n)$ and its amortized randomized communication complexity is $O(1)$. We also give a general lower bound on the amortized communication complexity of any function $f$ in terms of its communication complexity $C(f)$: for every function $f$ the amortized communication complexity of $f$ is $\Omega \left (\sqrt{C(f)} - \log n \right)$.

A Fast Approximation Algorithm for Computing theFrequencies of Subgraphs in a Given Graph

Abstract: In this paper we give an algorithm which, given a labeled graph on $n$ vertices and a list of all labeled graphs on $k$ vertices, provides for each graph $H$ of this list an approximation to the number of induced copies of $H$ in $G$ with total error small. This algorithm has running time $O(n^{{1 \over \log \log n}} \cdot M(n))$, where $M(n)$ is the time needed to square a $n$ by $n$ matrix with 0, 1-entries over the integers. The main tool in designing this algorithm is a variant of the regularity lemma of Szemeredi.

Algorithms for Enumerating All Spanning Trees ofUndirected and Weighted Graphs

Abstract: In this paper, we present algorithms for enumeration of spanning trees in undirected graphs, with and without weights. The algorithms use a search tree technique to construct a computation tree. The computation tree can be used to output all spanning trees by outputting only relative changes between spanning trees rather than the entire spanning trees themselves. Both the construction of the computation tree and the listing of the trees is shown to require $O(N+V+E)$ operations for the case of undirected graphs without weights. The basic algorithm is based on swapping edges in a fundamental cycle. For the case of weighted graphs (undirected), we show that the nodes of the computation tree of spanning trees can be sorted in increasing order of weight, in $O(N\log V+VE)$ time. The spanning trees themselves can be listed in $O(NV)$ time. Here $N$, $V$, and $E$ refer respectively to the number of spanning trees, vertices, and edges of the graph.

Nearly Optimal Algorithms For Canonical Matrix Forms

Abstract: A Las-Vegas-type probabilistic algorithm is presented for finding the Frobenius canonical form of an $n\times n$ matrix $T$ over any field $\KK$. The algorithm requires $\softO(\MM(n))=\MM(n)\cdot(\log n)^{O(1)}$ operations in $\KK$, where $O(\MM(n))$ operations in $\KK$ are sufficient to multiply two $n\times n$ matrices over $\KK$. This nearly matches the lower bound of $\Omega(\MM(n))$ operations in $\KK$ for this problem, and improves on the $O(n^4)$ operations in $\KK$ required by the previously best known algorithms.A fast parallel implementation of the algorithm is also demonstrated for the Frobenius form, which is processor-efficient on a PRAM. As an application we give an algorithm to evaluate a polynomial $g\in\KK[x]$ at $T$ which requires only $\softO(\MM(n))$ operations in $\KK$ when $\deg g\leq n^2$. Other applications include sequential and parallel algorithms for computing the minimal and characteristic polynomials of a matrix, the rational Jordan form of a matrix (for testing whether two matrices are similar), and for matrix powering which are substantially faster than those previously known.

$O(M . N)$ Algorithms for the Recognition and Isomorphism Problems on Circular-Arc Graphs

Abstract: Circular-arc graphs have a rich combinatorial structure. The circular endpoint sequence of arcs in a model for a circular-arc graph is usually far from unique. We present a natural restriction on these models to make it meaningful to define the unique representations for circular-arc graphs. We characterize those circular-arc graphs which have unique restricted models and give an $O(m \cdot n)$ algorithm for recognizing circular-arc graphs. We think a more careful implementation could reduce the complexity to $O(n^2)$. Our approach is to reduce the recognition problem of circular-arc graphs to that of circle graphs. This approach has the following advantages: it is conceptually simpler than Tucker's $O(n^3)$ recognition algorithm; it exploits the similarity between circle graphs and circular-arc graphs in a natural fashion; it yields an isomorphism algorithm. A main contribution of this result is an illustration of the transformed decomposition technique. The decomposition tree developed for circular-arc graphs generalizes the concept of the PQ-tree, which is a data structure that keeps track of all possible interval representations of a given interval graph. As a consequence, our approach also yields an $O(m \cdot n)$ isomorphism algorithm for circle graphs.

Scheduling Tasks with AND/OR Precedence Constraints

Abstract: In traditional precedence-constrained scheduling a task is ready to execute when all its predecessors are complete. We call such a task an AND task. In this paper we allow certain tasks to be ready when just one of their predecessors is complete. These tasks are known as OR tasks. We analyze the complexity of two types of real-time AND/OR task scheduling problems. In the first type of problem, all the predecessors of every OR task must eventually be completed, but in the second type of problem, some OR predecessors may be left unscheduled. We show that most problems involving tasks with individual deadlines are NP-complete, and then present two priority-driven heuristic algorithms to minimize completion time on a multiprocessor. These algorithms provide the same level of worst-case performance as some previous priority-driven algorithms for scheduling AND-only task systems.

The Complexity and Distribution of Hard Problems

Abstract: Measure-theoretic aspects of the $\leq^{\rm P}_{\rm m}$-reducibility structure of the exponential time complexity classes E=DTIME($2^{\rm linear}$) and $E_{2}={\rm DTIME}(2^{\rm polynomial})$ are investigated. Particular attention is given to the complexity (measured by the size of complexity cores) and distribution (abundance in the sense of measure) of languages that are $\leq^{\rm P}_{\rm m}$-hard for E and other complexity classes. Tight upper and lower bounds on the size of complexity cores of hard languages are derived. The upper bound says that the $\leq^{\rm P}_{\rm m}$-hard languages for E are unusually simple, in the sense that they have smaller complexity cores than most languages in E. It follows that the $\leq^{\rm P}_{\rm m}$-complete languages for E form a measure 0 subset of E (and similarly in $E_2$). This latter fact is seen to be a special case of a more general theorem, namely, that {\it every} \pmr-degree (e.g., the degree of all \pmr-complete languages for NP) has measure 0 in E and in \Ep.

A General Approach to Removing Degeneracies

Abstract: We wish to increase the power of an arbitrary algorithm designed for nondegenerate input, by allowing it to execute on all inputs. We concentrate on infinitesimal symbolic perturbations that do not affect the output for inputs in general position. Otherwise, if the problem mapping is continuous, the input and output space topology are at least as coarse as the real euclidean one and the output space is connected, then our perturbations make the algorithm produce an output arbitrarily close or identical to the correct one. For a special class of algorithms, which includes several important algorithms in computational geometry, we describe a deterministic method that requires no symbolic computation. Ignoring polylogarithmic factors, this method increases only the worst-case bit complexity by a multiplicative factor which is linear in the dimension of the geometric space. For general algorithms, a randomized scheme with arbitrarily high probability of success is proposed; the bit complexity is then bounded by a small-degree polynomial in the original worst-case complexity. In addition to being simpler than previous ones, these are the first efficient perturbation methods.

Approximating the Minimum Equivalent Digraph

Abstract: The MEG (minimum equivalent graph) problem is the following: "Given a directed graph, find a smallest subset of the edges that maintains all reachability relations between nodes." This problem is NP-hard; this paper gives an approximation algorithm achieving a performance guarantee of about 1.64 in polynomial time. The algorithm achieves a performance guarantee of 1.75 in the time required for transitive closure. The heart of the MEG problem is the minimum SCSS (strongly connected spanning subgraph) problem --- the MEG problem restricted to strongly connected digraphs. For the minimum SCSS problem, the paper gives a practical, nearly linear-time implementation achieving a performance guarantee of 1.75. The algorithm and its analysis are based on the simple idea of contracting long cycles. The analysis applies directly to $2$-\Exchange, a general "local improvement" algorithm, showing that its performance guarantee is 1.75.

Polynomial-time Membership Comparable Sets

Abstract: This paper studies a notion called polynomial-time membership comparable sets. For a function $g$, a set $A$ is polynomial-time $g$-membership comparable if there is a polynomial-time computable function $f$ such that for any $x_1, \cdots, x_m$ with $m \geq g(\max\{ |x_1|, \cdots, |x_m| \})$, outputs $b \in \{0,1\}^m$ such that $(A(x_1), \cdots, A(x_m)) eq b$. The following is a list of major results proven in the paper. 1. Polynomial-time membership comparable sets construct a proper hierarchy according to the bound on the number of arguments. 2. Polynomial-time membership comparable sets have polynomial-size circuits. 3. For any function $f$ and for any constant $c>0$, if a set is $\leq^p_{f(n)-tt}$-reducible to a P-selective set, then the set is polynomial-time $(1+c)\log f(n)$-membership comparable. 4. For any $\cal C$ chosen from $\{ {\rm PSPACE, UP, FewP, NP, C_{=}P, PP, MOD_{2}P, MOD_{3}}, \cdots \}$, if $\cal C \subseteq {\rm P-mc}(c\log n)$ for some $c<1$, then $\cal C = {\rm P}$. As a corollary of the last two results, it is shown that if there is some constant $c<1$ such that all of $\cal C$ are polynomial-time $n^c$-truth-table reducible to some P-selective sets, then $\cal C = {\rm P}$, which resolves a question that has been left open for a long time.

A Subexponential Algorithm for Abstract Optimization Problems

Abstract: An abstract optimization problem (AOP) is a triple $(H,<, \Phi)$ where $H$ is a finite set, $<$ a total order on $2^{H}$ and $\Phi$ an oracle that, for given $F\subseteq G\subseteq H$, either reports that $F=\min_{<}\{F'\mid F'\subseteq G\}$ or returns a set $F'\subseteq G$ with $F' $$e^{2\sqrt{n}+O(\sqrt[4]{n}\ln n)}$$ oracle calls, $n=|H|$. In contrast, any deterministic algorithm needs to make $2^{n}-1$ oracle calls in the worst case. The algorithm is applied to the problem of finding the distance between two $n$-vertex (or $n$-facet) convex polyhedra in $d$-space, and to the computation of the smallest ball containing $n$ points in $d$-space; for both problems we give the first subexponential bounds in the arithmetic model of computation.

Adaptive Pattern Matching

Abstract: Pattern matching is an important operation used in many applications such as functional programming, rewriting, and rule-based expert systems. By preprocessing the patterns into a DFA-like automaton, we can rapidly select the matching pattern(s) in a single scan of the relevant portions of the input term. This automaton is typically based on left-to-right traversal of the patterns. By adapting the traversal order to suit the set of input patterns, it is possible to considerably reduce the space and matching time requirements of the automaton. The design of such adaptive automata is the focus of this paper. We first formalize the notion of an adaptive traversal. We then present several strategies for synthesizing adaptive traversal orders aimed at reducing space and matching time complexity. In the worst case, however, the space requirements can be exponential in the size of the patterns. We show this by establishing an exponential lower bounds on space that is independent of the traversal order used. We then discuss an orthogonal approach to space minimization based on direct construction of optimal dag automata. Finally, our work brings forth the impact of typing in pattern matching. In particular, we show that several important problems (e.g., lazy pattern matching in ML) are computationally hard in the presence of type disciplines, whereas they can be solved efficiently in the untyped setting.

Dynamic Graph Drawings: Trees, Series-Parallel Digraphs, and Planar ST -Digraphs

Abstract: Drawing graphs is an important problem that combines elements of computational geometry and graph theory. Applications can be found in a variety of areas including circuit layout, network management, software engineering, and graphics. The main contributions of this paper can be summarized as follows: We devise a model for dynamic graph algorithms, based on performing queries and updates on an implicit representation of the drawing, and we show its applications. We present efficient dynamic drawing algorithms for trees and series-parallel digraphs. As further applications of the model, we give dynamic drawing algorithms for planar st-digraphs and planar graphs. Our algorithms adopt a variety of representations (e.g., straight line, polyline, visibility) and update the drawing in a smooth way.

A Generalization of the Suffix Tree to Square Matrices, with Applications

Abstract: We describe a new data structure, the Lsuffix tree, which generalizes McCreight's suffix tree for a string [J. Assoc. Comput. Mach., 23 (1976), pp. 262--272] to a square matrix. All matrices have entries from a totally ordered alphabet $\Sigma$. Based on the Lsuffix tree, we give efficient algorithms for the static versions of the following dual problems that arise in low-level image processing and visual databases. Two-dimensional pattern retrieval. We have a library of texts $S=\{TEXT^1,\cdots, TEXT^r\}$, where $TEXT^i$ is an $n_i\times n_i$ matrix, $ 1 \leq i \leq r$. We may preprocess the library. Then, given an $m \times m$, $m \leq n_i$, $ 1 \leq i \leq r$, pattern matrix $PAT$, we want to find all occurrences of $PAT$ in $TEXT$, for all $TEXT \in S$. Let $t(S)=\Sigma_{i=1}^r n_i^2$ be the size of the library. The preprocessing step builds the Lsuffix tree for the matrices in $S$ and then transforms it into an index (a trie defined over $\Sigma$). It takes $O(t(S)( \log |\Sigma| +\log t(S)))$ time and $O(t(S))$ space. The index can be queried directly in $O(m^2\log |\Sigma|+totocc)$ time, where $totocc$ is the total number of occurrences of $PAT$ in $TEXT$, for all $TEXT \in S$. Two-dimensional dictionary matching. We have a dictionary of patterns $DC=\{PAT_1, \cdots, PAT_s\}$, where $PAT_i$ is of dimension $m_i\times m_i$, $ 1 \leq i \leq s$. We may preprocess the dictionary. Then, given an $n \times n$ text matrix $TEXT$, we want to search for all occurrences of patterns in the dictionary in the text. Let $t(DC)=\Sigma_{i=1}^s m^2_i$ be the size of the dictionary and let $\overline{t}(DC)$ be the sum of the $m_i$'s. The preprocessing consists of building the Lsuffix tree for the matrices in $DC$. It takes $O(t(DC)\log |\Sigma| +\overline{t}(DC)\log \overline{t}(DC)))$ time and $O(t(DC))$ space. The search step takes $O(n^2(\log |\Sigma|+\log \overline{t}(DC))+totocc)$ time, where $totocc$ is the total number of occurrences of patterns in the text. Both problems have a dynamic version in which the library and the dictionary, respectively, can be updated by insertion or deletion of square matrices in them. In a companion paper, we will provide algorithms for the dynamic version.