Showing papers on "Disjoint sets published in 1989"

The cell probe complexity of dynamic data structures

Abstract: Dynamic data structure problems involve the representation of data in memory in such a way as to permit certain types of modifications of the data (updates) and certain types of questions about the data (queries). This paradigm encompasses many fundamental problems in computer science.The purpose of this paper is to prove new lower and upper bounds on the time per operation to implement solutions to some familiar dynamic data structure problems including list representation, subset ranking, partial sums, and the set union problem. The main features of our lower bounds are: They hold in the cell probe model of computation (A. Yao [18]) in which the time complexity of a sequential computation is defined to be the number of words of memory that are accessed. (The number of bits b in a single word of memory is a parameter of the model). All other computations are free. This model is at least as powerful as a random access machine and allows for unusual representation of data, indirect addressing etc. This contrasts with most previous lower bounds which are proved in models (e.g., algebraic, comparison, pointer manipulation) which require restrictions on the way data is represented and manipulated.The lower bound method presented here can be used to derive amortized complexities, worst case per operation complexities, and randomized complexities.The results occasionally provide (nearly tight) tradeoffs between the number R of words of memory that are read per operation, the number W of memory words rewritten per operation and the size b of each word. For the problems considered here there is a parameter n that represents the size of the data set being manipulated and for these problems b = logn is a natural register size to consider. By letting b vary, our results illustrate the effect of register size on time complexity. For instance, one consequence of the results is that for some of the problems considered here, increasing the register size from logn to polylog(n) only reduces the time complexity by a constant factor. On the other hand, decreasing the register size from logn to 1 increases time complexity by a logn factor for one of the problems we consider and only a loglogn factor for some other problems.The first two specific data structure problems for which we obtain bounds are: List Representation. This problem concerns the representation of an ordered list of at most n (not necessarily distinct) elements from the universe U = {1, 2,…, n}. The operations to be supported are report(k), which returns the kth element of the list, insert(k, u) which inserts element u into the list between the elements in positions k - 1 and k, delete(k), which deletes the kth item.Subset Rank. This problem concerns the representation of a subset S of U = {1, 2,…, n}. The operations that must be supported are the updates “insert item j into the set” and “delete item j from the set” and the queries rank(j), which returns the number of elements in S that are less than or equal to j.The natural word size for these problems is b = logn, which allows an item of U or an index into the list to be stored in one register. One simple solution to the list representation problem is to maintain a vector v, whose kth entry contains the kth item of the list. The report operation can be done in constant time, but the insert and delete operations may take time linear in the length of the list. Alternatively, one could store the items of the list with each element having a pointer to its predecessor and successor in the list. This allows for constant time updates (given a pointer to the appropriate location), but requires linear cost for queries.This problem can be solved must more efficiently by use of balanced trees (such as AVL trees). When b = logn, the worst case cost per operation using AVL trees is O(logn). If instead b = 1, so that each bit access costs 1, then the AVL three solution requires O(log2n) per operation.It is not hard to find similar upper bounds for the subset rank problem (the algorithms for this problem are actually simpler than AVL trees).The question is: are these upper bounds bet possible? Our results show that the upper bounds for the case of logn bit registers are within a loglogn factor of optimal. On the other hand, somewhat surprisingly, for the case of single bit registers there are implementations for both of these problems that run in time significantly faster than O(log2n) per operation.Let CPROBE(b) denote the cell probe computational model with register size b.Theorem 1. If b ≤ (logn)t for some t, then any CPROBE(b) implementation of either list representation or the subset rank requires O(logn/loglogn) amortized time per operation.Theorem 2. Subset rank and list representation have CPROBE(1) implementations with respective complexities O((logn)(loglogn)) and O((logn)(loglogn)2) per operation.Paul Dietz (personal communication) has found an implementation of list representation with logn bit registers that requires only O(logn/loglogn) time per operation, and thus the result of theorem 1 is best possible.The lower bounds of theorem 1 are derived from lower bounds for a third problem: Partial sum mode k. An array A[1],…, A[N] of integers mod k is to be represented. Updates are add(i, d) which implements A[i] ← A[i] + d; and queries are sum(j) which returns Si≤jA[i] (mod k).This problem is demoted PS(n, k). Our main lower bound theorems provide tradeoffs between the number of register rewrites and register reads as a function of n, k, and b. Two corollaries of these results are: Theorem 3. Any CPROBE(b) implementation of PS(n, 2) (partial sums mod 2) requires O(logn/(loglogn + logb)) amortized time per operation, and for b ≥ logn, there is an implementation that achieves this. In particular, if b = T((logn)c) for some constant c, then the optimal time complexity of PS(n, 2) is t(logn/loglogn).Theorem 4. Any CPROBE(1) implementation of PS(n, n) with single bit registers requires O((logn/loglogn)2) amortized time per operation, and there is an implementation that achieves O(log2n) time per operation.It can be shown that a lower bound of PS(n, 2) is also a lower bound for both list representation and subset rank (the details, which are not difficult, are omitted from this report), and thus theorem 1 follows from theorem 3. The results of theorem 4 make an interesting contrast with those of theorem 2. For the three problems, list representation, subset rank and PS(n, k), there are standard algorithms that can be implemented on a CPROBE(logn) that use time O(logn per operation, and their implementations on CPROBE(1) require O(log2n) time. Theorem 4 says that for the problem PS(n, n) this algorithm is essentially best possible, while theorem 2 says that for list representation and rank, the algorithm can be significantly improved. In fact, the rank problem an be viewed as a special case of PS(n, n) where the variables take on values on {0, 1}, and apparently this specialization is enough to reduce the complexity on a CPROBE(1) by a factor of logn/loglogn, even though on a CPROBE(logn) the complexities of the two problems differ by no more than a loglogn factor.The third problem we consider is the set union problem. This problem concerns the design of a data structure for the on-line manipulation of sets in the following setting. Initially, there are n singleton sets {1}, {2},…, {n} with i chosen as the name of the set {i}. Our data structure is required to implement two operations, Find(j), and Union(A, B, C). The operation Find(j) returns the name of the set containing j. The operation Union(A, B, C) combines the sets with names A and B. The names of the existing sets at any moment must be unique and chosen to be integers in the range from 1 to 2n. The sets existing at any time are disjoint and define a partition of the elements into equivalence classes.A well known data structure for the set union problem represents the sets as trees and stores the name of a set in the root of its corresponding tree. A Union operation is performed by attaching the root of the smaller set as a child of the root of the larger set (weight rule). A Find operation is implemented by following the path from the appropriate node to the root of the tree containing it, and then redirecting to the root the parent pointers of the nodes encountered along this path (path compression). From now on we consider sequences of Union and Find operations consisting of n-1 Union operations and m Find operations with m ≥ n. Tarjan [14] demonstrated that the above algorithm requires time t(ma(m, n)), where a(m, n) is an inverse to Ackermann's function, to execute n-1 Union and m Find operations. In particular, if m = t(n), then the running time is almost, but not quite, linear. Tarjan conjectured [14] that no linear time algorithm exists for the set union problem, and provided significant evidence in favor of this conjecture (which we discuss in the following section). We affirm Tarjan's conjecture in the CPROBE(logn) model.Theorem 5. Any CPROBE(logn) implementation of the set union problem requires O(ma(m, n)) time to execute m Find's and n-1 Union's, beginning with n singleton sets.N. Blum [2] has given a logn/loglogn algorithm (worst case time per operation) for the set union problem. This algorithm is also optimal in the CPROBE(polylogn) model.The following Section provides further discussion of these results, Section 3 outlines our lower bound method, and Section 4 contains some proofs.

On the size of systems of sets every t of which have an SDR, with an application to the worst-case ratio of heuristics for packing problems

Abstract: Let $E_1 ,\cdots,E_m $ be subsets of a set V of size n, such that each element of V is in at most k of the $E_i $ and such that each collection of t sets from $E_1 ,\cdots ,E_m $ has a system of distinct representatives (SDR). It is shown that $m/n\leqq (k(k - 1)^r - k)/(2(k - 1)^r - k)$ if $t = 2r - 1$, and $m/n \leqq (k(k - 1)^r - 2)/(2(k - 1)^r - 2)$ if $t = 2r$. Moreover it is shown that these upper bounds are the best possible. From these results the “worst-case ratio” of certain heuristics for the problem of finding a maximum collection of pairwise disjoint sets among a given collection of sets of size k is derived.

On the inverse kinematics of redundant manipulators: characterization of the self-motion manifolds

Abstract: The author takes a global rather than instantaneous look at the inverse kinematics of redundant manipulators. This approach is based on a manifold mapping reformulation of manipulator kinematics. While the kinematic problem has an infinite number of solutions for redundant manipulators, the infinity of solutions can be grouped into a finite and bounded set of disjoint continuous manifolds. Each of these manifolds, termed self-motion manifolds, physically corresponds to a distinct self-motion of the manipulator, and the number, geometry, and characterizations of the self-motion manifolds are investigated. >

Random Tessellations in Rd

Abstract: This paper presents a general theory of random tessellations (i.e. stochastic aggregates of disjoint and space-filling cells) in d-dimensional Euclidean space. Some particular models of random tessellations are discussed in detail.

Three tree‐paths

Abstract: Itai and Rodeh [3] have proved that for any 2-connected graph G and any vertex s ∈ G there are two spanning trees such that the paths from any other vertex to s on the trees are disjoint. In this paper the result is generalized to 3-connected graphs.

Smaller sums of disjoint products by subproduct inversion

Abstract: A new method is presented for calculating system reliability by sum of disjoint products. While the Abraham algorithm (1979) and its successors invert single variables, this new method applies inversion also to products of several variables. This results in shorter computation time and appreciably fewer disjoint products. Hence, the system reliability formula is considerably reduced in size. The Abraham algorithm, for instance, produces 71 disjoint products for network of 12 components and 24 minipaths, while this new method produces only 41 disjoint terms. This facilitates the numerical evaluation of the system reliability formula by reducing computation and rounding errors. Computer programs for both algorithms are included. They were written in Pascal and run on a microcomputer. >

Global Optimization of Univariate Lipschitz Functions: II. New Algorithms and Computational Comparison

Abstract: We consider the following global optimization problems for a Lipschitz functionf implicitly defined on an interval [a, b] Problem P′: find a globallye-optimal value off and a corresponding point; Problem Q″: find a set of disjoint subintervals of [a, b] containing only points with a globallye-optimal value and the union of which contains all globally optimal points A two-phase algorithm is proposed for Problem P′ In phase I, this algorithm obtains rapidly a solution which is often globallye-optimal Moreover, a sufficient condition onf for this to be the case is given In phase II, the algorithm proves thee-optimality of the solution obtained in phase I or finds a sequence of points of increasing value containing one with a globallye-optimal value The new algorithm is empirically compared (on twenty problems from the literature) with a best possible algorithm (for which the optimal value is assumed to be known), with a passive algorithm and with the algorithms of Evtushenko, Galperin, Shen and Zhu, Piyavskii, Timonov and Schoen For smalle, the new algorithm requires only a few percent more function evaluations than the best possible one An extended version of Piyavskii's algorithm is proposed for problem Q″ A sufficient condition onf is given for the globally optimal points to be in one-to-one correspondance with the obtained intervals This result is achieved for all twenty test problems

Design automation tools for efficient implementation of logic functions by decomposition

Abstract: A description is given of linear and disjoint decompositions of completely specified Boolean functions using transform methods. Since previously known transform methods are impractical for automation due to their enormous computational complexity, polynomial approximations to the linear decomposition procedure that use reduced representations of functions are used. Experimental results are reported which establish that such decompositions can often result in improved implementations of logic functions. The disjoint decomposition problem is in the spectral domain, allowing the development of an algorithm that can simultaneously detect multiple decompositions of a given function. This algorithm has low average complexity and has the ability to detect the nonexistence of decompositions quickly. >

Global Optimization of Univariate Lipschitz Functions: I. Survey and Properties

Abstract: We consider the following global optimization problems for a univariate Lipschitz functionf defined on an interval [a, b]: Problem P: find a globally optimal value off and a corresponding point; Problem Pź: find a globallyź-optimal value off and a corresponding point; Problem Q: localize all globally optimal points; Problem Qź: find a set of disjoint subintervals of small length whose union contains all globally optimal points; Problem Qź: find a set of disjoint subintervals containing only points with a globallyź-optimal value and whose union contains all globally optimal points. We present necessary conditions onf for finite convergence in Problem P and Problem Q, recall the concepts necessary for a worst-case and an empirical study of algorithms (i.e., those ofpassive and ofbest possible algorithms), summarize and discuss algorithms of Evtushenko, Piyavskii-Shubert, Timonov, Schoen, Galperin, Shen and Zhu, presenting them in a simplified and uniform way, in a high-level computer language. We address in particular the problems of using an approximation for the Lipschitz constant, reducing as much as possible the expected length of the region of indeterminacy which contains all globally optimal points and avoiding remaining subintervals without points with a globallyź-optimal value. New algorithms for Problems Pź and Qź and an extensive computational comparison of algorithms are presented in a companion paper.

On monotone paths among obstacles with applications to planning assemblies

Abstract: We study the class of problems associated with the detection and computation of monotone paths among a set of disjoint obstacles. We give an O(nE) algorithm for finding a monotone path (if one exists) between two points in the plane in the presence of polygonal obstacles. (Here, E is the size of the visibility graph defined by the n vertices of the obstacles.) If all of the obstacles are convex, we prove that there always exists a monotone path between any two points s and t. We give an O(n log n) algorithm for finding such a path for any s and t, after an initial O(E + n log n) preprocesing. We introduce the notions of “monotone path map”, and “shortest monotone path map” and give algorithms to compute them. We apply our results to a class of separation and assembly problems, yielding polynomial-time algorithms for planning an assembly sequence (based on separations by single translations) of arbitrary polygonal parts in two dimensions.

Termination for the Direct Sum of left-Linear Term Rewriting Systems -Preliminary Draft-

Abstract: The direct sum of two term rewriting systems is the union of systems having disjoint sets of function symbols. It is shown that two term rewriting systems both are left-linear and complete if and only if the direct sum of these systems is so.

Proof of Gru¨nbaum's conjecture on common transversals for translates

Abstract: In 1958 B. Grunbaum made a conjecture concerning families of disjoint translates of a compact convex set in the plane: if such a family consists of at least five sets, and if any five of these sets are met by a common line, then some line meets all sets of the family. This paper gives a proof of the conjecture.

Color image display with a limited palette size

Abstract: A method for creating from a digitized color image, a tree structured partitioning of all pixels in the image into M disjoint sets, with the pixels in each set having similar color values, the method comprising the steps of: separating and assigning all pixels in the image into disjoint sets so as to minimize the difference between the respective pixel color values in each set; selecting one of the sets which has a greatest variation of color values of assigned pixels, and separating and assigning all pixels in the selected set into new, disjoint sets, with the pixels assigned so as to minimize the differences between their respective color values; continuing the selecting, separating and assigning steps for sets until a total of M sets have been derived; and then assigning to all pixels in each set, a mean color value calculated from all pixel colors in the set.

Constructing disjoint paths on expander graphs

Abstract: In a typical parallel or distributed computation model processors are connected by a spars interconnection network. To establish open-line communication between pairs of processors that wish to communicate interactively, a set of disjoint paths has to be constructed on the network. Since communication needs vary in time, paths have to be dynamically constructed and destroyed. We study the complexity of constructing disjoint paths between given pairs of vertices on expander interconnection graphs. These graphs have been shown before to possess desirable properties for other communication tasks. We present a sufficient condition for the existence ofK≦n Q edge-disjoint paths connecting any set ofK pairs of vertices on an expander graph, wheren is the number of vertices andϱ<1 is some constant. We then show that the computational problem of constructing these paths lies in the classes Deterministic-P and Random-P C. Furthermore, we show that the set of paths can be constructed in probabilistic polylog time in the parallel-distributed model of computation, in which then participating processors reside in the nodes of the communication graph and all communication is done through edges of the graph. Thus, the disjoint paths are constructed in the very computation model that uses them. Finally, we show how to apply variants of our parallel algorithms to find sets ofvertex-disjoint paths when certain conditions are satisfied.

Covering Complete Graphs by Monochromatic Paths

Abstract: A theorem of R. Rado (see in [2]) says that if the edges of the countably infinite complete graph K ∞ are colored with r colors then the vertices of K ∞ can be covered by at most r (finite or one-way infinite) vertex-disjoint monochromatic paths. Edge-coloring theorems are usually extended from finite to infinite, however, in the case of Rado’s theorem it seems natural to look for finite versions.

Oracles for structural properties: the isomorphism problem and public-key cryptography

Abstract: There exists an oracle, relative to which P not= NP and each of the following properties hold: (i) all Sigma /sup p//sub 2/-complete sets are p-isomorphic; (ii) P-inseparable pairs of sets in NP do not exist; (iii) intractable public-key cryptosystems do not exist; and (iv) NP-complete sets are closed under union of disjoint sets. Remarkably, these properties all follow from one oracle construction, namely, it is proved that there is an oracle A such that every two disjoint sets in NP/sup A/ are P-separable, and Sigma /sup P//sub 2/= union (DTIME(2/sup p/) mod p is a polynomial). Additional related relativization results are presented. >

A computational mechanism for pronominal reference

Abstract: This paper describes an implemented mechanism for handling bound anaphora, disjoint reference, and pronominal reference. The algorith maps over every node in a parse tree in a left-to-right, depth first manner. Forward and backwards coreference, and disjoint reference are assigned during this tree walk. A semantic interpretation procedure is used to deal with multiple antecedents.

A distributed algorithm for finding shortest pairs of disjoint paths

Abstract: A distributed asynchronous algorithm is presented for finding two disjoint paths of minimum total length from each possible source node to a destination. The algorithm has both node-disjoint and link-disjoint versions, and provides each node with information sufficient to make incremental routing decisions for forwarding packets over the disjoint paths. For a network in which all links have unit length, it is shown that a synchronous implementation of the algorithm has communication and time complexities O( mod E mod +D mod N mod ) and O(D/sub 2/), respectively, where D is the networks diameter and D/sub 2/ is the maximum, over all nodes i, of the total number of links in the shortest pair of disjoint paths from i to the destination. >

Disjoint simplices and geometric hypergraphs

Abstract: Let A be a set of 2n points in general position in the Euclidean plane R2, and suppose n of the points are colored red and the remaining n are colored blue. A celebrated Putnam problem (see [6] ) asserts that there are n pairwise disjoint straight line segments matching the red points to the blue points. To show this, consider the set of all n! possible matchings and choose one, M , that minimizes the sum of lengths I(M) of its line segments. It is easy to show that these line segments cannot intersect. Indeed, if the two segments v, , b , and v2 , b, intersect, where v, , v2 are two red points and b,, b, are two blue points, the matching M' obtained from M by replacing q b , and v ,b , by v,b2 and u2 b, satisfies I(M') < I(M), contradicting the choice of M . Our first result in this paper is a generalization of this result to higher dimensions.

