Worst-case Time Complexity Research Articles

A parallel algorithm for solving sparse triangular systems

A fast parallel algorithm, which is generalized from the parallel algorithms for solving banded linear systems, is proposed to solve sparse triangular systems. The original problem is transformed into a directed graph. The solving procedure then consists of eliminating edges in this graph. The worst-case time-complexity of this parallel algorithm is O(log/sup 2/n) where n is the size of the coefficient matrix. When the coefficient matrix is a triangular banded matrix with bandwidth m, then the time-complexity of the algorithm is O(log(m)*log(n)). >

Efficient VLSI parallel algorithm for Delaunay triangulation on orthogonal tree network in two and three dimensions

An algorithm with worst case time complexity O(log/sup 2/N) in two dimensions and O(m/sup 1/2/log N) in three dimensions with N input points and m as the number of tetrahedra in triangulation is given. Its AT/sup 2/ VLSI complexity on Thompson's logarithmic delay model, (1983) is O(N/sup 2/log/sup 6/N) in two dimensions and O(m/sup 2/Nlog/sup 4/ N) in three dimensions.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A compact representation of hierarchical relations using decimal notations

A decimal notation satisfies many simple mathematical properties. and it is a useful tool in the analysis of trees. A practical method is presented, that compresses the decimal codes while maintaining the fast determination of relations (e.g., ancestor, descendant, brother, etc.). A special node. called a kernel node,including many common subcodes of the other codes, is defined, and a compact data structure is presented using the kerne! nodes. Let n(m) be the number of the total (kernel) nodes. It is theoretically proved that encoding a decimal code is a constant time, that the worst-case time complexity of compressing the decimal codes is O(n+m 2), and that the size of the data structure is proportional to m. From the experimental results of some hierarchical semantic primitives for natural language processing, it is shown that the ratio m/n becomes an extremely small value, ranging from 0.047 to 0.13.

Efficient calculation of the space-time performance of the working set

The performance of working set memory management is often used as a benchmark against which other algorithms are compared. Efficient algorithms which can generate exact performance curves for the mean working set size and fault rate have appeared in the literature. These algorithms exploit the fact that the curve of fault rate or mean resident set size versus the working set parameter value may be computed by gathering various statistics during one pass across the reference string and then by substituting those statistics into relatively simple formulae. This paper develops an efficient technique for the determination of the exact space time product versus parameter value curve. The usual simulation approach to compute a space-time performance curve exhibits worst case time complexity of O( nn 2) where p is the number of pages referenced by the program and n is the total number of memory references generated by the program. The one-pass technique presented here requires O( pn) time. Given that n may be quite large in practice (10 7 references is not unusual), this reduction in complexity is necessary for the practical determination of space-time performance of the working set.

An optimal k-consistency algorithm

This paper generalizes the arc-consistency algorithm of Mohr and Henderson [4] and the path-consistency algorithm of Han and Lee [2] to a k-consistency algorithm (arc-consistency and path-consistency being 2-consistency and 3-consistency, respectively). The algorithm is a development of Freuder's synthesis algorithm [1]. It simultaneously establishes i-consistency for each 1 ⩽ i ⩽ k. It has worst-case time and space complexity which is optimal when k is a constant and almost optimal for all other values of k. In the case that all order-i constraints exist for all 1 ⩽ i ⩽ n, this algorithm is a solution to the consistent labeling problem with almost optimal worst-case time and space complexity.

An efficient distributed protocol for finding shortest paths in networks with negative weights

The design is discussed of distributed algorithms for the single-source shortest-path problem to run on an asynchronous directed network in which some of the edges may be associated with negative weights, and thus in which a cycle of negative total weight may also exist. The only existing solution in the literature for this problem is due to K.M. Chandy and J. Misra (1982), and it has, in the worst case, an unbounded message complexity. A synchronous version of the Chandy-Misra algorithm is described and studied, and it is proved that for a network with m edges and n nodes, the worst case message and time complexities of this algorithm are O(mn) and O(n), respectively. This algorithm is then combined with an efficient synchronizer to yield an asynchronous protocol that retains the same message and time complexities. >

Storing a tree structure by using decimal notation

A decimal notation satisfies many simple mathematical properties, and it is a useful tool in the analysis of trees. A practical method is presented, that compresses the decimal codes while maintaining the fast determination of relations(e.g., ancestor, descendant, brother, etc.). A special node, called a kernel node , including many common subcodes of the other codes, is defined, and a compact data structure is presented using the kernel nodes. Let n ( m ) be the number of the total(kernel) nodes. It is theoretically proved that encoding a decimal code is a constant time, that the worst-case time complexity of compressing the decimal codes is O( n + m 2 ), and that the size of the data structure is proportional to m. From the experimental results of some hierarchical semantic primitives for natural language processing, it is shown that the ratio m/n becomes an extremely small value, ranging from 0.047 to 0.13.

