scispace - formally typeset
Search or ask a question

Showing papers on "Time complexity published in 1979"


Journal ArticleDOI
TL;DR: Three simple efficient algorithms with good probabilistic behaviour are described and an algorithm with a run time of O ( n log n ) which almost certainly finds a perfect matching in a random graph of at least cn log n edges is analyzed.

681 citations


Proceedings ArticleDOI
30 Apr 1979
TL;DR: The complexity of the Discrete Fourier Transform is studied with respect to a new model of computation appropriate to VLSI technology, which focuses on two key parameters, the amount of silicon area and time required to implement a DFT on a single chip.
Abstract: The complexity of the Discrete Fourier Transform (DFT) is studied with respect to a new model of computation appropriate to VLSI technology. This model focuses on two key parameters, the amount of silicon area and time required to implement a DFT on a single chip. Lower bounds on area (A) and time (T) are related to the number of points (N) in the DFT: AT2≥ N2/16. This inequality holds for any chip design based on any algorithm, and is nearly tight when T = θ(N1/2) or T = θ(log N). A more general lower bound is also derived: ATx = Ω(N1+x/2), for 0≤×≤2.

441 citations


Journal ArticleDOI
TL;DR: It is shown that n steps of the computation of an arbitrary machine with one- dimensional tapes can be performed by a combinational logic network of cost O( n log n) and delay O(n) and the results are the best possible, at least insofar as on-hne simulation is concerned.
Abstract: Various computational models (such as machines and combinational logic networks) induce various and, m general, different computational complexity measures Relations among these measures are established by studying the ways m which one model can "simulate" another It ts shown that a machine with k-dimensional storage tapes (respectively, with tree-structured storage media) can be simulated on-hne by a machine with one- dimensional storage tapes m time O(n 2-ilk) (respectively, m time O(n2/log n)) An obhv:ous machine Is defined to be one whose head posmons, as functions of time, are independent of the input, and It Is shown that any machine with one-d~menslonal tapes can be simulated on-hne by an oblivious machine with two one-dimensional tapes in time O(n log n) All of these results are the best possible, at least insofar as on-hne simulation is concerned. By slmdar methods It is shown that n steps of the computation of an arbitrary machine with one- dimensional tapes can be performed by a combinational logic network of cost O(n log n) and delay O(n)

427 citations


Journal ArticleDOI
TL;DR: This note presents an improvement to LeLann's algorithm for finding the largest (or smallest) of a set of uniquely numbered processes arranged in a circle, in which no central controller exists and the number of processes is not known a priori.
Abstract: This note presents an improvement to LeLann's algorithm for finding the largest (or smallest) of a set of uniquely numbered processes arranged in a circle, in which no central controller exists and the number of processes is not known a priori. This decentralized algorithm uses a technique of selective message extinction in order to achieve an average number of message passes of order (n log n) rather than O(n2).

376 citations


Journal ArticleDOI
TL;DR: A method for computing functions defined on paths in trees based on tree manipulation techniques first used for efficiently representing equivalence relations, which has an almost-linear running time and is useful for solving certain kinds of pathfinding problems on reducible graphs.
Abstract: We devise a method for computing functions defined on paths in trees. The method is based on tree manipulation techniques first used for efficiently representing equivalence relations. It has an almost-linear running time. We apply the method to give O(m $\alpha$(m,n)) algorithms for two problems. A. Verifying a minimum spanning tree in an undirected graph (best previous bound: O(m log log n) ). B. Finding dominators in a directed graph (best previous bound: O(n log n + m) ). Here n is the number of vertices and m the number of edges in the problem graph, and $\alpha$(m,n) is a very slowly growing function which is related to a functional inverse of Ackermann''s function. The method is also useful for solving, in O(m $\alpha$(m,n)) time, certain kinds of pathfinding problems on reducible graphs. Such problems occur in global flow analysis of computer programs and in other contexts. A companion paper will discuss this application.

324 citations


