Relaxed multi-way trees with group updates

Data structures with relaxed balance differ from standard structures in that rebalancing can be delayed and interspersed with updates. This gives extra flexibility in both sequential and parallel applications. We study the version of multi-way trees called (a,b)-trees (which includes B-trees) with the operations insertion, deletion, and group insertion. The latter has applications in for instance document databases, WWW search engines, and differential indexing. We prove that we obtain the optimal asymptotic rebalancing complexities of amortized constant time for insertion and deletion and amortized logarithmic time in the size of the group for group insertion. These results hold even for the relaxed version. This is an improvement over the existing results in the most interesting cases.     

Rumor spreading in social networks

Social networks are an interesting class of graphs likely to become of increasing importance in the future, not only theoretically, but also for its probable applications to ad hoc and mobile networking. Rumor spreading is one of the basic mechanisms for information dissemination in networks; its relevance stemming from its simplicity of implementation and effectiveness. In this paper, we study the performance of rumor spreading in the classic preferential attachment model of Bollobás et al. which is considered to be a valuable model for social networks. We prove that, in these networks: (a) The standard PUSH-PULL strategy delivers the message to all nodes within O(log²n) rounds with high probability; (b) by themselves, PUSH and PULL require polynomially many rounds. (These results are under the assumption that m, the number of new links added with each new node is at least 2. If m=1 the graph is disconnected with high probability, so no rumor spreading strategy can work.) Our analysis is based on a careful study of some new properties of preferential attachment graphs which could be of independent interest.     

Improved Bounds for Finger Search on a RAM

We present a new finger search tree with O(loglogd) expected search time in the Random Access Machine (RAM) model of computation for a large class of input distributions. The parameter d represents the number of elements (distance) between the search element and an element pointed to by a finger, in a finger search tree that stores n elements. Our data structure improves upon a previous result by Andersson and Mattsson that exhibits expected O(loglogn) search time by incorporating the distance d into the search time complexity, and thus removing the dependence on n. We are also able to show that the search time is O(loglogd+?(n)) with high probability, where ?(n) is any slowly growing function of n. For the need of the analysis we model the updates by a “balls and bins” combinatorial game that is interesting in its own right as it involves insertions and deletions of balls according to an unknown distribution.     

Mantaining Dynamic Matrices for Fully Dynamic Transitive Closure

In this paper we introduce a general framework for casting fully dynamic transitive closure into the problem of reevaluating polynomials over matrices. With this technique, we improve the best known bounds for fully dynamic transitive closure. In particular, we devise a deterministic algorithm for general directed graphs that achieves O(n ²) amortized time for updates, while preserving unit worst-case cost for queries. In case of deletions only, our algorithm performs updates faster in O(n) amortized time. We observe that fully dynamic transitive closure algorithms with O(1) query time maintain explicitly the transitive closure of the input graph, in order to answer each query with exactly one lookup (on its adjacency matrix). Since an update may change as many as Ω(n ²) entries of this matrix, no better bounds are possible for this class of algorithms. This work has been partially supported by the Sixth Framework Programme of the EU under contract number 507613 (Network of Excellence “EuroNGI: Designing and Engineering of the Next Generation Internet”), and number 001907 (“DELIS: Dynamically Evolving, Large Scale Information Systems”), and by the Italian Ministry of University and Research (Project “ALGO-NEXT: Algorithms for the Next Generation Internet and Web: Methodologies, Design and Experiments”). Portions of this paper have been presented at the 41st Annual Symp. on Foundations of Computer Science, 2000.     

A compact data structure for representing a dynamic multiset

We develop a data structure for maintaining a dynamic multiset that uses bits and O(1) words, in addition to the space required by the n elements stored, supports searches in worst-case time and updates in amortized time. Compared to earlier data structures, we improve the space requirements from O(n) bits to bits, but the running time of updates is amortized, not worst-case.     

Exponentially decreasing number of operations in balanced trees

While many tree-like structures have been proven to support amortized constant number of operations after updates, considerably fewer structures have been proven to support the more general exponentially decreasing number of operations with respect to distance from the update. In addition, all existing proofs of exponentially decreasing operations are tailor-made for specific structures. We provide the first formalization of conditions under which amortized constant number of operations imply exponentially decreasing number of operations. Since our proof is constructive, we obtain the constants involved immediately. Moreover, we develop a number of techniques to improve these constants. Supported in part by the Danish Natural Science Research Council (SNF) and in part by the Future and Emerging Technologies programme of the EU under contract number IST-1999-14186 (ALCOM-FT). A preliminary version of this paper appeared in the Seventh Italian Conference on Theoretical Computer Science, Lecture Notes in Computer Science, vol. 2202, pages 293–311, Springer-Verlag, 2001.     