Optimal Algorithms for a Pursuit-Evasion Problem in Grids

This paper discusses a problem of searching for and capturing a fugitive by a team of searchers in an $N \times N \,\text{grid}\,G_N $ representing a system of Navenues and Nstreets which a searcher can “see” a fugitive if and only if both are on the same avenue or the same street. A $0.5N^2 + O(N)$ time algorithm is presented for searching $G_N $ by a team of two searchers in order to decide whether there exists a fugitive in $G_N $. The algorithm is shown to be (1) optimal with respect to the number of searchers required for the case in which the fugitive can move at least as fast as the searchers, and (2) asymptotically optimal with respect to the worst case time complexity. An $O(N^2 )$ time algorithm is also presented for capturing a fugitive in $G_N $ by a team of four searchers. The algorithm is shown to be asymptotically optimal with respect to the worst case time complexity.

All-to-all broadcast by flooding in communications networks

The author establishes the worst-case time complexity of all-to-all broadcast, which involves the simultaneous broadcast of messages from each node in a network to each other node, as with the dissemination of network status information for adaptive routing in ARPANET, by flooding. It it shown to be almost two times the optimum. This suboptimality of flooding results from the selection method permitting some message(s) to be consistently blocked by others. It is possible to avoid such blocking and attain the optimal worst-case time complexity by flooding within a spanning subtree. Simulations examine the performance of all-to-all broadcast by flooding using different selection methods. The best overall performance came using random selection, with FIFO next best, followed by LIFO, and in-order last. This relative performance is consistent with the hypothesis that flooding will generally perform better if implemented with a selection method that tends to avoid having some message(s) consistently blocked by others. Simulations show that the optimal worst-case time complexity is rarely exceeded, and then by only a relatively small amount.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

VLSI architecture for digital picture comparison

The authors propose a VLSI architecture consisting of m*n processing elements with extensive parallel and pipelining computational capabilities. The worst-case time complexity is reduced to O(max(m, n)), which is a significant improvement over the uniprocessor approach. The algorithm partition problem, an important issue in VLSI design, and the verification of the proposed architecture are also studied. A series of experiments conducted to verify the proposed algorithms is described.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

MOD-CHAR: an implementation of Char's spanning tree enumeration algorithm and its complexity analysis

Two complexity analyses of MOD-CHAR are presented. It is shown that MOD-CHAR leads to better complexity results for J.P. Char's algorithm than what could be obtained using the straightforward implementation implied in Char's original presentation (see IEEE Trans. Circuit Theory, Vol.15, p.228-38, 1968). The class of graphs for which MOD-CHAR and, hence, Char's algorithm, has linear time complexity per spanning tree generated is identified. This class is more general than the corresponding one identified in R. Jayakumar et al. (see ibid., vol.31, no.10, p.853-60, 1984). Using a result on random graphs, it is proved that for almost all graphs MOD-CHAR has linear worst-case time complexity per spanning tree generated. It is also shown that for any complete graph MOD-CHAR requires, on the average, at most seven computational steps to generate a spanning tree. This result and computational experiences provide evidence to believe that for dense graphs of any order the time complexity of MOD-CHAR is O(t), where t is the number of spanning trees generated. On the other hand, there is enough evidence to conclude that for sparse graphs, Char's original implementation is superior to MOD-CHAR.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An efficient digital search algorithm by using a double-array structure

An efficient digital search algorithm that is based on an internal array structure called a double array, which combines the fast access of a matrix form with the compactness of a list form, is presented. Each arc of a digital search tree, called a DS-tree, can be computed from the double array in 0(1) time; that is to say, the worst-case time complexity for retrieving a key becomes 0(k) for the length k of that key. The double array is modified to make the size compact while maintaining fast access, and algorithms for retrieval, insertion, and deletion are presented. If the size of the double array is n+cm, where n is the number of nodes of the DS-tree, m is the number of input symbols, and c is a constant particular to each double array, then it is theoretically proved that the worst-case times of deletion and insertion are proportional to cm and cm/sup 2/, respectively, and are independent of n. Experimental results of building the double array incrementally for various sets of keys show that c has an extremely small value, ranging from 0.17 to 1.13. >

A k shortest path algorithm for adaptive routing in communications networks