Proceedings ArticleDOI
29 Oct 1979
TL;DR: An O(n lgn) algorithm is presented for the construction of skeletons of arbitrary n-line polygonal figures that employs a linear time algorithm for the merging of two arbitrary (standard) Voronoi diagrams.
Abstract: An O(n lgn) algorithm is presented for the construction of skeletons of arbitrary n-line polygonal figures. This algorithm is based on an O(n lgn) algorithm for the construction of generalized Voronoi diagrams (our generalization replaces point sets by sets of line segments constrained to intersect only at end points). The generalized Voronoi diagram algorithm employs a linear time algorithm for the merging of two arbitrary (standard) Voronoi diagrams.

288 citations


Journal ArticleDOI
TL;DR: This work considers a bottleneck location problem on a graph and presents an efficient (polynomial time) algorithm for solving it, and shows that two other bottleneck location problems, finding K -centers and absolute K - centres of a graph appear to be very difficult to solve even for reasonably good approximate solutions.

226 citations


01 Jan 1979
TL;DR: This thesis describes an algorithm for the off-line MIN that organizes its computation in the form of a complete binary tree that relies on redundancy in its representation of the input graph, and introduces three techniques that permit the design of parallel algorithms that are efficient in terms of both their time and processor requirements.
Abstract: Recent advances in microelectronics have brought closer to feasibility the construction of computers containing thousands (or more) of processing elements. This thesis addresses the question of effective utilization of such processing power. We study the computational complexity of synchronous paarallel computations using a model of computation based on random access machines operating in parallel and sharing a common memory, the P-RAM. Two main areas within the field of parallel computational complexity are investigated. First, we explore the power of the P-RAM model viewed as an abstract computing device. Later, we study techniques for developing efficient algorithms for parallel computers. We are able to give concise characterizations of the power of deterministic and nondeterministic P-RAMS in terms of the more widely known space and time complexity classes for multi-tape Turing machines. Roughly speaking, time-bounded deterministic P-RAMS are equivalent in power to (can accept the same sets as) space-bounded Turing machines, where the time and space bounds differ by at most a polynomial. In the context of comparing models of computation, we consider such polynomial differences in resources to be insignificant. Adding the feature of nondeterminism to the time-bounded P-RAM changes its power to that of a nondeterministic Turing machine with an exponentially higher running time. The later sections of the thesis examine algorithm design techniques for parallel computers. We first develop efficient procedures for some common operations on linked lists and arrays. Given this background, we introduce three techniques that permit the design of parallel algorithms that are efficient in terms of both their time and processor requirements. We illustrate the use of these techniques by presenting time and processor efficient algorithms for three problems, in each case improving upon the best previously known parallel resource bounds. We show how to compute minimum string edit distances, using the technique of pairwise function composition. We describe an algorithm for the off-line MIN that organizes its computation in the form of a complete binary tree. Finally, we present an algorithm for undirected graph connectivity that relies on redundancy in its representation of the input graph.

224 citations


Journal ArticleDOI
Gupta1, Lee1, Leung
TL;DR: A Θ(N log N) algorithm is exhibited which is optimal for finding a minimal partition of this set of intervals such that no element of the partition contains two overlapping intervals.
Abstract: Given a set of intervals (pairs of real numbers), we look at the problem of finding a minimal partition of this set such that no element of the partition contains two overlapping intervals. We exhibit a Θ(N log N) algorithm which is optimal. The problem has applications in LSI layout design and job scheduling.

156 citations


Journal ArticleDOI
TL;DR: Two algorithms for the solution of linear Diophantine systems, which well restrain intermediate expression swell, are presented and a polynomial time bound is derived.
Abstract: Two algorithms for the solution of linear Diophantine systems, which well restrain intermediate expression swell, are presented. One is an extension and improvement of Kannan and Bachem’s algorithm for the Smith and the Hermite normal forms of a nonsingular square integral matrix. The complexity of this algorithm is investigated and a polynomial time bound is derived. Also a much better coefficient bound is obtained compared to Kannan and Bachem’s analysis. The other is based on ideas of Rosser, which were originally used in finding a general solution with smaller coefficients to a linear Diophantine equation and in computing the exact inverse of a nonsingular square integral matrix. These algorithms are implemented by using the infinite precision integer arithmetic capabilities of the SAC-2 system. Their performances are compared. Finally future studies are mentioned.

133 citations