Updating ?,<-chains

We address the problem of very efficient reasoning and update in ?,<-chains, where a ?,<-chain is a directed acyclic graph such that there is a directed path between every pair of vertices, and edges are consistently labeled by ? or <. It is easy to show that, subsequent to an O(n) labeling scheme, queries concerning implied ? and < relations can be answered in O(1) time. However this scheme does not allow for efficient updates to a chain. We show via a novel encoding of precedence information that updates to chains can be accomplished very efficiently. For edge or vertex addition, updates can be carried out in O(logn) time, with manageable degradation for queries: ? queries are answered in O(1) time while < queries require O(logn) time. This result is surprising, in that in the obvious approach to updates O(n) time is required.     

Towards optimal range medians

We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(nlogk+klogn) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a comparison lower bound for k=O(n). The space complexity of our simple algorithm is O(nlogn) in the pointer machine model, and O(n) in the RAM model. In the latter model, a more involved O(n) space data structure can be constructed in O(nlogn) time where the time per query is reduced to O(logn/loglogn). We also give efficient dynamic variants of both data structures, achieving O(log²n) query time using O(nlogn) space in the comparison model and O((logn/loglogn)²) query time using O(nlogn/loglogn) space in the RAM model, and show that in the cell-probe model, any data structure which supports updates in O(log^O(1)n) time must have Ω(logn/loglogn) query time.Our approach naturally generalizes to higher-dimensional range median problems, where element positions and query ranges are multidimensional—it reduces a range median query to a logarithmic number of range counting queries.     

Semidynamic Algorithms for Maintaining Single-Source Shortest Path Trees

We consider the problem of updating a single-source shortest path in either a directed or an undirected graph, with positive real edge weights. Our algorithms for the incremental problem (handling edge insertions and cost decrements) work for any graph; they have optimal space requirements and query time, but their performances depend on the class of the considered graph. The cost of updates is computed in terms of amortized complexity and depends on the size of the output modifications. In the case of graphs with bounded genus (including planar graphs), graphs with bounded arboricity (including bounded degree graphs), and graphs with bounded treewidth, the incremental algorithms require O(log n) amortized time per vertex update, where a vertex is considered updated if it reduces its distance from the source. For general graphs with n vertices and m edges our incremental solution requires O( log n) amortized time per vertex update. We also consider the decremental problem for planar graphs, providing algorithms and data structures with analogous performances. The algorithms, based on Dijkstra's technique [6], require simple data structures that are really suitable for a practical and straightforward implementation. Received January 1995; revised February 1997.     

(1 + i) - ary GCD Computation inZ[ i ]as an Analogue to the Binary GCD Algorithm

We present a novel algorithm for GCD computation over the ring of Gaussian integersZ[i ], that is similar to the binary GCD algorithm forZ, in which powers of 1  + i are extracted. Our algorithm has a running time of O(n²) bit operations with a small constant hidden in the O -notation if the two input numbers have a length ofO (n) bits. This is noticeably faster than a least remainder version of the Euclidean algorithm inZ[ i ] or the Caviness–Collins GCD algorithm that both have a running time ofO (n·μ(n)) bit operations, whereμ (n) denotes a good upper bound for the multiplication time of n -bit integers. Our new GCD algorithm is also faster by a constant factor than a Lehmer-type GCD algorithm (i.e. in every Euclidean step a small remainder is calculated, but this remainder need not to be a least remainder) inZ[ i ] which achieves a running time of O(n²) bit operations.     

Intuitionistic fuzzy soft modules

Molodtsov (1999) initiated the concept of soft sets in [1]. Maji et al. (2003) defined some operations on soft sets in [22]. Akta? and Ça?man (2007) generalized soft sets by defining the concept of soft groups in [16]. After them, Sun et al. (2008) gave soft modules in [21]. In this paper, the concept of an intuitionistic fuzzy soft module is introduced and some operations on intuitionistic fuzzy soft sets are given. Finally, some of its basic properties are studied.     

A cross-layer optimization based integrated routing and grooming algorithm for green multi-granularity transport networks