An efficient and flexible algorithm is presented for finding a k shortest loopless path with distinct initial links from one node to each other node. Low-order polynomial bounds are established for the worst-case time complexity of the algorithm, showing it to offer a substantial improvement over applying known algorithms to the problem. The algorithm can incorporate various extensions, including the ability to handle an algebraic objective, which enhance its applicability to diverse network models. In addition, the k shortest path formulation and algorithm are proposed as a basis for network survivability measures where path length bounds exist.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Maximal chordal subgraphs

An algorithm for finding maximal chordal subgraphs is developed that has worst-case time complexity of O(| E| Δ), where | E| is the number of edges in G and Δ is the maximum vertex degree in G. The study of maximal chordal subgraphs is motivated by their usefulness as computationally efficient structures with which to approximate a general graph. Two examples are given that illustrate potential applications of maximal chordal subgraphs. One provides an alternative formulation to the maximum independent set problem on a graph. The other involves a novel splitting scheme for solving large sparse systems of linear equations.

Minimization of the number of layers for single row routing with fixed street capacity

A set of three algorithms is presented for solving single-row routine problems with a fixed street capacity using the least number of layers. The main difference among these algorithms is in the strategy used to search for an optimal solution, which greatly affects the performance. At the extreme points of the strategy are algorithms Q and S. The worst-case time complexity is linear for algorithm Q and exponential for algorithm S. The best-case time complexity of all the algorithms is linear. The main disadvantage of algorithm Q is that the constant associated with its time complexity bounds is large. On the other hand, the constant associated with the best-case time complexity bound for algorithm S is small. An experimental evaluation of the performance of the algorithms is presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Efficient axis-translation of binary digital pictures by blocks in linear quadtree representation

For binary digital pictures with large all-black fragments, the linear quadtree representation is a space-efficient data structure on which many time-efficient algorithms, such border-determination and filling, have been implemented. Translation—moving the picture bodily in a fixed direction—was originally done by converting each pixel into bit-map form. More recently, a recursive translation-rotation algorithm has appeared which makes better use of the hierarchical nature of the data structure, together with a time-complexity bound expressed in terms of the output. We present a nonrecursive translation algorithm with the same asymptotic worst-case time-complexity bound as the recursive algorithm, but which turns out to execute significantly faster than either of the previous algorithms. We generalize this algorithm to higher dimensional pictures, and we express the time-complexity in terms of the input data.

On the computational complexity of the abelian permutation group structure, membership and intersection problems

Algorithms on computations on abelian permutation groups are presented here. An algorithm for computing the complete structure, algorithms for membership-inclusion testing and an algorithm for computing the intersection of abelian permutation groups are given. Their worst-case time complexity is a polynomial of degree 4 in terms of n, the number of points moved by the group. The upper bounds on the running time of the algorithms shown here improve the bounds on the above problems cited in the literature.

Structure of the submarking-reachability problem and network programming

Using a linear programming formulation, a unified treatment of the submarking-reachability problem for both capacitated and uncapacitated marked graphs is presented. In both cases, the problem reduces to that of testing feasibility of the dual transshipment problem of operations research. An algorithm called REACH is presented for the feasibility testing problem; its worst-case time complexity is O(mn), where m and n are, respectively, the number of edges and the number of nodes in the marked graph. The place of this work in the context of general network programming problems is indicated.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Plane-sweep solves the closest pair problem elegantly

Optimal algorithms for the closest pair problem are often complex because they are derived from algorithms that solve more general problems, such as all-nearest-neighbors or computing the Voronoi diagram. The only known direct algorithm with optimal worst-case time complexity (in the algebraic decision tree model of computation) uses divide-and-conquer and involves a complicated merge step. We show how the two-dimensional closest pair problem is solved elegantly in asymptotically optimal time using a plane-sweep algorithm which is easier to understand and implement. We explain why sweeping generalizes easily, but not efficiently, to multi-dimensional closest pair problems.

Performance analysis of the FFT algorithm on a shared-memory parallel architecture

This paper presents a model for the performance prediction of FFT algorithms executed on a shared-memory parallel computer consisting of N processors an the same number of memory modules. The model applies a deterministic analysis to estimate the communication delay through the interconnection network by assuming that all requests arrive at the network in bursts. Our results indicate that the communication delay is significantly affected by the method applied to allocate data to memory modules. For the case in which all data items referenced by a processor during an iteration are allocated to a single memory module, the best-case communication time complexity grows as O[(log N) 2 /N]. The worst-case communication time complexity for this case, obtained by a different allocation of data to memory modules, is increased to O[(log N)/√N] due to high network contention. For the case in which the data items referenced by different processors during an iteration are allocated to the same memory module, the communication time complexity is further increased to O(log N) since all N requests generated by processors are serialized at a single memory module. The methods developed in this paper can be applied for the performance prediction of other well-structured parallel iterative algorithms.