Journal ArticleDOI
TL;DR: It is proved that for every tally language set in NP there exists a polynomial time equivalent set inNP that isp-selective, and it follows that if NEXT ≠ DEXT, then polynometric time Turing and many-one reducibilities differ onNP.
Abstract: The notion ofp-selective sets, and tally languages, are used to study polynomial time reducibilities onNP. P-selectivity has the property that a setA belongs to the classP if and only if bothĀ ≤ A andA isp-selective. We prove that for every tally language set inNP there exists a polynomial time equivalent set inNP that isp-selective. From this result it follows that if NEXT ≠ DEXT, then polynomial time Turing and many-one reducibilities differ onNP.

Journal ArticleDOI
TL;DR: AnO(n) approximation algorithm is presented which tries to determine a nonpreemptive schedule with minimum finish time and extensive empirical results show that the new algorithm is competitive with the LPT algorithm in terms of quality of solution and faster interms of computing time.
Abstract: Givenn jobs andm identical processors anO(n) approximation algorithm is presented which tries to determine a nonpreemptive schedule with minimum finish time. Ifr is the number of jobs placed onto the processor with maximum finish time, then the worst case ratio of the new algorithm's finish time to the optimal solution is shown to be less thanrm/(rm−m+1). Extensive empirical results show that the new algorithm is competitive with the LPT algorithm in terms of quality of solution and faster in terms of computing time.

Journal ArticleDOI
TL;DR: Efficient algorithms for finding maximum flow in planar networks are presented and take advantage of the planarity and are superior to the most efficient algorithms to date.
Abstract: Efficient algorithms for finding maximum flow in planar networks are presented These algorithms take advantage of the planarity and are superior to the most efficient algorithms to date If the source and the terminal are on the same face, an algorithm of Berge is improved and its time complexity is reduced to $O(n\log n)$ In the general case, for a given $D > 0$ a flow of value D is found if one exists; otherwise, it is indicated that no such flow exists This algorithm requires $O(n^2 \log n)$ time If the network is undirected a minimum cut may be found in $O(n^2 \log n)$ time All algorithms require $O(n)$ space

Book ChapterDOI
16 Jul 1979
TL;DR: The notion of p-selective sets, and tally languages, are used to study polynomial time reducibilities on NP as mentioned in this paper, and it has been shown that for every tally language set in NP there exists a polynomially time equivalent set that is pselective.
Abstract: The notion of p-selective sets, and tally languages, are used to study polynomial time reducibilities on NP. P-selectivity has the property that a set A belongs to the class P if and only if both Ā ≤ m P A and A is p-selective. We prove that for every tally language set in NP there exists a polynomial time equivalent set in NP that is p-selective. From this result it follows that if NEXT ≠ DEXT, then polynomial time Turing and many-one reducibilities differ on NP.

Journal ArticleDOI
Zvi Galil1
TL;DR: It is shown how to modify the Boyer-Moore string matching algorithm so that its worst case running time is linear even when multiple occurrences of the pattern are present in the text.
Abstract: It is shown how to modify the Boyer-Moore string matching algorithm so that its worst case running time is linear even when multiple occurrences of the pattern are present in the text.

Journal ArticleDOI
TL;DR: It is shown that any algorithm which determines the outcome of optimal play for one of these games must infinitely often use a number of steps which grows exponentially as a function of the size of the starting position given as input.
Abstract: For a number of two-person combinatorial games, the problem of determining the outcome of optimal play from a given starting position (that is, of determining which player, if either, has a forced win) is shown to be complete in exponential time with respect to logspace-reducibility. As consequences of this property, it is shown that (1) any algorithm which determines the outcome of optimal play for one of these games must infinitely often use a number of steps which grows exponentially as a function of the size of the starting position given as input; and (2) these games are “universal games” in the sense that, if G denotes one of these games and R denotes any member of a large class of combinatorial games (including Chess, Go, and many other games of popular or mathematical interest), then the problem of determining the outcome of R is reducible in polynomial time to the problem of determining the outcome of G.