With the development of IP networks and intelligent optical switch networks, the backbone network tends to be a multi-granularity transport one. In a multi-granularity transport network (MTN), due to the rapid growth of various applications, the scale and complexity of network devices are significantly enhanced. Meanwhile, to deal with bursty IP traffic, the network devices need to provide continuous services along with excessive power consumption. It has attracted wide attention from both academic and industrial communities to build a power-efficient MTN. In this paper, we design an effective node structure for MTN. Considering the power savings on both IP and optical transport layers, we propose a mathematical model to achieve a cross-layer optimization objective for power-efficient MTN. Since this optimization problem is NP-hard (Hasan et al. (2010)  [11]) and heuristic or intelligent optimization algorithms have been successfully applied to solve such kinds of problems in many engineering domains (Huang et al. (2011)  [13], Li et al. (2011)  [17] and Dong et al. (2011)  [5]), a G  reen integrated R$R$outing and Grooming algorithm based on Biogeography-Based Optimization (Simon (2008)  [23]) (GRG_BBO) is also presented. The simulation results demonstrate that, compared with the other BBO based and state-of-the-art power saving approaches, GRG_BBO improves the power savings at a rate between 2%–15% whilst the high-level multi-user QoS (Quality of Services) satisfaction degree (MQSD) is guaranteed. GRG_BBO is therefore an effective technique to build a power-efficient MTN.     

ℓ 2 2 Spreading Metrics for Vertex Ordering Problems

We design approximation algorithms for the vertex ordering problems Minimum Linear Arrangement, Minimum Containing Interval Graph, and Minimum Storage-Time Product, achieving approximation factors of $O(\sqrt{\log n}\log\log n)We design approximation algorithms for the vertex ordering problems Minimum Linear Arrangement, Minimum Containing Interval Graph, and Minimum Storage-Time Product, achieving approximation factors of O(?{logn}loglogn)O(\sqrt{\log n}\log\log n) , O(?{logn}loglogn)O(\sqrt{\log n}\log\log n) , and O(?{logT}loglogT)O(\sqrt{\log T}\log\log T) , respectively, the last running in time polynomial in T (T being the sum of execution times). The technical contribution of our paper is to introduce “ℓ ₂² spreading metrics” (that can be computed by semidefinite programming) as relaxations for both undirected and directed “permutation metrics,” which are induced by permutations of {1,2,…,n}. The techniques introduced in the recent work of Arora, Rao and Vazirani (Proc. of 36th STOC, pp. 222–231, 2004) can be adapted to exploit the geometry of such ℓ ₂² spreading metrics, giving a powerful tool for the design of divide-and-conquer algorithms. In addition to their applications to approximation algorithms, the study of such ℓ ₂² spreading metrics as relaxations of permutation metrics is interesting in its own right. We show how our results imply that, in a certain sense we make precise, ℓ ₂² spreading metrics approximate permutation metrics on n points to a factor of O(?{logn}loglogn)O(\sqrt{\log n}\log\log n) .     

Dynamically Switching Vertices in Planar Graphs

We consider graphs whose vertices may be in one of two different states: either on or off . We wish to maintain dynamically such graphs under an intermixed sequence of updates and queries. An update may reverse the status of a vertex, by switching it either on or off , and may insert a new edge or delete an existing edge. A query tests whether any two given vertices are connected in the subgraph induced by the vertices that are on . We give efficient algorithms that maintain information about connectivity on planar graphs in O( log ³ n) amortized time per query, insert, delete, switch-on, and switch-off operation over sequences of at least Ω(n) operations, where n is the number of vertices of the graph. Received September 1997; revised January 1999.     

Improved algorithm for all pairs shortest paths

We present an improved algorithm for all pairs shortest paths. For a graph of n vertices our algorithm runs in O(n³(loglogn/logn)^5/7) time. This improves the best previous result which runs in O(n³(loglogn/logn)^1/2) time.     

Fully dynamic biconnectivity in graphs

We present an algorithm for maintaining the biconnected components of a graph during a sequence of edge insertions and deletions. It requires linear storage and preprocessing time. The amortized running time for insertions and for deletions isO(m ^2/3 ), wherem is the number of edges in the graph. Any query of the form ‘Are the verticesu andv biconnected?’ can be answered in timeO(1). This is the first sublinear algorithm for this problem. We can also output all articulation points separating any two vertices efficiently. If the input is a plane graph, the amortized running time for insertions and deletions drops toO(√n logn) and the query time isO(log² n), wheren is the number of vertices in the graph. The best previously known solution takes timeO(n ^2/3 ) per update or query.     

A note on predecessor searching in the pointer machine model

Predecessor searching is a fundamental data structuring problem and at the core of countless algorithms: given a totally ordered universe U with n elements, maintain a subset S⊆U such that for each element x∈U its predecessor in S can be found efficiently. During the last thirty years the problem has been studied extensively and optimal algorithms in many classical models of computation are known. In 1988, Mehlhorn et al. [K. Mehlhorn, S. Näher, H. Alt, A lower bound on the complexity of the union-split-find problem, SIAM J. Comput. 17 (6) (1988) 1093-1102] showed an amortized lower bound of Ω(loglogn) in the pointer machine model. We give a different proof for this bound which sheds new light on the question of how much power the adversary actually needs.