Abstract: Several polynomial time algorithms finding “good,” but not necessarily optimal, tours for the traveling salesman problem are considered. We measure the closeness of a tour by the ratio of the obtained tour length to the minimal tour length. For the nearest neighbor method, we show the ratio is bounded above by a logarithmic function of the number of nodes. We also provide a logarithmic lower bound on the worst case. A class of approximation methods we call insertion methods are studied, and these are also shown to have a logarithmic upper bound. For two specific insertion methods, which we call nearest insertion and cheapest insertion, the ratio is shown to have a constant upper bound of 2, and examples are provided that come arbitrarily close to this upper bound. It is also shown that for any n≥8, there are traveling salesman problems with n nodes having tours which cannot be improved by making n/4 edge changes, but for which the ratio is 2(1−1/n).

Abstract: The problem of generating all the maximal independent sets (or maximal cliques) of a given graph is fundamental in graph theory and is also one of the most important in terms of the application of graph theory. In this paper, we present a new efficient algorithm for generating all the maximal independent sets, for which processing time and memory space are bounded by $O(nm\mu)$ and $O(n+m)$, respectively, where n, m, and $\mu$ are the numbers of vertices, edges, and maximal independent sets of a graph.

Abstract: The problem of finding a minimum spanning tree connecting n points in a k-dimensional space is discussed under three common distance metrics -- Euclidean, rectilinear, and $L_\infty$. By employing a subroutine that solves the post office problem, we show that, for fixed k $\geq$ 3, such a minimum spanning tree can be found in time O($n^{2-a(k)} {(log n)}^{1-a(k)}$), where a(k) = $2^{-(k+1)}$. The bound can be improved to O(${(n log n)}^{1.8}$) for points in the 3-dimensional Euclidean space. We also obtain o($n^2$) algorithms for finding a farthest pair in a set of n points and for other related problems.

Abstract: Let n be an odd integer. Take a random number a from a uniform distribution on the set $\{1, 2,\cdots, n -1\}$. If a and n are relatively prime, compute the residue $\varepsilon \equiv a^{(n - 1)/2...

Abstract: Turing machine space complexity is related to circuit depth complexity. The relationship complements the known connection between Turing machine time and circuit size, thus enabling us to expose the related nature of some important open problems concerning Turing machine and circuit complexity. We are also able to show some connection between Turing machine complexity and arithmetic complexity.

Abstract: We study the performance of LPT (largest processing time) schedules with respect to optimal schedules in a nonpreemptive multiprocessor environment. The processors are assumed to have different speeds and the tasks being scheduled are independent.

Abstract: Given a set $\mathcal{T} = \{ T_1 ,T_2 , \cdots ,T_n \} $ of tasks, each $T_i$ having execution time 1, an integer start-time $s_i \geqq 0$ and a deadline $d_i > 0$, along with precedence constraints among the tasks, we examine the problem of determining whether there exists a schedule on two identical processors that executes each task in the time interval between its start-time and deadline. We present an $O(n^3)$ algorithm that constructs such a schedule whenever one exists. The algorithm may also be used in a binary search mode to find the shortest such schedule or to find a schedule that minimizes maximum “tardiness”. A number of natural extensions of this problem are seen to be $NP$ complete and hence probably intractable.

Abstract: Given a subdivision of the plane induced by a planar graph with n vertices, in this paper we consider the problem of identifying which region of the subdivision contains a given test point. We present a search algorithm, called point-location algorithm, which operates on a suitably preprocessed data structure. The search runs in time at most $O((\log n)^{2})$, while the preprocessing task runs in time at most $O(n \log n)$ and requires $O(n)$ storage. The methods are quite general, since an arbitrary subdivision can be transformed in time at most $O(n \log n)$ into one to which the preprocessing procedure is applicable. This solution of the point location problem yields interesting and efficient solutions of other geometric problems, such as spatial convex inclusion and inclusion in an arbitrary polygon.

Abstract: Two algorithms for generating spanning trees of a connected graph in order of increasing weight are presented. The first generates the K smallest weight trees, where K can be specified in advance or during execution of the algorithm. The run time is $O(KE\alpha (E,V) + E\log E)$ and the space is $O(K + E)$; here V is the number of vertices, E is the number of edges, and $\alpha$ is Tarjan’s inverse of Ackermann’s function and is very slow-growing. The algorithm uses a minimum weight spanning tree as a “reference tree”, and exchanges edges to derive other trees. The second algorithm, a modification of the first, generates all spanning trees of the graph, in order. If N is the number of spanning trees, the time is $O(NE)$ and the space is $O(N+E)$.

Abstract: We represent a binary tree by the level numbers of its leaves from left to right Thus every binary tree of n leaves corresponds to a sequence of n numbers We first give the necessary and sufficient conditions for a sequence to represent a binary tree; then we give an algorithm for generating all the feasible sequences lexicographically as a list Also, algorithms are developed to determine the position of a given sequence, or to generate the sequence of a given position Finally, it is shown that the average time per sequence generated is constant (independent of the length of the sequence)

Abstract: A new algorithm for constructing minimum cost binary trees in $O(n \log n)$ time is presented. The algorithm is similar to the well-known Hu-Tucker algorithm. Our proof of validity is based on finite variational methods and is therefore quite different and somewhat simpler than the proof for the Hu-Tucker algorithm. Our proof also yields some additional information about the structure of minimum cost binary trees. This permits a linear time implementation of our algorithm in a special case.

Abstract: Coffman and Graham give an algorithm to schedule unit execution time task systems nonpreemptively. On two processors, their algorithm is optimal. We show that in general, if $\omega$ is the length of a schedule produced by their algorithm and $\omega_0$ the length of an optimal schedule, then $\omega / \omega_{0} \leqq 2 - 2/m$, where m is the number of processors. The preemptive equivalent of the above algorithm has been considered by Muntz and Coffman. Again we show that the ratio of the lengths of theirs and an optimal schedule is bounded by $2 - 2/m$. In both the nonpreemptive and the preemptive cases there exist task systems for which the ratio $2 - 2/m$ can be approached arbitrarily closely. On a small number of machines, $2 - 2/m$ is not too far from 1. In particular, as noted above, on two machines the ratio is 1.

Abstract: A set of queries Q is said to have the consecutive retrieval property with respect to a set of records R if there exists an organization of the record set (without duplication of any record) such t...

Abstract: Any algorithm for finding a pattern of length k in a string of length n must examine at least $n - k + 1$ of the characters of the string in the worst case. By considering the pattern $00 \cdots 0$, we prove that this is the best possible result. Therefore there do not exist pattern matching algorithms whose worst-case behavior is “sublinear” in n (that is, linear with constant less than one), in contrast with the situation for average behavior (the Boyer-Moore algorithm is known to be sublinear on the average).

Abstract: Consider the combinational complexity $L(f)$ of Boolean functions over the basis $\Omega = \{ f|f:\{ 0,1\} ^2 \to \{ 0,1\} \} $. A new method for proving linear lower bounds of size $2n$ is presented. Combining it with methods presented in Savage [13, (1974)] and Schnorr [18, (1974)], we establish for a special sequence of functions $f_n :\{ 0,1\} ^{n + 2\log (n) + 1} \to \{ 0,1\} :2.5n \leqq L(f) \leqq 6n$. Also a trade-off result between circuit complexity and formula size is derived.

Abstract: Several procedures based on (not necessarily regular) resolution for checking whether a formula in CF3 is contradictory are considered. The procedures use various methods of bounding the size of the clauses which are generated. The following results are obtained:1. All of the proposed procedures which are forced to run in polynomial time do not always work—i.e., they do not identify all contradictory formulas.2. Those which always work must run in exponential time. The exponential lower bounds for these procedures do not follow directly from Tseitin’s lower bound for regular resolution since these procedures also allow nonregular resolution trees.

Abstract: This paper considers a model of a computing system with several independent but identical processors, each with a private memory of limited, and possibly different, storage capacity. The tasks are assumed to have known resource demands expressed as processing times and memory requirements. Several scheduling strategies are evaluated by worst-case performance bounds and simulation results. Both preemptive and nonpreemptive scheduling are considered. An optimal preemptive algorithm is given to find the shortest schedule for a task set with no precedence constraints.

Abstract: The partial fraction decomposition of a proper rational function whose denominator has degree n and is given in general factored form can be done in $O(n \log^{2}n)$ operations in the worst case. Previous algorithms require $O(n^{3})$ operations, and $O(n \log^{2}n)$ operations for the special case where the factors appearing in the denominator are all linear.

Abstract: There is no recursive function bounding the succinctness gained using ambiguous grammars rather than unambiguous ones in the description of unambiguous context-free languages.

Abstract: This paper considers the general problem of specifying the meaning of programming languages which include "data type definition facilities". The fundamental question posed in attempting to define such languages is: "what meaning should be given to a data type definition," or more simply, "what does data type mean?". In this paper we describe a new approach to defining the meaning of data types and give its application to the definition of a typed lambda calculus extension. We also prove a theorem stating that our language is "strongly typed".

Abstract: It is very often more convenient and more meaningful to specify a set of structural descriptions analytically rather than generatively, i.e., by specifying a set of constraints each structured description in the set has to satisfy. Peters and Ritchie [7] have shown that if context-sensitive rules are used only for “analysis” then the string language of the set of trees is still context-free. In this paper, we have generalized this result by considering context-free rules constrained by Boolean combinations of proper analysis predicates and domination predicates. These rules, called "local transformations" not only make precise an informal and briefly discussed notion of Chomsky [2], but also, generalize it in an appropriate manner. It is shown that the Peters-Ritchie result can be generalized to local transformations. Linguistic relevance of this result has been also briefly discussed. Results in this paper are relevant to the following situation: Patterns of a class, say A, may be difficult to characteri...

Abstract: We correct some errors in Spira’s algorithm for the all-pairs shortest-path problem, and empirically compare his algorithm (with two distinct sorting, routines) to Dijkstra’s procedure. The results show that Spira’s algorithm is only efficient for “large” networks. Furthermore, it is seen that the asymptotic number of additions and comparisons required by two algorithms may be a very poor indicator of their relative running times.

Abstract: It is shown by simulation that every language accepted within time $n^d$ by a nondeter-ministic one-dimensional Turing machine is accepted in linear time by a nondeterministic d-dimensional iterative array. Conversely, every language accepted in linear time by such an iterative array is accepted within time $n^{d+1}$ by a nondeterministic one-dimensional Turing machine. It follows that the class of languages accepted in linear time by nondeterministic multidimensional iterative arrays is precisely Karp’s class NP, that nondeterministic $(d + 2)$-dimensional iterative arrays are more powerful than nondeterministic d-dimensional iterative arrays, and that nondeterministic two-dimensional iterative arrays are more powerful than the entire class of nondeterministic multidimensional Turing machines. Related deterministic results are surveyed and summarized for comparison.

Abstract: A general class of buddy systems is defined and the overallocation of memory due to internal fragmentation is examined. It is shown that, for a uniform distribution of requests, the overallocation varies between $2x_{1}/(x_{1}+1)$ and $\frac{1}{2}(x_{1}+1)$, where $x_{1}>1$ is the largest real root of the characteristic equation of the particular buddy system. Bounds are found for the overallocation for request distributions characterized by a parameterization of Zipf’s law. The expected value of the overallocation is independent of the request distribution within wide values of the parameter, and is given by $(x_{1}-1)/\ln x_{1}$. For the binary buddy system $x_{1}= 2$; the overallocation varies between 1.33 and 1.50 and the expected value is $\approx 1.44$.

Abstract: The problem of generation of loop invariants from the input, output assertions of a loop program $({\textbf{while }}B{\textbf{ do }}S)$ is considered. The problem is theoretically unsolvable in general. As a special case we consider assertions of the form $xRy$, where R denotes a binary relation, x denotes the variables manipulated by the program and y denotes variables that are not modified by the(program. We derive conditions for R such that if any loop program has $xRy$ as the input and output assertions, then $xRy$ is a loop invariant. These conditions for R are shown to be necessary and sufficient in that if some $R'$ does not meet these conditions, then there are loop programs for which $xR'y$ holds at entrance and exit, though not following every iteration. In particular it is shown that if R is an equivalence relation, then under certain reasonable restrictions on the loop, $xRy$ holds at entrance and exit of the loop if and only if it holds after every iteration.

Abstract: A read-forward polyphase merge algorithm is described which performs the polyphase merge starting from an arbitrary string distribution. This algorithm minimizes the volume of information moved. Since this volume is easily computed, it is possible to construct dispersion algorithms which anticipate the merge algorithm. Two such dispersion techniques are described. The first algorithm requires that the number of strings to be dispersed be known in advance; this algorithm is optimal. The second algorithm makes no such requirement, but is not always optimal. In addition, performance estimates are derived and both algorithms are shown to be asymptotically optimal.

Abstract: Under a virtual storage operating system, the time spent by a list processing language on garbage collection varies in a complex manner with the amount of memory allocated. This dependence is investigated and strategies for minimizing the time spent on garbage collection are given.

Abstract: Let F be an arbitrary context-free grammar form and $\mathcal{G}(F)$ the family of grammars defined by F For each grammar G in $\mathcal{G}(F)$, the derivation complexity function $\Phi _G$, on the language of G, is defined for each word x as the number of steps in a minimal G-derivation of x It is shown that derivations may always be speeded up by any constant factor n, in the sense that for each positive integer n, an equivalent grammar $G'$ in $\mathcal{G}(F)$ can be found so that $\Phi _{G'} (x) \leqq | x | / n$ for all large words $x,| x |$ denoting the length of x