Disjoint edges in geometric graphs

Abstract: Answering an old question in combinatorial geometry, we show that any configuration consisting of a setV ofn points in general position in the plane and a set of 6n ? 5 closed straight line segments whose endpoints lie inV, contains three pairwise disjoint line segments.

Efficient parallel algorithms for testing connectivity and finding disjoint s-t paths in graphs

Abstract: An efficient parallel algorithm for testing whether a graph G is K-vertex connected, for any fixed k, is presented. The algorithm runs in O(log n) time and uses nC(n,m) processors on a concurrent-read, concurrent-write parallel random-access machine (CRCW PRAM), where n and m are the number of vertices and edges of G and C(n,m) is the number of processors required to compute the connected components of G in logarithmic time. An optimal speedup algorithm for computing connected components would induce an optimal speedup algorithm for testing k-vertex connectivity, for any k>4. To develop the algorithm, an efficient parallel algorithm is designed for the following disjoint s-t paths problem: Given a graph G and two specified vertices s and t, find k-vertex disjoint paths between s and t, if they exist. If no such paths exist, find a set of at most k-1 vertices whose removal disconnects s and t. The parallel algorithm for this problem runs in O(log n) time using C(n,m) processors. It is shown how to modify the algorithm to find k-edge disjoint paths, if they exist. This yields an efficient parallel algorithm for testing whether a graph G is k-edge connected, for any fixed k. The algorithm runs in O(log n) time and uses nC (n,n) processors on a CRCW PRAM. Again, an optimal speedup algorithm for computing connected components would induce an optimal speedup algorithm for testing k-edge connectivity. >

