D.B. Johnson. \A priority queue in which initialization and queue operations take #(log log #) time", ############ #### #### ###### 15, pp. 295-309, 1982.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....query time. We conclude: 6 Theorem 4.1 Let V be a set of keels in U. There ezists a dlnamic structure for storing V, requiring O(U) storage such that insertions, deletions and neighbor queries take time O(loglog U) A number of improvements over the vanEmdeBoas tree have been suggested. Iohnson[7] describes a modification to reduce the initialisation time and to per form some queue operations more efficiently. Willard[26] and Karlsson[8] describe dynamic structures on a grid that use only O(n) storage. To obtain this lower space requirement, the update and query time of their methods is ....

Johnson, D.B., A priority queue in which initialization and queue operations take O(loglog D) time, Math. $//stems Theory 15 (1982), 295-310.

....[0. u 1] using O(u) space so that in time O(loglog u) keys can be inserted, deleted and the key nearest to a specified key in U can be found. A drawback of this structure is its O(u) preprocessing. Instead, we will use a more flexible tree structure introduced by Johnson. Theorem 2. 1: Johnson [6]) Given a set of n keys from U = 0. u 1] there exists a structure using O(u) storage such that in time O(logiog u) it can be initialized and keys can be inserted, deleted and the key nearest to a given value in U can be determined. We will call this structure a Johnson tree. It can also be ....

D.B. Johnson, A Priority Queue in which Initialization and Queue Operations Take O(loglog D) Time, Math. Systems Theory 15, 4 (1982), 295-310

....computation can be performed on a pointer machine. Furthermore, for the first haft of this paper, we require that the rectangle corners and query points lie in a fixed size integer grid [1, U] d. Stratified trees, a data structure introduced by van Erode Boas [16] and extended by him and others [9, 13, 18, 19], exploit the power of a RAM on a fixed universe. They have been used for log logarithmic time queries in onedimensional point location, more commonly known as searching a list for the successor of a query point. M dller [14] used a type of stratified tree as a two dimensional point location ....

D. Johnson. A priority queue in which initialization and queue operations take O(loglog D) time. Math. S.lstems Theortj, 15:295-309, 1982.