Proceedings ArticleDOI
30 Apr 1979
TL;DR: This problem is shown to be effectively solvable in the general case and to lead to correct inference in the limit of the pattern languages and a polynomial time algorithm for finding minimal one-variable pattern languages compatible with a given set of strings is given.
Abstract: We motivate, formalize, and study a computational problem in concrete inductive inference. A “pattern” is defined to be a concatenation of constants and variables, and the language of a pattern is defined to be the set of strings obtained by substituting constant strings for the variables. The problem we consider is, given a set of strings, find a minimal pattern language containing this set. This problem is shown to be effectively solvable in the general case and to lead to correct inference in the limit of the pattern languages. There exists a polynomial time algorithm for it in the restricted case of one-variable patterns. Inference from positive data is re-examined, and a characterization given of when it is possible for a family of recursive languages. Various collateral results about patterns and pattern languages are obtained. Section 1 is an introduction explaining the context of this work and informally describing the problem formulation. Section 2 is definitions. Section 3 is results concerning patterns and pattern languages. Section 4 concerns the abstract question of inference from positive data. Section 5 gives a polynomial time algorithm for finding minimal one-variable pattern languages compatible with a given set of strings. Section 6 contains remarks.

Journal ArticleDOI
TL;DR: It is shown that in reducible graphs (and thus in almost all the “practical” flowcharts of programs), minimum cutsets can be found in linear time and that the linear algorithm can check its own applicability to a given graph, thus eliminating the need of prechecking whether it is reducible or not.
Abstract: The analysis of many processes modeled by directed graphs requires the selection of a subset of vertices which cut all the cycles in the graph. Reducing the size of such a cutset usually leads to a simpler and more efficient analysis, but the problem of finding minimum cutsets in general directed graphs is known to be $NP$-complete. In this paper we show that in reducible graphs (and thus in almost all the “practical” flowcharts of programs), minimum cutsets can be found in linear time. We further show that the linear algorithm can check its own applicability to a given graph, thus eliminating the need of prechecking (in nonlinear time) whether it is reducible or not. An immediate application of this result is in program verification systems based on Floyd’s inductive assertions method.

Journal ArticleDOI
TL;DR: A non-trivial factor of a composite number n can be found by performing arithmetic steps in a number proportional to the number of bits in n, and thus there are extremely short straight-line factoring programs.

Journal ArticleDOI
TL;DR: For a general vector linear time series model, this article proved the strong consistency and asymptotic normality of parameter estimates obtained by maximizing a particular time domain approximation to a Gaussian likelihood, although they do not assume that the observations are necessarily normally distributed.
Abstract: For a general vector linear time series model we prove the strong consistency and asymptotic normality of parameter estimates obtained by maximizing a particular time domain approximation to a Gaussian likelihood, although we do not assume that the observations are necessarily normally distributed. To solve the normal equations we set up a constrained Gauss-Newton iteration and obtain the properties of the iterates when the sample size is large. In particular we show that the iterates are efficient when the iteration begins with a VN- consistent estimator. We obtain similar results to the above for a frequency domain approximation to a Gaussian likelihood. We use the asymptotic estimation theory to obtain the asymptotic distribution of several familiar test statistics for testing nonlinear equality constraints.

Proceedings ArticleDOI
30 Apr 1979
TL;DR: It is shown that 2nfa are exponentially more succinct than 2dfa of a certain restricted form, a step toward proving the conjecture that there is a polynomial p, such that every n-state 2 nfa (two-way nondeterministic finite automaton) has an equivalent p(n)-state 2dfA.
Abstract: Establishing good lower bounds on the complexity of languages is an important area of current research in the theory of computation. However, despite much effort, fundamental questions such as P =? NP and L =? NL remain open. To resolve these questions it may be necessary to develop a deep combinatorial understanding of polynomial time or log space computations, possibly a formidable task. One avenue for approaching these problems is to study weaker models of computation for which the analogous problems may be easier to settle, perhaps yielding insight into the original problems. Sakoda and Sipser [3] raise the following question about finite automata: Is there a polynomial p, such that every n-state 2nfa (two-way nondeterministic finite automaton) has an equivalent p(n)-state 2dfa? They conjecture a negative answer to this. In this paper we take a step toward proving this conjecture by showing that 2nfa are exponentially more succinct than 2dfa of a certain restricted form.

Journal ArticleDOI
TL;DR: In this paper, a suboptimal rectilinear Steiner tree algorithm was proposed, which can be constructed in O(n \log n) time and has good average-case and worst-case performance.
Abstract: We propose a suboptimal rectilinear Steiner tree algorithm which can be constructed in O(n \log n) time, and has good average-case and worst case performance.

Proceedings ArticleDOI
30 Apr 1979
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.

Journal ArticleDOI
TL;DR: A new algorithm based on the Lagrange multiplier method is proposed, requiring O[n2(log N)2] time, which is faster if N is much larger than n and the optimal sample size problem related to monitoring the urban air pollution is treated.
Abstract: Consider the resource allocation problem:minimize ∑ni=1fi(xi) subject to ∑ni=1 xi = N and xi's being nonnegative integers, where each fi is a convex function. The well-known algorithm based on the incremental method requires O(N log n + n) time to solve this problem. We propose here a new algorithm based on the Lagrange multiplier method, requiring O[n2(log N)2] time. The latter is faster if N is much larger than n. Such a situation occurs, for example, when the optimal sample size problem related to monitoring the urban air pollution is treated.

Proceedings ArticleDOI
29 Oct 1979
TL;DR: A constructive algorithm for solving systems of linear inequalities (LI) with at most two variables per inequality with polynomial in the size of the input is presented.
Abstract: We present a constructive algorithm for solving systems of linear inequalities (LI) with at most two variables per inequality. The algorithm is polynomial in the size of the input. The LI problem is of importance in complexity theory since it is polynomial time (Turing) equivalent to linear programming. The subclass of LI treated in this paper is also of practical interest in mechanical verification systems, and we believe that the ideas presented can be extended to the general LI problem.

Journal ArticleDOI
TL;DR: The problem of preemptively scheduling a set of n independent jobs on an m processor open shop is discussed and an algorithm to construct preemptive schedules with minimum-maximum finishing time is presented.
Abstract: The problem of preemptively scheduling a set of n independent jobs on an m processor open shop is discussed. An algorithm to construct preemptive schedules with minimum-maximum finishing time is presented. The worst case time complexity is 0(r + min {m4, n4, r2}), where r is the number of nonzero tasks. The maximum number of preemptions introduced is 0(min {rn, rm, n3, m3}). The algorithm is best possible for open shops with a fixed number of processors or jobs. In this case the maximum number of preemptions introduced is bounded by some fixed constant.

01 Jul 1979
TL;DR: In this paper, the running time of the algorithm is polynomial in the number of digits of the coefficients, which can be applied to solve linear programs in O(n) time.
Abstract: : L. G. Khachian's algorithm to check the solvability of a system of linear inequalities with integral coefficients is described. The running time of the algorithm is polynomial in the number of digits of the coefficients. It can be applied to solve linear programs in polynomial time. (Author)

Journal ArticleDOI
TL;DR: This note contains an 0(n log n) time-bounded implementation and extentions for a procedure developed by Sidney for the two-machine maximum flow time problem with series-parallel precedence constraints.
Abstract: This note contains an 0(n log n) time-bounded implementation and extentions for a procedure developed by Sidney for the two-machine maximum flow time problem with series-parallel precedence constraints.

Journal ArticleDOI
TL;DR: Generalized Chandrasekhar type algorithms are obtained that are applicable to linear time varying as well as time invariant distributed systems and the implications are analyzed.

Proceedings ArticleDOI
30 Apr 1979
TL;DR: It is shown that minimum covers can be found in polynomial time, using the notion of direct determination, and the kernel algorithm of Lewis, Sekino, and Ting is improved using these results.
Abstract: Numerous algorithms concerning relational databases use a cover for a set of functional dependencies as all or part of their input. Examples are Bernstein and Beeri's synthesis algorithm [BB] and the tableau modification algorithm of Aho, Beeri, and Ullman [ABU]. The performance of these algorithms may depend both on the number of functional dependencies in the cover and the total size of the cover. Starting with a smaller cover will make such algorithms run faster. After Bernstein [Be75], many researchers believe the problem of finding a minimum cover is NP-complete. We show that minimum covers can be found in polynomial time, using the notion of direct determination. The proof details the structure of minimum covers, refining the structure Bernstein and Beeri show for non-redundant covers [BB]. The kernel algorithm of Lewis, Sekino, and Ting [LST] is improved using these results.