Banach lattices with the subsequence splitting property

Abstract: A Banach lattice X has SSP if every bounded sequence in X has a subsequence that splits into a A'-equi-integrable sequence and a sequence with pairwise disjoint support. We characterize such lattices in terms of uniform order continuity conditions and ultrapowers. This implies that rearrangement invariant function spaces with the Fatou-property have SSP.

Lines in space-combinators, algorithms and applications

Abstract: We study combinatorial and algorithmic problems involving arrangements of n lines in 3-dimensional space, and then present applications of our results to a variety of problems on polyhedral terrains. Our main results include: A tight T(n2) bound on the complexity of the space of all lines passing above all the n given lines (their “upper envelope”) and satisfying a certain orientation consistency constraint.A preprocessing procedure using near-quadratic time and storage that builds a structure supporting O(log n) time queries for testing if a line lies above all the given lines.An O(n4/3+e) randomized expected time algorithm, for any fixed e > 0, that tests the “towering property”: do n given red lines lie all above n given blue lines?A preprocessing procedure for a polyhedral terrain S with n edges, that uses near-quadratic time and storage and builds a structure supporting O(log2n) time rayshooting queries for computing the first intersection of an arbitrary query ray with S.Finding the smallest vertical distance between two disjoint polyhedral terrains with a total of n edges, in time O(n4/3+e), for any e > 0.Computing the upper envelope (pointwise maximum) of two polyhedral terrains with a total of n edges, in time O(n1.5+e + klog2n), for any e > 0, where k is the size of the output envelope.The tools used to obtain these results include Plucker coordinates for lines in space, random sampling in geometric problems, and a new variant of segment trees.