....are amortized and randomized,i.e. the averaging involved in the analysis is over choices made by the algorithm and not over the input sequence. q.e.d. This result extends and unifies the work of v. Emde Boas et al. v. Emde Boas, D. Johnson, R. Karlsson, and D. Willard. In [E77] EKZ77] and [J82] it is shown that the time bounds can be achieved using O(N) space and that a space bound O(N ffl ) can be achieved at the cost of multiplying the time bounds by 1=ffl for any ffl 0. In [W83] the space bound O(jdom Dj) is achieved for static dictionaries, and in [K84] W84] the space O(jdom ....

D. Johnson: "A Priority Queue in which Initialization and Queue Operations Take Time O(log log D) time", Math. System Theory 15, 295-309, 1982

....they proposed an O(S(n; m) time algorithm for MSP . Since the best available value for S(n; m) at the time was O(m log 1 m=n n) Tarjan and Suurballe quoted this expression for time bound. Currently, the best available value for S(n; m) is O(minfm n log n; m log log C; m q n log Cg) FT 84, John 82, AMOT 90] where C represents the largest edge cost in G. Hence, following Tarjan and Suuraballe s method a solution for MSP can be found within the same time bound. The problem of nding all pairs of shortest paths in a directed graph with non negative edge weights can be solved in O(log 2 n) ....

D.B.Johnson, A priority queue in which initialization and queue operations take O(log log D) time, Mathematical Systems Theory , 15(1982), pp 295-309.

....only on the symbol correspondences induced by the substrings. This problem arises in an application to analysis of software systems. Our algorithm solves the problem in O(jM j log jM j) time using balanced trees, or O(jM j log log min(jM j; nm=jM j) time using Johnson s version of Flat Trees [10]. These bounds apply for two cost measures. The algorithm can also be adapted to finding the usual LCS in O( m n) log j Sigma j jM j log jM j) using balanced trees or O( m n) log j Sigma j jM j log log min(jM j; nm=jM j) using Johnson s Flat Trees, where M is the set of maximal ....

....(of any length) of a fragment. Extension of this cost measure to deal with the full fledged application is discussed in Section 5. For both cost measures, LCS from Fragments can be computed in O(jM j log jM j) time. With sophisticated data structures, such as Johnson s version of Flat Trees [10], that bound reduces to O(jM j log log min(jM j; nm=jM j) The algorithm for the second cost measure is more complex than that for the Levenshtein cost measure. If the set M consists of all pairs of maximal equal substrings of X and Y , and the Levenshtein cost measure is used, the solution of ....

[Article contains additional citation context not shown here]

D. B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Math. Sys. Th., 15:295--309, 1982.

....the total space required by our data structure is O(m) 2 When the graph is planar, and insertions of new edges leave it planar, we can achieve a better bound. First, when G is planar, e G is planar itself and therefore has only O( m k ) edges. Second, we use Johnson s stratified trees [12] instead of balanced search trees to represent the sets E(C i ; C j ) The bound given in Lemma 8 improves now to O(log log k) The initialization of a Johnson s stratified tree containing O(k) items can be still accomplished in O(k) time [13] which implies that the time required to initialize ....

D. B. Johnson, "A priority queue in which initialization and queue operations take O(log log D) time", Math. Syst. Th. 15 (1982), 295--309.

....a constant. If the cost function is simple, the time for a homogeneous sequence of k operations can be reduced to O(k log log n k) We first consider the simple case. In the data structure of the previous section, in place of the flat trees of van Emde Boas, we use Johnson s improved flat trees [31]. This is again a structure in which one can insert, delete, and search for points numbered from 0 to n. However, whereas flat trees take time O(log log n) per operation, improved flat trees take time O(log log G) where G is the length of the gap between points in the structure containing the ....

.... d # row (x) column(x ) if x # A then G [d ] # min(G [d ] D [x ] else E [x ] # min(E [x ] F [d ] end; RecurseRow(C ) end; end Recall that we can implement the data structure of chapter 5 to use, in place of the flat trees of van Emde Boas, we use Johnson s improved flat trees [31]. With such an implementation, a sequence of k operations, all of one type (insertions, deletions, or searches) can be performed in total time O(k log n k) If the cost function is simple, this time can be further reduced to O(k log log n k) Theorem 10. The RNA structure computation of ....

Donald B. Johnson, A Priority Queue in Which Initialization and Queue Operations Take O(log log D) Time, Math. Sys. Th. 15, 1982, pp. 295--309.

....bound nonlinear. This term comes from two parts of our method, Dijkstra s shortest path algorithm and the construction of P(G) from the tree of shortest paths. But for certain graphs, or with certain assumptions about edge lengths, shortest paths can be computed more quickly than O(m n log n) [2, 28,33, 36], and in these cases we would like to speed up our construction of P(G) to match these improvements. In other cases, k may be large and the k log k term may dominate the time bound; again we would like to improve this nonlinear term. In this section we show how to reduce the time for our algorithm ....

D. B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Mathematical Systems Theory 15:295--309, 1982.

....case. The extension to higher dimensions is straightforward. The one dimensional space subdivision technique called stratified tree was proposed by van Emde Boas [20] It supports nearest neighbor query in the integer interval [u] in O(log log u) time. The data structure can be made dynamic (cf. [12]) Each addition or deletion of a point takes O(log log u) time. The tree requires O(n) space, where n denotes the maximum number of points present in the tree at any time 4 . It is assumed that standard boolean and arithmetic operations on words of size log u can be performed in constant time; ....

....of a given query point. Below we give the description of the construct (together with the description of the data structure per se) and search procedures. The add and delete (nontrivial) procedures are essentially the same as in the one dimensional case, and the reader is therefore referred to [12] for details. In the rest of this section we first define the data structure and discuss the algorithm in general, including intuition behind this construction. Then we proceed with its correctness and complexity analysis. The MDST data consists on three recursively coupled components, denoted D, ....

Johnson, D. B. A priority queue in which initialization and queue operations take O(log(log(D)) time. Mathematical Systems Theory 15 (1982), 295--309. 30

.... hoc variants of finger trees supporting the same performance (Apostolico and Guerra [1987] A bound O(m log n d log(2mn=d) was also claimed by Hsu and Du [1984] for one of their constructions, but the claim turned out to be flawed (Apostolico [1987] Eppstein et al. 1990] observed that using Johnson s [1982] variant of the flat trees of van Emde Boas [1975] would reduce the log factor to log log. Before leaving this section, it is useful to mention also some other approaches to the LCS problem. One notable line of research concentrated on cases where the length of an LCS is expected to be close to ....

Johnson, D. B. [1982]. "A priority queue in which initialization and queue operations take O(log log D) time," Math. Systems Theory 15, 295-309.

....weakly and strongly polynomial versions where applicable. SP is the time to solve a shortest path problem with non negative costs, MF is the time to solve a max flow problem, and AP is the time to solve an assignment problem. The best current bounds on SP are O(m n log n) 9] O(m log log C) [22], and O(m n p log C) 1] The best current bounds on MF are O(mn log(n 2 =m) 14] O(nm log m=n log n n) 25] O(mn log m=n n n 2 log 2 n) for any constant 0 [35] O(nm log(2 n p log U=m) 2] and O(minfn 2=3 ; p mgm log(n 2 =m) log U) 13] The best current bounds on AP ....

D. B. Johnson, "A priority queue in which initialization and queue operations take O(log log D) time," Mathematical Systems Theory 14 (1982) 295--309. 5

....[53] developed a linear time algorithm for the problem; his algorithm performs bit manipulations on the input numbers. We let SP(m, n, C) be the complexity assuming the lengths are integers between 0 and C. Currently, the best known bounds for SP(m, n, C)areO(m log log C)andO(m n # log C) due to [34], and [2] respectively. 15 If negative length arcs are allowed (but no negative length cycles) then the best strongly polynomial complexity bound is O(mn) due to Bellman [5] and Ford [16] The best weakly polynomial bound is O(m # n log C) due to [ 2.2.2 Minimum Mean Cycle Problem In the ....

D. B. Johnson. A priority queue in which initialization and queue operations take O(log log d)time.Mathematical Systems Theory, 14:295--309, 1982.

....take integer values in a finite range. A recursive algorithm was proposed in [14, 64, 69] for implementing add and delete operations in such a priority queue with O(log log V ) time complexity, where V is the number of elements in the queue. These algorithms were further refined by Johnson [49] who presented a non recursive algorithm with O(log log D) complexity for the add and delete operations. In this algorithm D denotes the smallest interval between successive elements in the priority queue. Applying this algorithm to Frame based Fair Queueing results in a complexity of O(log log F ....

D. Johnson, "A priority queue in which initialization and queue operations take o(log log d) time," Mathematical Systems Theory, vol. 15, pp. 295--309, 1982.

.... this efficiently, we need to use a priority queue with the following operations: Insert, Delete, and Successor (i.e. given some value i in the priority queue, determine j, the next larger value that is currently in the priority queue) The integer priority queue originally 6 due to van Emde Boas [VKZ77, Joh82] has just the properties we need. Each site can be assigned one of the integers 1 through n based on its order when sorted by x coordinate (i.e. the data point with least x coordinate is 1, the one with next smallest x coordinate is 2, etc. These integer values can be used in an integer ....

D. B. Johnson, A Priority Queue in Which Initialization and Queue Operations Take O(log log D) Time, Mathematical Systems Theory, 15 (1982), 295--309.

....The reader is referred to [12] for further details on the algorithm. When the function w is linear, we can compute recurrences 10 and 11 in time O(n m M log log min(M,nm M ) This algorithm is based on the use of e#cient data structures for the management of priority queues with integer keys [27]. As a by product, we also obtain an improved implementation of the algorithm for the longest common subsequence devised by Apostolico and Guerra [5] Our implementation runs in time O(n log s d log log min(d, nm d) Here s is the minimum between m and the cardinality of the alphabet and d ....

Donald B. Johnson, A Priority Queue in Which Initialization and Queue Operations Take O(log log D) Time, Math. Sys. Th. 15, 1982, pp. 295--309.

....this heap. Each resulting path corresponds to a path from s to v in G. 6 Improved Space and Time The only non optimal part of our time bound is the O(n log n) term. For certain graphs, or with certain assumptions about edge lengths, shortest paths can be computed more quickly than O(m n log n) [2, 16, 19, 22]. However the O(n log n) term in the bounds above comes both from a singlesource shortest path computation, and from a sequence of heap operations performed in our algorithm. In this section we show how to reduce the part of the time bound coming from the heap operations. As a consequence we can ....

D. B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Mathematical Systems Theory, 15:295-- 309, 1982. 20

....neighbor of a given point. Below we give the description of construct (together with the description of the data structure per se) and search. The (nontrivial) implementation of the add and delete are essentially the same as in the one dimensional case, therefore the reader is referred to [16] for details. The first procedure, construct, takes as an input a set of points P from the universe [v] 2 . As the procedure is used recursively, v does not have to be equal to u (but is its divisor) Therefore, the universe [v] 2 does not in general coincide with [u] 2 ; rather than that, ....

Johnson, D. B. A priority queue in which initialization and queue operations take O(log(log(D)) time. Mathematical Systems Theory 15 (1982), 295--309.

....of Fredman, Koml os and Szemer edi [7] Furthermore, for the first half of this paper, we require that the rectangle corners and query points lie in a fixed size integer grid [0; U Gamma 1] d . Stratified trees, a data structure introduced by van Emde Boas [19] and extended by him and others [10, 14, 21, 22], exploit the power of a RAM on a fixed universe. They have been used for log logarithmic time queries in one dimensional point location, more commonly known as searching a list for the successor of a query point. Muller [15] used a type of stratified tree as a twodimensional point location ....

D. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Math. Systems Theory, 15:295--309, 1982.

....bound nonlinear. This term comes from two parts of our method, Dijkstra s shortest path algorithm and the construction of P (G) from the tree of shortest paths. But for certain graphs, or with certain assumptions about edge lengths, shortest paths can be computed more quickly than O(m n log n) [2, 28, 33, 36], and in these cases we would like to speed up our construction of P (G) to match these improvements. In other cases, k may be large and the k log k term may dominate the time bound; again we would like to improve this nonlinear term. In this section we show how to reduce the time for our ....

<F3.774e+05> D. B.<F3.828e+05> Johnson,<F4.018e+05> A priority queue in which initialization and queue operations take<F3.572e+05><F3.828e+05> O(log log<F3.572e+05><F3.828e+05> D)<F4.018e+05><F3.828e+05> time, Math. Systems Theory, 15 (1982), pp. 295--309.

....linear overall work, since it suffices to visit each subtree once. We conclude by pointing out that all log factors apperaring in our claims can be reduced to log log at the expense of some additional bookkeeping, by deploying data structures especially suited for storing integers in a known range [6]. It is also likely that the log n factors could be made to disappear entirely by resort to amortized finger searches such as, e.g. in [2] ....

D.B. Johnson, A Priority Queue in which Initialization and Queue Operations Take O(log log n) Time, Math. Sys. Th., 15, 295-309 (1982).

.... : 0 for i 0 or j 0 max 8 : MNCM c (i Gamma 1; j) MNCM c (i; j Gamma 1) MNCM c (i Gamma 1; j Gamma 1) w(i; j) cut(i; j) otherwise (1) In the case of sparse graphs, the O(m log n) time (or O(m log log n) time using integer priority queue operations of [14]) algorithm for MNCM [13] extends trivially to the MNCM c problem. Nested Maximum Crossing problem. Consider a pair (i; j) where 0 i n 0 , 0 j n 1 . We say the crossing between e 1 ; e 2 is dominated by (i; j) if e 1 and e 2 cross properly and both of them are dominated by (i; j) The ....

D.B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Math. Systems Theory, 15:295--309, 1982.

....make about the (h; w) SCA relates to its time complexity. It is easy to see that each step inside the two loops can be executed in constant time, except for the step marked ( which can be accomplished in O(log n) time because R is a sorted array of size O(n) With the priority queue of Johnson [12], step ( can be performed in O(log log n) time. Johnson s priority queue allows for initialization, insertion, and deletion in O(log log n) time if the input is from a small restricted domain of natural numbers (in this case [0: 2n] Clearly, the time complexity of (h; w) SCA depends on the ....

D. B. Johnson, A priority queue in which initialization and queue operations take O(log log D) time, Mathematical Systems Theory, 15 (1982), pp. 295--309.

....queues for arbitrary integers. In this section we complete the proof of Theorem 1.1. To get from arbitrary integers to short integers we will use a recursive range reduction which can be seen as a simple specialized variant of van Emde Boas data structure [24,25] inspired by the developments in [5,16,17,19]. Let T (n; b) be the time for insert and extract min in a priority queue with up to n b bit integers. We assume that b but not n is known in advance. By Theorem 2.1, T (n; w= logn) O(log log n) We will show that T (n; b) O(1) T (n; b=2) 2.1) Here b is assumed to be a power of 2. For ....

D.B. Johnson, A priority queue in which initialization and queue operations take O(log log D) time, Math. Syst. Th. 15, 4 (1982), 295--309.

....take integer values in a finite range. A recursive algorithm was proposed in [18, 19, 20] for implementing add and delete operations in such a priority queue with O(log log V ) time complexity, where V is the number of elements in the queue. These algorithms were further refined by Johnson [21] who presented a non recursive algorithm with O(log log D) complexity for the add and delete operations. In this algorithm D denotes the smallest interval between successive elements in the priority queue. Applying this algorithm to Frame based Fair Queueing results in a complexity of O(log log F ....

D. Johnson, "A priority queue in which initialization and queue operations take O(log log d) time," Mathematical Systems Theory, vol. 15, pp. 295--309, 1982.

....algorithm with time complexity O(pn n log n) is in Hirschberg [1977] The O( r n) log n) time Hunt Szymanski algorithm is described in Hunt and Szymanski [1977] Apostolico [1986] improves its worst case performance. The notion of flat trees is from van Emde Boas [1975] they are improved in Johnson [1982]. Modifications to the Hunt Szymanski algorithm are discussed in Hsu and Du [1984a] but see Apostolico [1987] Apostolico and Guerra [1987] and Eppstein, Galil, Giancarlo, and Italiano [1990] Other algorithms are discussed in Chin and Poon [1990] and Rick [1995] The O(nD) time algorithm is due ....

Johnson, D. B. [1982]. "A priority queue in which initialization and queue operations take O(log log D) time," Math. Systems Theory 15, 295-309.

....path algorithms which may not be strongly polynomial, i.e. algorithms whose running time depends on L = max l(u; v) 1. These algorithms may achieve a better running time than Dijkstra s algorithm, provided L is not too large. Listed below are four such algorithms: Dial [5] O(m nL) Johnson [16] O(m log log L) Gabow [11] O(m log d L) where d = max(2; dm=ne) Ahuja, Mehlhorn, Orlin, Tarjan [3] O(m n p log L) Observe that all these algorithms except Dial s algorithm are polynomial since the size of the input is at least log L. If negative lengths are allowed then the problem can ....

D. Johnson. A priority queue in which initialization and queue operations take O(log log D). Math. Systems Theory, 15:295--309, 1982.

....fixed ffl 0) parallel algorithm, using n log log n= log n priority CRCW processors [Hag87] No optimal parallel algorithm is known for this range. Our sorting algorithm clearly belongs in the second approach. Using data structures presented by van Emde Boas, Kaas and Zijlstra [vKZ77] Johnson [Joh82] dealt with priority queues problems, where the priorities are drawn from the integer domain [1: m] A corollary of his result is an O(n log log m) time and O(m 1=c ) space algorithm for sorting, where c 0 is a constant. Johnson recognizes the problem with the space requirements of the ....

....and (2) O(log n (log log m) 2 ) time and O(n 2 m ffl ) space (ffl 0) using n(log log m) 2 log n arbitrary CRCW processors. Some of the ideas we use in the deterministic algorithms of Section 2 go back to [vKZ77] These ideas were inspired also by the algorithms of [Hag87] and [Joh82] Johnson s algorithm has the same complexity as our deterministic serial algorithm. However, our sorting algorithm has two advantages: it is simpler and parallelizable. The so called DNN algorithm of Section 2 implies efficient algorithms for the ordered chaining and for the ordered compaction ....

D.B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Math. Systems Theory, 15:295--309, 1982.

.... found independently by Eppstein et al.: 4] and by Myers and Huang [8] Eppstein et al.: observed that in the case of sequence comparison the coordinates of points are integers between 0 and N = max(N i ) and so the running time can be reduced to O(F log log F ) using a data structure of Johnson [5]. However, Myers and Huang were considering the problem of comparing restriction maps, where the points have to be modeled as K tuples of real numbers, a context in which the speedup does not apply. In order to make the central algorithm of practical value to biologists, Chao and Miller [2] ....

D. B. Johnson, A priority queue in which initialization and queue operations take O(log log D) time, Math. Syst. Theory, 15 (1982), pp. 295-309.

....where D is the embedded depth of the altered subcircuit. Thus, the total time is O(W D) We can also use other priority queue implementations to obtain different tradeoffs. For instance, using a binary heap [4, Chapter 7] yields a running time of O(W lg W ) and using Johnson s O(lg lg D) queue [8] produces a running time of O(W lg lg D) 3 A Synchronous, Parallel Algorithm This section describes a synchronous, parallel algorithm for the circuit value update problem on a circuit G = V; E) This algorithm extends the serial algorithm from Section 2 to run on multiple processors while ....

Donald B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Mathematical Systems Theory, 15(4):295--309, December 1982.

No context found.

D.B. Johnson. \A priority queue in which initialization and queue operations take #(log log #) time", ############ #### #### ###### 15, pp. 295-309, 1982.

No context found.

Donald B. Johnson. A priority queue in which initialization and queue operations take O(log log D) time. Mathematical System Theory, 15:295--309, 1982.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC