Showing papers in "SIAM Journal on Computing in 1981"
TL;DR: It is shown that it is NP-complete to determine the chromatic index of an arbitrary graph, even for cubic graphs.
Abstract: We show that it is NP-complete to determine the chromatic index of an arbitrary graph. The problem remains NP-complete even for cubic graphs.
1,249 citations
TL;DR: This work presents a practical algorithm for subdivision search that achieves the same (optimal) worst case complexity bounds as the significantly more complex algorithm of Lipton and Tarjan, namely $O(\log n)$ search time with $O(n)$ storage.
Abstract: A planar subdivision is any partition of the plane into (possibly unbounded) polygonal regions. The subdivision search problem is the following: given a subdivision $S$ with $n$ line segments and a query point $p$, determine which region of $S$ contains $p$. We present a practical algorithm for subdivision search that achieves the same (optimal) worst case complexity bounds as the significantly more complex algorithm of Lipton and Tarjan, namely $O(\log n)$ search time with $O(n)$ storage. Our subdivision search structure can be constructed in linear time from the subdivision representation used in many applications.
810 citations
TL;DR: An algorithm for constructing a tree to satisfy a set of lineage constraints on common ancestors is presented and this algorithm is applied to synthesize a relational algebra expression from a simple tableau, a problem arising in the theory of relational databases.
Abstract: We present an algorithm for constructing a tree to satisfy a set of lineage constraints on common ancestors. We then apply this algorithm to synthesize a relational algebra expression from a simple tableau, a problem arising in the theory of relational databases.
428 citations
TL;DR: Let A be a language chosen randomly by tossing a fair coin for each string x to determine whether x belongs to A, and${\bf NP}^A is shown, with probability 1, to contain a-immune set, i.e., a set having no infinite subset in ${\bf P]^A $.
Abstract: Let A be a language chosen randomly by tossing a fair coin for each string x to determine whether x belongs to A. With probability 1, each of the relativized classes ${\textbf{LOGSPACE}}^A $, ${\bf P}^A $, ${\bf NP}^A $, ${\bf PP}^A $, and ${\textbf{PSPACE}}^A $ is properly contained in the next. Also, ${\bf NP}^A
e {\text{co-}} {\bf NP}^A $ with probability 1. By contrast, with probability 1 the class ${\bf P}^A $ coincides with the class ${\bf BPP}^A $ of languages recognized by probabilistic oracle machines with error probability uniformly bounded below $\tfrac{1}{2}$. ${\bf NP}^A $ is shown, with probability 1, to contain a ${\bf P}^A $-immune set, i.e., a set having no infinite subset in ${\bf P}^A $. The relationship of ${\bf P}^A $-immunity to p-sparseness and ${\bf NP}^A $-completeness is briefly discussed: ${\bf P}^A $-immune sets in ${\bf NP}^A $ can be sparse or moderately dense, but not co-sparse. Relativization with respect to a random length-preserving permutation $\pi $, instead of a rand...
397 citations
TL;DR: It is shown that many graph problems can be solved efficiently using the matrix multiplication algorithms.
Abstract: Matrix multiplication algorithms for cube connected and perfect shuffle computers are presented. It is shown that in both these models two $n \times n$ matrices can be multiplied in $O(n/m + \log m)$ time when $n^2 m$, $1 \leqq m \leqq n$, processing elements (PEs) are available. When only $m^2 $, $1 \leqq m \leqq n$, PEs are available, two $n \times n$ matrices can be multiplied in $O(n^2/m + m(n/m)^{2.61} )$ time. It is shown that many graph problems can be solved efficiently using the matrix multiplication algorithms.
387 citations
TL;DR: The algorithm presented is an improvement of a previous known result which takes $O(Nc^{\sqrt {\log N} } )$ time and is shown to be applicable under a more general metric if certain conditions are satisfied.
Abstract: In this paper we study the Voronoi diagram for a set of N line segments and circles in the Euclidean plane. The diagram is a generalization of the Voronoi diagram for a set of points in the plane a...
326 citations
TL;DR: Graph augmentation problems on a weighted graph are shown to be NP-complete in the restricted case of the graph being initially connected and approximation algorithms with favorable time complexity are presented and shown to have constant worst-case performance ratios.
Abstract: Graph augmentation problems on a weighted graph involve determining a minimum-cost set of edges to add to a graph to satisfy a specified property, such as biconnectivity, bridge-connectivity or strong connectivity. These augmentation problems are shown to be NP-complete in the restricted case of the graph being initially connected. Approximation algorithms with favorable time complexity are presented and shown to have constant worst-case performance ratios.
306 citations
TL;DR: Those properties for which the bipartite restriction of the node-deletion problem is polynomial and those for which it remains NP-complete are characterized.
Abstract: A set of problems which has attracted considerable interest recently is the set of node-deletion problems. The general node-deletion problem can be stated as follows: Given a graph, find the minimum number of nodes whose deletion results in a subgraph satisfying property r. In (LY) this problem was shown to be NP-complete for a large class of properties (the class of properties that are hereditary on induced subgraphs) using a small number of reduction schemes from the node cover problem. Since the node cover problem becomes polynomial on bipartite graphs, it might be hoped that this is the case with other node-deletion problems too. In this paper we characterize those properties for which the bipartite restriction of the node-deletion problem is polynomial and those for which it remains NP-complete. Similar results follow for analogous problems on other structures such as families of sets, hypergraphs and 0,1 matrices. For example, in the case of matrices, our result states that ifM is a class of 0,1 matrices which is closed under permutation and deletion of rows and columns, then finding the largest submatrix inM of a matrix is polynomial if the matrices ofM have bounded rank and NP-complete otherwise. 1. Introduction. A common approach when faced with an NP-complete problem (C), (K), (GJ) is to restrict its input domain with the hope that the problem may become solvable in polynomial time under the restriction. In fact it turns out that sometimes this is the case" for example, the node-cover problem, NP-complete on general graphs (K), can be solved efficiently when restricted to bipartite graphs. (This follows from K6nig's theorem that the node covering number of a bipartite graph equals the number of edges in a maximum matching, and moreover a minimum node cover can be found efficiently from a maximum matching when the graph is bipartite--see, for example, (La).) In other cases, however, the node cover problem continues to be NP-complete under restriction; for example the node cover problem on planar graphs (GJS). Much work has been done recently (KD), (LY), (LDL) on a class of problems, called the node-deletion (or maximum subgraph) problems. The general node-deletion problem can be stated as follows: Given a graph (or digraph) G, find a set of nodes of minimum cardinality, whose deletion results in a graph or digraph satisfying a property r. Several of the known NP-complete problems, such as the node cover, the max clique, the feedback-node set (K), as well as some polynomial problems, such as the connectivity of a graph (E), IT), can be formulated in an obvious way as node-deletion problems, by specifying appropriately the property r.
270 citations
TL;DR: By combining Pan’s trilinear technique with a strong version of the compression theorem for the case of several disjoint matrix multiplications it is shown that multiplication of N \times N matrices (over arbitrary fields) is possible in time.
Abstract: In 1979 considerable progress was made in estimating the complexity of matrix multiplication. Here the new techniques and recent results are presented, based upon the notion of approximate rank and the observation that certain patterns of partial matrix multiplication (some of the entries of the matrices may be zero) can efficiently be utilized to perform multiplication of large total matrices. By combining Pan’s trilinear technique with a strong version of our compression theorem for the case of several disjoint matrix multiplications it is shown that multiplication of $N \times N$ matrices (over arbitrary fields) is possible in time $O(N^\beta )$, where $\beta $ is a bit smaller than $3\ln 52/\ln 110 \approx 2.522$.
267 citations
TL;DR: This paper characterizes the queries for which full reducer exist and presents an efficient algorithm for constructing full reducers where they do exist and considers “natural” semijoin operator, which is used in the SDD-1 distributed database system.
Abstract: A semijoin is a relational operator that is used to reduce the cost of processing queries in the SDD-1 distributed database system, the RAP database machine, and similar systems. Semijoin is used in these systems as part of a query pre-processing phase; its function is to “reduce” the database by delimiting those portions of the database that contain data relevant to the query. For some queries, there exist sequences of semijoins that “fully reduce” the database; those sequences delimit the exact portions of the database needed to answer the query in the sense that if any less data were delimited then the query would produce a different answer. Such sequences are called full reducers.This paper characterizes the queries for which full reducers exist and presents an efficient algorithm for constructing full reducers where they do exist.This paper extends the results of Bernstein and Chiu [J. Assoc. Comput. Mach., 28 (1981), pp. 25–40] by considering a more powerful semijoin operator. We consider “natural” ...
240 citations
TL;DR: This paper shows that the edge-deletion problem is NP-complete for the following properties: (1) without cycles of specified length l, or of any length $ \leqq l$, (2) connected and degree-constrained, (3) outerplanar, (4) transitive digraph, (5) line-invertible, (6) bipartite, (7)transitively orientable.
Abstract: If $\pi $ is a property on graphs or digraphs, the edge-deletion problem can be stated as follows: find the minimum number of edges whose deletion results in a subgraph (or subdigraph) satisfying property $\pi $. Several well-studied graph problems can be formulated as edge-deletion problems.In this paper we show that the edge-deletion problem is NP-complete for the following properties: (1) without cycles of specified length l, or of any length $ \leqq l$, (2) connected and degree-constrained, (3) outerplanar, (4) transitive digraph, (5) line-invertible, (6) bipartite, (7) transitively orientable. For problems (5), (6), (7) we determine the best possible bounds on the node-degrees for which the problems remain NP-complete.
TL;DR: It is shown that for each fixed $n \geqq 3$ it is NP-complete to determine whether an arbitrary graph can be edge-partitioned into subgraphs isomorphic to the complete graph K_n.
Abstract: We show that for each fixed $n \geqq 3$ it is NP-complete to determine whether an arbitrary graph can be edge-partitioned into subgraphs isomorphic to the complete graph $K_n $. The NP-completeness of a number of other edge-partition problems follows immediately.
TL;DR: The results show that the perfect matching problem is essentially the only instance of the G-factor problem that is likely to admit a polynomial time bounded solution, and if G has any component with three or more vertices then the existence question for G-factors is NP-complete.
Abstract: For arbitrary graphs G and H, a G-factor of H is a spanning subgraph of H composed of disjoint copies of G. G-factors are natural generalizations of l-factors (or perfect matchings), in which G replaces the complete graph on two vertices. Our results show that the perfect matching problem is essentially the only instance of the G-factor problem that is likely to admit a polynomial time bounded solution. Specifically, if G has any component with three or more vertices then the existence question for G-factors is NP-complete. (In all other cases the question can be resolved in polynomial time.) .br The notion of a G-factor is further generalized by replacing G by an arbitrary family of graphs. This generalization forms the foundation for an extension of the traditional theory of matching. This theory, whose details will be developed elsewhere, includes, in addition to further NP-completeness results, new polynomial algorithms and simple duality results. Some indication of the nature and scope of this theory are presented here.
TL;DR: This work provides an $O(n\log n)$ algorithm based on the concept of “forbidden regions” for the one-processor case, a generalization that considerably increases the difficulty of the problem even for only a single processor.
Abstract: The basic problem considered is that of scheduling n unit-time tasks, with arbitrary release times and deadlines, so as to minimize the maximum task completion time. Previous work has shown that this problem can be solved rather easily when all release times are integers. We are concerned with the general case in which noninteger release times are allowed, a generalization that considerably increases the difficulty of the problem even for only a single processor. Our results are for the one-processor case, where we provide an $O(n\log n)$ algorithm based on the concept of “forbidden regions”.
TL;DR: An algorithm is presented which determines the amount of time required to pass, or to broadcast, a unit of information from an arbitrary vertex to every other vertex in a tree and it is shown that the subtree induced by the broadcast center of a tree is always a star with two or more vertices.
Abstract: In large organizations there is frequently a need to pass information from one place, e.g., the president’s office or company headquarters, to all other divisions, departments or employees. This is often done along organizational reporting lines. Insofar as most organizations are structured in a hierarchical or treelike fashion, this can be described as a process of information dissemination in trees. In this paper we present an algorithm which determines the amount of time required to pass, or to broadcast, a unit of information from an arbitrary vertex to every other vertex in a tree. As a byproduct of this algorithm we determine the broadcast center of a tree, i.e., the set of all vertices from which broadcasting can be accomplished in the least amount of time. It is shown that the subtree induced by the broadcast center of a tree is always a star with two or more vertices. We also show that the problem of determining the minimum amount of time required to broadcast from an arbitrary vertex in an arbit...
TL;DR: A general-purpose algorithm that can solve a number of NP-complete problems in time $T = O(2^{n/2} )$ and space and can be generalized to a fam...
Abstract: In this paper we develop a general-purpose algorithm that can solve a number of NP-complete problems in time $T = O(2^{n/2} )$ and space $S = O(2^{n/4} )$. The algorithm can be generalized to a fam...
TL;DR: It is shown that the sequence 2^0, 2^1, 2 \cdots, 2^{n - 1} ,2^ n - 1\} can be computed with $n + 2.13\sqrt n + \log n$ additions, and that the lower bound result is applied to show that the addition-sequence problem is NP-complete.
Abstract: Given a sequence $n_1 , \cdots ,n_m $ of positive integers, what is the smallest number of additions needed to compute all m integers starting with 1? This generalization of the addition chain ($m = 1$) problem will be called the addition-sequence problem. We show that the sequence $\{ 2^0 ,2^1 , \cdots ,2^{n - 1} ,2^n - 1\} $ can be computed with $n + 2.13\sqrt n + \log n$ additions, and that $n + \sqrt n - 2$ is a lower bound. This lower bound result is applied to show that the addition-sequence problem is NP-complete.
TL;DR: Several altered or generalized versions of the ISOMORPHISM problem are presented and shown to be NP-complete and one of these is the problem of determining whether a given graph has a fixed-point-free automorphism.
Abstract: The GRAPH ISOMORPHISM problem has so far resisted attempts at determining its complexity status—it has not been shown to be NP-complete nor in P. In this paper several altered or generalized versions of the ISOMORPHISM problem are presented and shown to be NP-complete. One of these is the problem of determining whether a given graph has a fixed-point-free automorphism. Some speculation is made on the possible implications of these results on deciding the complexity status of ISOMORPHISM. Various classes and hierarchies of problems in NP are discussed.
TL;DR: This work considers the problem of choosing K “medians” among n points on the Euclidean plane such that the sum of the distances from each of the n points to its closest median is minimized and presents two heuristics that produce arbitrarily good solutions with probability going to 1.
Abstract: We consider the problem of choosing K “medians” among n points on the Euclidean plane such that the sum of the distances from each of the n points to its closest median is minimized. We show that this problem is NP-complete. We also present two heuristics that produce arbitrarily good solutions with probability going to 1. One is a partition heuristic, and works when K grows linearly—or almost so—with n. The other is the “honeycomb” heuristic, and is applicable to rates of growth of K of the form $K \sim n^\varepsilon $, $0 < \varepsilon < 1$.
TL;DR: The methods developed here are applied to improve the previously known upper bounds for the time complexity of various location problems.
Abstract: Many known algorithms are based on selection in a set whose cardinality is superlinear in terms of the input length. It is desirable in these cases to have selection algorithms that run in sublinear time in terms of the cardinality of the set. This paper presents a successful development in this direction. The methods developed here are applied to improve the previously known upper bounds for the time complexity of various location problems.
TL;DR: This paper presents a practical algorithm which runs in less than $6\lceil {\log _2 n} \rceil $ comparisons on a data structure which uses O(n\log n) storage, in the worst case.
Abstract: Given a planar straight line graph G with n vertices and a point $P_0 $, locating $P_0 $ means to find the region of the planar subdivision induced by G which contains $P_0 $. Recently, Lipton and Tarjan presented a brilliant but extremely complex point location algorithm which runs in time $O(\log n)$ on a data structure using $O(n)$ storage. This paper presents a practical algorithm which runs in less than $6\lceil {\log _2 n} \rceil $ comparisons on a data structure which uses $O(n\log n)$ storage, in the worst case. The method rests crucially on a simple partition of each edge of G into $O(\log n)$ segments.
TL;DR: In the algorithms for finding minimum spanning trees, bridges, and fundamental cycles, the number of processors used is small enough that the parallel algorithm is efficient in comparison with the best sequential algorithms for these problems.
Abstract: Algorithms for solving graph problems on an unbounded parallel model of computation are considered. Parallel algorithms of time complexity $O(\log ^2 n)$ are described for finding biconnected components, bridges, minimum spanning trees and fundamental cycles. In the algorithms for finding minimum spanning trees, bridges, and fundamental cycles, the number of processors used is small enough that the parallel algorithm is efficient in comparison with the best sequential algorithms for these problems. Several other algorithms are presented which are especially suitable for processing sparse graphs.
TL;DR: It is shown that the “greedy” heuristic of repeatedly matching the two closest unmatched points can be implemented in worst-case time $O(n^2 \log n)$, a reasonable savings compared to the general minimum weighted matching algorithm which requires time proportional to $n^3 $ to find the minimum cost matching in a weighted graph.
Abstract: Finding a minimum weighted complete matching on a set of vertices in which the distances satisfy the triangle inequality is of general interest and of particular importance when drawing graphs on a mechanical plotter. The “greedy” heuristic of repeatedly matching the two closest unmatched points can be implemented in worst-case time $O(n^2 \log n)$, a reasonable savings compared to the general minimum weighted matching algorithm which requires time proportional to $n^3 $ to find the minimum cost matching in a weighted graph. We show that, for an even number n of vertices whose distances satisfy the triangle inequality, the ratio of the cost of the matching produced by this greedy heuristic to the cost of the minimal matching is at most ${}_3^4 n^{\lg _2^3 } - 1$, $\lg _2^3 \approx 0.58496$, and there are examples that achieve this bound. We conclude that this greedy heuristic, although desirable because of its simplicity, would be a poor choice for this problem.
TL;DR: An algorithm based upon Edmonds’s procedure for testing isomorphism of trees is extended to answer various questions concerning automorphisms of a labeled forest.
Abstract: An algorithm based upon Edmonds’s procedure for testing isomorphism of trees is extended to answer various questions concerning automorphisms of a labeled forest. This and linear pattern matching techniques are used to build efficient algorithms which find the automorphism partition and a set of generators for the automorphism group, determine the order of the automorphism group, and compute a coding for forests, interval graphs, outerplanar graphs, and planar graphs.
TL;DR: It is shown that being polynomial time m-complete in EXP does not provide any control of the probability of erroneous approximations and the relationship between completeness and approximability is studied.
Abstract: Polynomial time approximations to exponential time computable problems (EXP) are considered from the point of view of structure. Infinitely often speedable and almost everywhere complex problems are studied using the notions of polynomial time productivity and immunity. In particular, the existence of a polynomial time immune set which is not polynomial time approximable at all but which is polynomial time $tt$-complete in EXP is proven. The relationship between completeness and approximability is also studied. It is shown that being polynomial time m-complete in EXP does not provide any control of the probability of erroneous approximations.
TL;DR: This paper presents an algorithm for finding K minimum spanning trees in an undirected graph based on three subroutines which obtains the kth minimum spanning tree in $O(m)$ steps when the jthminimum spanning trees for $j = 1,2, \cdots ,k - 1$ are given.
Abstract: This paper presents an algorithm for finding K minimum spanning trees in an undirected graph. The required time is $O(Km + \min (n^2 ,m\log \log n))$ and the space is $O(K + m)$, where n is the number of vertices and m is the number of edges. The algorithm is based on three subroutines. The first two subroutines are used to obtain the second minimum spanning tree in $O(\min (n^2 ,m\alpha (m,n)))$ steps, where $\alpha (m,n)$ is Tarjan’s inverse of Ackermann’s function [12] which is very slowly growing. The third one obtains the kth minimum spanning tree in $O(m)$ steps when the jth minimum spanning trees for $j = 1,2, \cdots ,k - 1$ are given.
TL;DR: It is argued that this question reduces to the equivalence of the sets of fixed points of the project-join mappings associated with the two database schemes in question, and the “update sets” approach to database design is introduced.
Abstract: We investigate the question of when two database schemes embody the same information. We argue that this question reduces to the equivalence of the sets of fixed points of the project-join mappings associated with the two database schemes in question. When data dependencies are given, we need only consider those fixed points that satisfy the dependencies. A polynomial algorithm to test the equivalence of database schemes, when there are no dependencies, is given. We also provide an exponential algorithm to handle the case where there are functional and/or multivalued dependencies. Furthermore, we give a polynomial time test to determine whether a project-join mapping preserves a set of functional dependencies, and a polynomial time algorithm for equivalence of database schemes whose project-join mappings do preserve the given set of functional dependencies. Lastly, we introduce the “update sets” approach to database design as an application of these results.
TL;DR: This paper presents a procedure for sequencing a set of jobs on a single processor (machine) with the objective of minimizing the mean flow time, when the jobs may have unequal ready times.
Abstract: This paper presents a procedure for sequencing a set of jobs on a single processor (machine) with the objective of minimizing the mean flow time, when the jobs may have unequal ready times. The procedure involves implicit enumeration with the branch and bound technique, coupled with some devices to improve the efficiency of the search. The devices include a sufficient optimality condition, a simple but tight lower bound and rules for tree pruning. The approach has potential applications to other sequencing problems.
TL;DR: A technique is presented for deriving lower bounds on the complexity of optimal data structures which permit insertions and deletions of records, and queries of the form query (Region) where value (r) lies in a commutative semi-group S, and $\Gamma $ denotes a set of regions of the space of possible keys.
Abstract: A technique is presented for deriving lower bounds on the complexity of optimal data structures which permit insertions and deletions of records, and queries of the form \[ {\text{Query (Region)}};\quad {\text{Return}}\quad \sum_{\begin{subarray}{l} {\text{key}}(r) \\ \in {\text{Region}} \end{subarray}} {{\text{value }}(r)} \quad ({\text{Region}} \in \Gamma ), \] where value$(r)$ (the value associated with a record r) lies in a commutative semi-group S, and $\Gamma $ denotes a set of regions of the space of possible keys. This technique is illustrated with several examples.
TL;DR: Formulas are given for the expected number of nodes in the backtrack tree that is generated while searching for all the solutions of a random predicate, a set of predicates that obeys the following conditions.
Abstract: Formulas are given for the expected number of nodes in the backtrack tree that is generated while searching for all the solutions of a random predicate. The most general formulas apply to selection from any set of predicates that obeys the following conditions. Each predicate is the conjunction of t terms selected from a set of terms T. For any subset $T' \leqq T$, the probability that the predicate contains only terms from $T'$ depends only on the size of $T'$. The set T must remain unchanged if each variable $x_i $ is replaced by $p_i (x_i )$, where $p_i $ is a permutation function. The time needed to evaluate the general formulas is proportional to v, the number of variables in the predicate. More detailed consideration is given to predicates whose terms are random disjunctive clauses with s literals, $t = v^\alpha $ for some $1 < \alpha < s$, and the random selections are done with repetition. For this case the expected number of nodes is $\exp [O(v^{(s - \alpha )/(s - 1)} )]$. (Complete enumeration r...