Datasets:

niceanyh

/

arXiv_index_ds

like 0

cs/0211009

Sung Wing Kin, Ken

Wing-Kai Hon, Ming-Yang Kao, Tak-Wah Lam, Wing-Kin Sung, Siu-Ming Yiu

Improved Phylogeny Comparisons: Non-Shared Edges Nearest Neighbor Interchanges, and Subtree Transfers

cs.DS

The number of the non-shared edges of two phylogenies is a basic measure of the dissimilarity between the phylogenies. The non-shared edges are also the building block for approximating a more sophisticated metric called the nearest neighbor interchange (NNI) distance. In this paper, we give the first subquadratic-time algorithm for finding the non-shared edges, which are then used to speed up the existing approximating algorithm for the NNI distance from $O(n^2)$ time to $O(n \log n)$ time. Another popular distance metric for phylogenies is the subtree transfer (STT) distance. Previous work on computing the STT distance considered degree-3 trees only. We give an approximation algorithm for the STT distance for degree-$d$ trees with arbitrary $d$ and with generalized STT operations.

cs/0211010

Erik Demaine

Stephen Alstrup, Michael A. Bender, Erik D. Demaine, Martin Farach-Colton, Theis Rauhe, Mikkel Thorup

Efficient Tree Layout in a Multilevel Memory Hierarchy

18 pages. Version 2 adds faster dynamic programs. Preliminary version appeared in European Symposium on Algorithms, 2002

cs.DS

We consider the problem of laying out a tree with fixed parent/child structure in hierarchical memory. The goal is to minimize the expected number of block transfers performed during a search along a root-to-leaf path, subject to a given probability distribution on the leaves. This problem was previously considered by Gil and Itai, who developed optimal but slow algorithms when the block-transfer size B is known. We present faster but approximate algorithms for the same problem; the fastest such algorithm runs in linear time and produces a solution that is within an additive constant of optimal. In addition, we show how to extend any approximately optimal algorithm to the cache-oblivious setting in which the block-transfer size is unknown to the algorithm. The query performance of the cache-oblivious layout is within a constant factor of the query performance of the optimal known-block-size layout. Computing the cache-oblivious layout requires only logarithmically many calls to the layout algorithm for known block size; in particular, the cache-oblivious layout can be computed in O(N lg N) time, where N is the number of nodes. Finally, we analyze two greedy strategies, and show that they have a performance ratio between Omega(lg B / lg lg B) and O(lg B) when compared to the optimal layout.

cs/0211013

Alice Kolakowska

A. Kolakowska, M. A. Novotny, G. Korniss

Algorithmic scalability in globally constrained conservative parallel discrete event simulations of asynchronous systems

14 pages, 11 figures

Phys. Rev. E 67, 046703 (2003)

10.1103/PhysRevE.67.046703

cs.DC cond-mat.stat-mech cs.DS physics.comp-ph

We consider parallel simulations for asynchronous systems employing L processing elements that are arranged on a ring. Processors communicate only among the nearest neighbors and advance their local simulated time only if it is guaranteed that this does not violate causality. In simulations with no constraints, in the infinite L-limit the utilization scales (Korniss et al, PRL 84, 2000); but, the width of the virtual time horizon diverges (i.e., the measurement phase of the algorithm does not scale). In this work, we introduce a moving window global constraint, which modifies the algorithm so that the measurement phase scales as well. We present results of systematic studies in which the system size (i.e., L and the volume load per processor) as well as the constraint are varied. The constraint eliminates the extreme fluctuations in the virtual time horizon, provides a bound on its width, and controls the average progress rate. The width of the window constraint can serve as a tuning parameter that, for a given volume load per processor, could be adjusted to optimize the utilization so as to maximize the efficiency. This result may find numerous applications in modeling the evolution of general spatially extended short-range interacting systems with asynchronous dynamics, including dynamic Monte Carlo studies.

cs/0211018

Vladimir Pestov

Vladimir Pestov and Aleksandar Stojmirovic

Indexing schemes for similarity search: an illustrated paradigm

19 pages, LaTeX with 8 figures, prepared using Fundamenta Informaticae style file

Fundamenta Informaticae Vol. 70 (2006), No. 4, 367-385

cs.DS

We suggest a variation of the Hellerstein--Koutsoupias--Papadimitriou indexability model for datasets equipped with a similarity measure, with the aim of better understanding the structure of indexing schemes for similarity-based search and the geometry of similarity workloads. This in particular provides a unified approach to a great variety of schemes used to index into metric spaces and facilitates their transfer to more general similarity measures such as quasi-metrics. We discuss links between performance of indexing schemes and high-dimensional geometry. The concepts and results are illustrated on a very large concrete dataset of peptide fragments equipped with a biologically significant similarity measure.

cs/0211019

Sebastian Brand

Krzysztof R. Apt, Sebastian Brand

Schedulers for Rule-based Constraint Programming

8 pages. To appear in Proc. ACM Symposium on Applied Computing (SAC) 2003

cs.DS cs.PL

We study here schedulers for a class of rules that naturally arise in the context of rule-based constraint programming. We systematically derive a scheduler for them from a generic iteration algorithm of Apt [2000]. We apply this study to so-called membership rules of Apt and Monfroy [2001]. This leads to an implementation that yields for these rules a considerably better performance than their execution as standard CHR rules.

cs/0212044

Sandor P. Fekete

Sandor P. Fekete, Henk Meijer, Andre Rohe, and Walter Tietze

Solving a "Hard" Problem to Approximate an "Easy" One: Heuristics for Maximum Matchings and Maximum Traveling Salesman Problems

20 pages, 14 figures, Latex, to appear in Journal of Experimental Algorithms, 2002

Journal of Experimental Algorithms, 7 (2002), article 11.

cs.DS

We consider geometric instances of the Maximum Weighted Matching Problem (MWMP) and the Maximum Traveling Salesman Problem (MTSP) with up to 3,000,000 vertices. Making use of a geometric duality relationship between MWMP, MTSP, and the Fermat-Weber-Problem (FWP), we develop a heuristic approach that yields in near-linear time solutions as well as upper bounds. Using various computational tools, we get solutions within considerably less than 1% of the optimum. An interesting feature of our approach is that, even though an FWP is hard to compute in theory and Edmonds' algorithm for maximum weighted matching yields a polynomial solution for the MWMP, the practical behavior is just the opposite, and we can solve the FWP with high accuracy in order to find a good heuristic solution for the MWMP.

cs/0212047

Giorgio Parisi

Giorgio Parisi

On local equilibrium equations for clustering states

9 pages

cs.CC cond-mat.dis-nn cs.DS

In this note we show that local equilibrium equations (the generalization of the TAP equations or of the belief propagation equations) do have solutions in the colorable phase of the coloring problem. The same results extend to other optimization problems where the solutions has cost zero (e.g. K-satisfiability). On a random graph the solutions of the local equilibrium equations are associated to clusters of configurations (clustering states). On a random graph the local equilibrium equations have solutions almost everywhere in the uncolored phase; in this case we have to introduce the concept quasi-solution of the local equilibrium equations.

cs/0212054

Hsueh-I. Lu

Ching-Chi Lin, Hsueh-I Lu, I-Fan Sun

Improved Compact Visibility Representation of Planar Graph via Schnyder's Realizer

11 pages, 6 figures, the preliminary version of this paper is to appear in Proceedings of the 20th Annual Symposium on Theoretical Aspects of Computer Science (STACS), Berlin, Germany, 2003

SIAM Journal on Discrete Math, 18(1):19-29, 2004

10.1137/S0895480103420744

cs.DS cs.CG

Let $G$ be an $n$-node planar graph. In a visibility representation of $G$, each node of $G$ is represented by a horizontal line segment such that the line segments representing any two adjacent nodes of $G$ are vertically visible to each other. In the present paper we give the best known compact visibility representation of $G$. Given a canonical ordering of the triangulated $G$, our algorithm draws the graph incrementally in a greedy manner. We show that one of three canonical orderings obtained from Schnyder's realizer for the triangulated $G$ yields a visibility representation of $G$ no wider than $\frac{22n-40}{15}$. Our easy-to-implement O(n)-time algorithm bypasses the complicated subroutines for four-connected components and four-block trees required by the best previously known algorithm of Kant. Our result provides a negative answer to Kant's open question about whether $\frac{3n-6}{2}$ is a worst-case lower bound on the required width. Also, if $G$ has no degree-three (respectively, degree-five) internal node, then our visibility representation for $G$ is no wider than $\frac{4n-9}{3}$ (respectively, $\frac{4n-7}{3}$). Moreover, if $G$ is four-connected, then our visibility representation for $G$ is no wider than $n-1$, matching the best known result of Kant and He. As a by-product, we obtain a much simpler proof for a corollary of Wagner's Theorem on realizers, due to Bonichon, Sa\"{e}c, and Mosbah.

cs/0301015

Giorgio Parisi

Giorgio Parisi

Some remarks on the survey decimation algorithm for K-satisfiability

cs.CC cond-mat.dis-nn cs.DS

In this note we study the convergence of the survey decimation algorithm. An analytic formula for the reduction of the complexity during the decimation is derived. The limit of the converge of the algorithm are estimated in the random case: interesting phenomena appear near the boundary of convergence.

cs/0301019

Daniel A. Spielman

Daniel A. Spielman and Shang-Hua Teng

Smoothed Analysis of Interior-Point Algorithms: Termination

to be presented at the 2003 International Symposium on Mathematical Programming

cs.DS

We perform a smoothed analysis of the termination phase of an interior-point method. By combining this analysis with the smoothed analysis of Renegar's interior-point algorithm by Dunagan, Spielman and Teng, we show that the smoothed complexity of an interior-point algorithm for linear programming is $O (m^{3} \log (m/\sigma))$. In contrast, the best known bound on the worst-case complexity of linear programming is $O (m^{3} L)$, where $L$ could be as large as $m$. We include an introduction to smoothed analysis and a tutorial on proof techniques that have been useful in smoothed analyses.

cs/0301021

Sostenes Lins

Lauro Lins, Sostenes Lins and Silvio Melo

PHORMA: Perfectly Hashable Order Restricted Multidimensional Arrays

12 pages, 4 figures, 2 tables. Revised version. Submitted to Discrete Applied Mathematics

cs.DS

In this paper we propose a simple and efficient data structure yielding a perfect hashing of quite general arrays. The data structure is named phorma, which is an acronym for perfectly hashable order restricted multidimensional array. Keywords: Perfect hash function, Digraph, Implicit enumeration, Nijenhuis-Wilf combinatorial family.

cs/0301030

Ronald I. Greenberg

Ronald I. Greenberg

Bounds on the Number of Longest Common Subsequences

13 pages. Corrected typos, corrected operation of hyperlinks, improved presentation

cs.DM cs.DS

This paper performs the analysis necessary to bound the running time of known, efficient algorithms for generating all longest common subsequences. That is, we bound the running time as a function of input size for algorithms with time essentially proportional to the output size. This paper considers both the case of computing all distinct LCSs and the case of computing all LCS embeddings. Also included is an analysis of how much better the efficient algorithms are than the standard method of generating LCS embeddings. A full analysis is carried out with running times measured as a function of the total number of input characters, and much of the analysis is also provided for cases in which the two input sequences are of the same specified length or of two independently specified lengths.

cs/0301034

Ronald I. Greenberg

Ronald I. Greenberg

Computing the Number of Longest Common Subsequences

3 pages, LaTeX

cs.DS cs.DM

This note provides very simple, efficient algorithms for computing the number of distinct longest common subsequences of two input strings and for computing the number of LCS embeddings.

cs/0301036

Joe Francoeur

Joe Francoeur

Algorithms using Java for Spreadsheet Dependent Cell Recomputation

23 pages, 4 figures, 2 tables

cs.DS cs.DM

Java implementations of algorithms used by spreadsheets to automatically recompute the set of cells dependent on a changed cell are described using a mathematical model for spreadsheets based on graph theory. These solutions comprise part of a Java API that allows a client application to read, modify, and maintain spreadsheet data without using the spreadsheet application program that produced it. Features of the Java language that successfully improve the running time performance of the algorithms are also described.

cs/0302005

Vicky Choi

Vicky Choi and Martin Farach-Colton

Barnacle: An Assembly Algorithm for Clone-based Sequences of Whole Genomes

13 pages, 10 figures

cs.DS cs.DM q-bio

We propose an assembly algorithm {\sc Barnacle} for sequences generated by the clone-based approach. We illustrate our approach by assembling the human genome. Our novel method abandons the original physical-mapping-first framework. As we show, {\sc Barnacle} more effectively resolves conflicts due to repeated sequences. The latter is the main difficulty of the sequence assembly problem. Inaddition, we are able to detect inconsistencies in the underlying data. We present and compare our results on the December 2001 freeze of the public working draft of the human genome with NCBI's assembly (Build 28). The assembly of December 2001 freeze of the public working draft generated by {\sc Barnacle} and the source code of {\sc Barnacle} are available at (http://www.cs.rutgers.edu/~vchoi).

cs/0302009

Andrej Brodnik

Andrej Brodnik (1 and 2), Andreas Nilsson (2) ((1) IMFM, Ljubljana, Slovenia, (2) University of Technology, Lulea, Sweden)

Data Structure for a Time-Based Bandwidth Reservations Problem

cs.DS cs.NI

We discuss a problem of handling resource reservations. The resource can be reserved for some time, it can be freed or it can be queried what is the largest amount of reserved resource during a time interval. We show that the problem has a lower bound of $\Omega(\log n)$ per operation on average and we give a matching upper bound algorithm. Our solution also solves a dynamic version of the related problems of a prefix sum and a partial sum.

cs/0302011

Daniel A. Spielman

John Dunagan, Daniel A. Spielman, and Shang-Hua Teng

Smoothed Analysis of Interior-Point Algorithms: Condition Number

Fixed it up quite a bit

cs.DS cs.NA

We show that the smoothed complexity of the logarithm of Renegar's condition number is O(log (n/sigma)).

cs/0302022

James Aspnes

James Aspnes, Zoe Diamadi, and Gauri Shah

Fault-tolerant routing in peer-to-peer systems

Full version of PODC 2002 paper. New version corrects missing conditioning in Lemma 9 and some related details in the proof of Theorem 10, with no changes to main results

cs.DS cs.DC

We consider the problem of designing an overlay network and routing mechanism that permits finding resources efficiently in a peer-to-peer system. We argue that many existing approaches to this problem can be modeled as the construction of a random graph embedded in a metric space whose points represent resource identifiers, where the probability of a connection between two nodes depends only on the distance between them in the metric space. We study the performance of a peer-to-peer system where nodes are embedded at grid points in a simple metric space: a one-dimensional real line. We prove upper and lower bounds on the message complexity of locating particular resources in such a system, under a variety of assumptions about failures of either nodes or the connections between them. Our lower bounds in particular show that the use of inverse power-law distributions in routing, as suggested by Kleinberg (1999), is close to optimal. We also give efficient heuristics to dynamically maintain such a system as new nodes arrive and old nodes depart. Finally, we give experimental results that suggest promising directions for future work.

cs/0302030

David Eppstein

David Eppstein

The traveling salesman problem for cubic graphs

20 pages, 8 figures. A preliminary version of this paper appeared at the 8th Worksh. Algorithms and Data Structures, LNCS 2748, Springer-Verlag, 2003, pp. 307-318. This version generalizes an algorithm from the previous version, to generate all cycles instead of counting them. It also includes a derandomized version of the degree-four algorithm and an implementation of the cycle listing algorithm

J. Graph Algorithms and Applications 11(1):61-81, 2007

cs.DS

We show how to find a Hamiltonian cycle in a graph of degree at most three with n vertices, in time O(2^{n/3}) ~= 1.260^n and linear space. Our algorithm can find the minimum weight Hamiltonian cycle (traveling salesman problem), in the same time bound. We can also count or list all Hamiltonian cycles in a degree three graph in time O(2^{3n/8}) ~= 1.297^n. We also solve the traveling salesman problem in graphs of degree at most four, by randomized and deterministic algorithms with runtime O((27/4)^{n/3}) ~= 1.890^n and O((27/4+epsilon)^{n/3}) respectively. Our algorithms allow the input to specify a set of forced edges which must be part of any generated cycle. Our cycle listing algorithm shows that every degree three graph has O(2^{3n/8}) Hamiltonian cycles; we also exhibit a family of graphs with 2^{n/3} Hamiltonian cycles per graph.

cs/0303011

Wim H. Hesselink

Hui Gao, Jan Friso Groote, Wim H. Hesselink

Lock-free dynamic hash tables with open addressing

Distributed Computing 17 (2005) 21-42

cs.DC cs.DS

We present an efficient lock-free algorithm for parallel accessible hash tables with open addressing, which promises more robust performance and reliability than conventional lock-based implementations. ``Lock-free'' means that it is guaranteed that always at least one process completes its operation within a bounded number of steps. For a single processor architecture our solution is as efficient as sequential hash tables. On a multiprocessor architecture this is also the case when all processors have comparable speeds. The algorithm allows processors that have widely different speeds or come to a halt. It can easily be implemented using C-like languages and requires on average only constant time for insertion, deletion or accessing of elements. The algorithm allows the hash tables to grow and shrink when needed. Lock-free algorithms are hard to design correctly, even when apparently straightforward. Ensuring the correctness of the design at the earliest possible stage is a major challenge in any responsible system development. In view of the complexity of the algorithm, we turned to the interactive theorem prover PVS for mechanical support. We employ standard deductive verification techniques to prove around 200 invariance properties of our algorithm, and describe how this is achieved with the theorem prover PVS.

cs/0303022

Jean-Camille Birget

Dawei Hong, Jean-Camille Birget, Shushuang Man

Probabilistic behavior of hash tables

cs.DS cs.DB

We extend a result of Goldreich and Ron about estimating the collision probability of a hash function. Their estimate has a polynomial tail. We prove that when the load factor is greater than a certain constant, the estimator has a gaussian tail. As an application we find an estimate of an upper bound for the average search time in hashing with chaining, for a particular user (we allow the overall key distribution to be different from the key distribution of a particular user). The estimator has a gaussian tail.

cs/0304005

Oded Regev

Oded Regev

Quantum Computation and Lattice Problems

cs.DS

We present the first explicit connection between quantum computation and lattice problems. Namely, we show a solution to the Unique Shortest Vector Problem (SVP) under the assumption that there exists an algorithm that solves the hidden subgroup problem on the dihedral group by coset sampling. Moreover, we solve the hidden subgroup problem on the dihedral group by using an average case subset sum routine. By combining the two results, we get a quantum reduction from $\Theta(n^{2.5})$-unique-SVP to the average case subset sum problem.

cs/0304018

David Eppstein

David Eppstein

Quasiconvex Analysis of Backtracking Algorithms

12 pages, 2 figures. This revision includes a larger example recurrence and reports on a second implementation of the algorithm

cs.DS cs.CG math.CO

We consider a class of multivariate recurrences frequently arising in the worst case analysis of Davis-Putnam-style exponential time backtracking algorithms for NP-hard problems. We describe a technique for proving asymptotic upper bounds on these recurrences, by using a suitable weight function to reduce the problem to that of solving univariate linear recurrences; show how to use quasiconvex programming to determine the weight function yielding the smallest upper bound; and prove that the resulting upper bounds are within a polynomial factor of the true asymptotics of the recurrence. We develop and implement a multiple-gradient descent algorithm for the resulting quasiconvex programs, using a real-number arithmetic package for guaranteed accuracy of the computed worst case time bounds.

cs/0305002

Marcus Hutter

Monaldo Mastrolilli and Marcus Hutter

Hybrid Rounding Techniques for Knapsack Problems

19 LaTeX pages

Discrete Applied Mathematics, 154:4 (2006) 640-649

10.1016/j.dam.2005.08.004

IDSIA-03-02

cs.CC cs.DM cs.DS

We address the classical knapsack problem and a variant in which an upper bound is imposed on the number of items that can be selected. We show that appropriate combinations of rounding techniques yield novel and powerful ways of rounding. As an application of these techniques, we present a linear-storage Polynomial Time Approximation Scheme (PTAS) and a Fully Polynomial Time Approximation Scheme (FPTAS) that compute an approximate solution, of any fixed accuracy, in linear time. This linear complexity bound gives a substantial improvement of the best previously known polynomial bounds.

cs/0305005

Gianni Franceschini

Gianni Franceschini and Viliam Geffert

An In-Place Sorting with O(n log n) Comparisons and O(n) Moves

cs.DS cs.CC

We present the first in-place algorithm for sorting an array of size n that performs, in the worst case, at most O(n log n) element comparisons and O(n) element transports. This solves a long-standing open problem, stated explicitly, e.g., in [J.I. Munro and V. Raman, Sorting with minimum data movement, J. Algorithms, 13, 374-93, 1992], of whether there exists a sorting algorithm that matches the asymptotic lower bounds on all computational resources simultaneously.

cs/0306023

Daniel L. Wang

Adeyemi Adesanya, Jacek Becla, Daniel Wang

The Redesigned BaBar Event Store: Believe the Hype

Presented at the 2003 Computing in High Energy and Nuclear Physics (CHEP03), 5 pages, 2 ps figures, PSN TUKT008

SLAC-PUB-9893

cs.DB cs.DS

As the BaBar experiment progresses, it produces new and unforeseen requirements and increasing demands on capacity and feature base. The current system is being utilized well beyond its original design specifications, and has scaled appropriately, maintaining data consistency and durability. The persistent event storage system has remained largely unchanged since the initial implementation, and thus includes many design features which have become performance bottlenecks. Programming interfaces were designed before sufficient usage information became available. Performance and efficiency were traded off for added flexibility to cope with future demands. With significant experience in managing actual production data under our belt, we are now in a position to recraft the system to better suit current needs. The Event Store redesign is intended to eliminate redundant features while adding new ones, increase overall performance, and contain the physical storage cost of the world's largest database.

cs/0306025

Jie Gao

Jie Gao, and Dianjun Wang

Permutation Generation: Two New Permutation Algorithms

7 pages, 4 figures

cs.DS cs.CC

Two completely new algorithms for generating permutations, shift-cursor algorithm and level algorithm, and their efficient implementations are presented in this paper. One implementation of the shift cursor algorithm gives an optimal solution of the permutation generation problem, and one implementation of the level algorithm can be used to generate random permutations.

cs/0306043

James Aspnes

James Aspnes and Gauri Shah

Skip Graphs

36 pages, 12 figures. Full version of paper appearing in SODA 2003

cs.DS cs.DC

Skip graphs are a novel distributed data structure, based on skip lists, that provide the full functionality of a balanced tree in a distributed system where resources are stored in separate nodes that may fail at any time. They are designed for use in searching peer-to-peer systems, and by providing the ability to perform queries based on key ordering, they improve on existing search tools that provide only hash table functionality. Unlike skip lists or other tree data structures, skip graphs are highly resilient, tolerating a large fraction of failed nodes without losing connectivity. In addition, constructing, inserting new nodes into, searching a skip graph, and detecting and repairing errors in the data structure introduced by node failures can be done using simple and straightforward algorithms.

cs/0306044

James Aspnes

James Aspnes and Orli Waarts

Compositional competitiveness for distributed algorithms

33 pages, 2 figures; full version of STOC 96 paper titled "Modular competitiveness for distributed algorithms."

cs.DS cs.DC

We define a measure of competitive performance for distributed algorithms based on throughput, the number of tasks that an algorithm can carry out in a fixed amount of work. This new measure complements the latency measure of Ajtai et al., which measures how quickly an algorithm can finish tasks that start at specified times. The novel feature of the throughput measure, which distinguishes it from the latency measure, is that it is compositional: it supports a notion of algorithms that are competitive relative to a class of subroutines, with the property that an algorithm that is k-competitive relative to a class of subroutines, combined with an l-competitive member of that class, gives a combined algorithm that is kl-competitive. In particular, we prove the throughput-competitiveness of a class of algorithms for collect operations, in which each of a group of n processes obtains all values stored in an array of n registers. Collects are a fundamental building block of a wide variety of shared-memory distributed algorithms, and we show that several such algorithms are competitive relative to collects. Inserting a competitive collect in these algorithms gives the first examples of competitive distributed algorithms obtained by composition using a general construction.

cs/0306046

Sebastiano Vigna

Paolo Boldi and Sebastiano Vigna

Compact Approximation of Lattice Functions with Applications to Large-Alphabet Text Search

292-03

cs.DS

We propose a very simple randomised data structure that stores an approximation from above of a lattice-valued function. Computing the function value requires a constant number of steps, and the error probability can be balanced with space usage, much like in Bloom filters. The structure is particularly well suited for functions that are bottom on most of their domain. We then show how to use our methods to store in a compact way the bad-character shift function for variants of the Boyer-Moore text search algorithms. As a result, we obtain practical implementations of these algorithms that can be used with large alphabets, such as Unicode collation elements, with a small setup time. The ideas described in this paper have been implemented as free software under the GNU General Public License within the MG4J project (http://mg4j.dsi.unimi.it/).

cs/0306104

Ely Porat

Yossi Matias and Ely Porat

Efficient pebbling for list traversal synopses

27 pages

cs.DS

We show how to support efficient back traversal in a unidirectional list, using small memory and with essentially no slowdown in forward steps. Using $O(\log n)$ memory for a list of size $n$, the $i$'th back-step from the farthest point reached so far takes $O(\log i)$ time in the worst case, while the overhead per forward step is at most $\epsilon$ for arbitrary small constant $\epsilon>0$. An arbitrary sequence of forward and back steps is allowed. A full trade-off between memory usage and time per back-step is presented: $k$ vs. $kn^{1/k}$ and vice versa. Our algorithms are based on a novel pebbling technique which moves pebbles on a virtual binary, or $t$-ary, tree that can only be traversed in a pre-order fashion. The compact data structures used by the pebbling algorithms, called list traversal synopses, extend to general directed graphs, and have other interesting applications, including memory efficient hash-chain implementation. Perhaps the most surprising application is in showing that for any program, arbitrary rollback steps can be efficiently supported with small overhead in memory, and marginal overhead in its ordinary execution. More concretely: Let $P$ be a program that runs for at most $T$ steps, using memory of size $M$. Then, at the cost of recording the input used by the program, and increasing the memory by a factor of $O(\log T)$ to $O(M \log T)$, the program $P$ can be extended to support an arbitrary sequence of forward execution and rollback steps: the $i$'th rollback step takes $O(\log i)$ time in the worst case, while forward steps take O(1) time in the worst case, and $1+\epsilon$ amortized time per step.

cs/0306113

Farn Wang

Farn Wang

Symbolic Parametric Analysis of Embedded Systems with BDD-like Data-Structures

11 pages, 1 figure

cs.DS cs.LO

We use dense variable-ordering to define HRD (Hybrid-Restriction Diagram), a new BDD-like data-structure for the representation and manipulation of state-spaces of linear hybrid automata. We present and discuss various manipulation algorithms for HRD, including the basic set-oriented operations, weakest precondition calculation, and normalization. We implemented the ideas and experimented to see their performance. Finally, we have also developed a pruning technique for state-space exploration based on parameter valuation space characterization. The technique showed good promise in our experiment.

cs/0306122

Richard Wheeldon

Richard Wheeldon and Mark Levene

The Best Trail Algorithm for Assisted Navigation of Web Sites

11 pages, 11 figures

cs.DS cs.IR

We present an algorithm called the Best Trail Algorithm, which helps solve the hypertext navigation problem by automating the construction of memex-like trails through the corpus. The algorithm performs a probabilistic best-first expansion of a set of navigation trees to find relevant and compact trails. We describe the implementation of the algorithm, scoring methods for trails, filtering algorithms and a new metric called \emph{potential gain} which measures the potential of a page for future navigation opportunities.

cs/0306123

Daniel Etzold

Daniel Etzold

Heuristic to reduce the complexity of complete bipartite graphs to accelerate the search for maximum weighted matchings with small error

5 pages, 2 figures

cs.DS

A maximum weighted matching for bipartite graphs $G=(A \cup B,E)$ can be found by using the algorithm of Edmonds and Karp with a Fibonacci Heap and a modified Dijkstra in $O(nm + n^2 \log{n})$ time where n is the number of nodes and m the number of edges. For the case that $|A|=|B|$ the number of edges is $n^2$ and therefore the complexity is $O(n^3)$. In this paper we want to present a simple heuristic method to reduce the number of edges of complete bipartite graphs $G=(A \cup B,E)$ with $|A|=|B|$ such that $m = n\log{n}$ and therefore the complexity of such that $m = n\log{n}$ and therefore the complexity of $O(n^2 \log{n})$. The weights of all edges in G must be uniformly distributed in [0,1].

cs/0307005

Erik Demaine

Ilya Baran and Erik D. Demaine

Optimal Adaptive Algorithms for Finding the Nearest and Farthest Point on a Parametric Black-Box Curve

19 pages, 8 figures; v3 adds relative-error results; v2 adds description of related work in introduction

cs.CG cs.DS

We consider a general model for representing and manipulating parametric curves, in which a curve is specified by a black box mapping a parameter value between 0 and 1 to a point in Euclidean d-space. In this model, we consider the nearest-point-on-curve and farthest-point-on-curve problems: given a curve C and a point p, find a point on C nearest to p or farthest from p. In the general black-box model, no algorithm can solve these problems. Assuming a known bound on the speed of the curve (a Lipschitz condition), the answer can be estimated up to an additive error of epsilon using O(1/epsilon) samples, and this bound is tight in the worst case. However, many instances can be solved with substantially fewer samples, and we give algorithms that adapt to the inherent difficulty of the particular instance, up to a logarithmic factor. More precisely, if OPT(C,p,epsilon) is the minimum number of samples of C that every correct algorithm must perform to achieve tolerance epsilon, then our algorithm performs O(OPT(C,p,epsilon) log (epsilon^(-1)/OPT(C,p,epsilon))) samples. Furthermore, any algorithm requires Omega(k log (epsilon^(-1)/k)) samples for some instance C' with OPT(C',p,epsilon) = k; except that, for the nearest-point-on-curve problem when the distance between C and p is less than epsilon, OPT is 1 but the upper and lower bounds on the number of samples are both Theta(1/epsilon). When bounds on relative error are desired, we give algorithms that perform O(OPT log (2+(1+epsilon^(-1)) m^(-1)/OPT)) samples (where m is the exact minimum or maximum distance from p to C) and prove that Omega(OPT log (1/epsilon)) samples are necessary on some problem instances.

cs/0307034

Pat Morin

Danny Krizanc, Pat Morin and Michiel Smid

Range Mode and Range Median Queries on Lists and Trees

12 pages, 6 figures

cs.DS

We consider algorithms for preprocessing labelled lists and trees so that, for any two nodes u and v we can answer queries of the form: What is the mode or median label in the sequence of labels on the path from u to v.

cs/0307043

Aravind Srinivasan

Aravind Srinivasan

An Extension of the Lovasz Local Lemma, and its Applications to Integer Programming

22 pages, preliminary version appeared in the SODA 1996 conference

cs.DS

The Lovasz Local Lemma due to Erdos and Lovasz is a powerful tool in proving the existence of rare events. We present an extension of this lemma, which works well when the event to be shown to exist is a conjunction of individual events, each of which asserts that a random variable does not deviate much from its mean. As applications, we consider two classes of NP-hard integer programs: minimax and covering integer programs. A key technique, randomized rounding of linear relaxations, was developed by Raghavan and Thompson to derive good approximation algorithms for such problems. We use our extension of the Local Lemma to prove that randomized rounding produces, with non-zero probability, much better feasible solutions than known before, if the constraint matrices of these integer programs are column-sparse (e.g., routing using short paths, problems on hypergraphs with small dimension/degree). This complements certain well-known results from discrepancy theory. We also generalize the method of pessimistic estimators due to Raghavan, to obtain constructive (algorithmic) versions of our results for covering integer programs.

cs/0307062

Viviane Baladi

Viviane Baladi and Brigitte Vallee

Euclidean algorithms are Gaussian

fourth revised version - 2 figures - the strict convexity condition used has been clarified

cs.DS cs.CC

This study provides new results about the probabilistic behaviour of a class of Euclidean algorithms: the asymptotic distribution of a whole class of cost-parameters associated to these algorithms is normal. For the cost corresponding to the number of steps Hensley already has proved a Local Limit Theorem; we give a new proof, and extend his result to other euclidean algorithms and to a large class of digit costs, obtaining a faster, optimal, rate of convergence. The paper is based on the dynamical systems methodology, and the main tool is the transfer operator. In particular, we use recent results of Dolgopyat.

cs/0308004

Gene Cooperman

Gene Cooperman, Xiaoqin Ma and Viet Ha Nguyen

DPG: A Cache-Efficient Accelerator for Sorting and for Join Operators

12 pages, 11 figures

cs.DB cs.DS

We present a new algorithm for fast record retrieval, distribute-probe-gather, or DPG. DPG has important applications both in sorting and in joins. Current main memory sorting algorithms split their work into three phases: extraction of key-pointer pairs; sorting of the key-pointer pairs; and copying of the original records into the destination array according the sorted key-pointer pairs. The copying in the last phase dominates today's sorting time. Hence, the use of DPG in the third phase provides an accelerator for existing sorting algorithms. DPG also provides two new join methods for foreign key joins: DPG-move join and DPG-sort join. The resulting join methods with DPG are faster because DPG join is cache-efficient and at the same time DPG join avoids the need for sorting or for hashing. The ideas presented for foreign key join can also be extended to faster record pair retrieval for spatial and temporal databases.

cs/0308006

Sandor P. Fekete

Sandor P. Fekete and Ekkehard Koehler and Juergen Teich

Higher-Dimensional Packing with Order Constraints

23 pages, 14 figures, 5 tables, Latex; revision clarifies various minor points, fixes typos, etc. To appear in SIAM Journal on Discrete Mathematics

cs.DS cs.DM

We present a first exact study on higher-dimensional packing problems with order constraints. Problems of this type occur naturally in applications such as logistics or computer architecture and can be interpreted as higher-dimensional generalizations of scheduling problems. Using graph-theoretic structures to describe feasible solutions, we develop a novel exact branch-and-bound algorithm. This extends previous work by Fekete and Schepers; a key tool is a new order-theoretic characterization of feasible extensions of a partial order to a given complementarity graph that is tailor-made for use in a branch-and-bound environment. The usefulness of our approach is validated by computational results.

cs/0308011

Matjaz Zaversnik

V. Batagelj, M. Zaversnik

Short Cycles Connectivity

DISCRETE MATH 307 (3-5): 310-318 FEB 6 2007

cs.DS cs.DM

Short cycles connectivity is a generalization of ordinary connectivity. Instead by a path (sequence of edges), two vertices have to be connected by a sequence of short cycles, in which two adjacent cycles have at least one common vertex. If all adjacent cycles in the sequence share at least one edge, we talk about edge short cycles connectivity. It is shown that the short cycles connectivity is an equivalence relation on the set of vertices, while the edge short cycles connectivity components determine an equivalence relation on the set of edges. Efficient algorithms for determining equivalence classes are presented. Short cycles connectivity can be extended to directed graphs (cyclic and transitive connectivity). For further generalization we can also consider connectivity by small cliques or other families of graphs.

cs/0308039

Andreas Schaale

Andreas Schaale, Carsten Wulf-Mathies, Soenke Lieberam-Schmidt

A new approach to relevancy in Internet searching - the "Vox Populi Algorithm"

9 pages Latex

cs.DS cond-mat.dis-nn cs.IR

In this paper we will derive a new algorithm for Internet searching. The main idea of this algorithm is to extend the existing algorithms by a component, which reflects the interests of the users more than existing methods. The "Vox Populi Algorithm" (VPA) creates a feedback from the users to the content of the search index. The information derived from the users query analysis is used to modify the existing crawling algorithms. The VPA controls the distribution of the resources of the crawler. Finally, we also discuss methods of suppressing unwanted content (spam).

cs/0308041

Andrej Brodnik

Andrej Brodnik and Andreas Nilsson

Static Data Structure for Discrete Advance Bandwidth Reservations on the Internet

IMFM-(2003)-PS-889

cs.DS

In this paper we present a discrete data structure for reservations of limited resources. A reservation is defined as a tuple consisting of the time interval of when the resource should be reserved, $I_R$, and the amount of the resource that is reserved, $B_R$, formally $R=\{I_R,B_R\}$. The data structure is similar to a segment tree. The maximum spanning interval of the data structure is fixed and defined in advance. The granularity and thereby the size of the intervals of the leaves is also defined in advance. The data structure is built only once. Neither nodes nor leaves are ever inserted, deleted or moved. Hence, the running time of the operations does not depend on the number of reservations previously made. The running time does not depend on the size of the interval of the reservation either. Let $n$ be the number of leaves in the data structure. In the worst case, the number of touched (i.e. traversed) nodes is in any operation $O(\log n)$, hence the running time of any operation is also $O(\log n)$.

cs/0308044

Grigorii Pivovarov

Grigorii Pivovarov and Sergei Trunov

EqRank: A Self-Consistent Equivalence Relation on Graph Vertexes

a kdd cup 2003 submission

cs.DS cs.DL

A new method of hierarchical clustering of graph vertexes is suggested. In the method, the graph partition is determined with an equivalence relation satisfying a recursive definition stating that vertexes are equivalent if the vertexes they point to (or vertexes pointing to them) are equivalent. Iterative application of the partitioning yields a hierarchical clustering of graph vertexes. The method is applied to the citation graph of hep-th. The outcome is a two-level classification scheme for the subject field presented in hep-th, and indexing of the papers from hep-th in this scheme. A number of tests show that the classification obtained is adequate.

cs/0309005

Aleksandar Stojmirovic

Aleksandar Stojmirovic and Vladimir Pestov

Indexing Schemes for Similarity Search In Datasets of Short Protein Fragments

34 pages, 12 figures, 4 tables - Timings for experiments added upon referees' request, and a number of less substantial modifications made

Information Systems 32 (2007), 1145-1165

cs.DS q-bio.BM

We propose a family of very efficient hierarchical indexing schemes for ungapped, score matrix-based similarity search in large datasets of short (4-12 amino acid) protein fragments. This type of similarity search has importance in both providing a building block to more complex algorithms and for possible use in direct biological investigations where datasets are of the order of 60 million objects. Our scheme is based on the internal geometry of the amino acid alphabet and performs exceptionally well, for example outputting 100 nearest neighbours to any possible fragment of length 10 after scanning on average less than one per cent of the entire dataset.

cs/0309014

Sandor P. Fekete

Esther M. Arkin, Michael A. Bender, Erik D. Demaine, Sandor P. Fekete, Joseph S. B. Mitchell, and Saurabh Sethia

Optimal Covering Tours with Turn Costs

36 pages, 19 figures, 2 tables, Latex; to appear in SIAM Journal on Computing. New version contains more technical details in Sections 4.1, 5.1, 5.2, 5.5, four more figures, four more pages, as well as numerous smaller changes

cs.DS cs.CG

We give the first algorithmic study of a class of ``covering tour'' problems related to the geometric Traveling Salesman Problem: Find a polygonal tour for a cutter so that it sweeps out a specified region (``pocket''), in order to minimize a cost that depends mainly on the number of em turns. These problems arise naturally in manufacturing applications of computational geometry to automatic tool path generation and automatic inspection systems, as well as arc routing (``postman'') problems with turn penalties. We prove the NP-completeness of minimum-turn milling and give efficient approximation algorithms for several natural versions of the problem, including a polynomial-time approximation scheme based on a novel adaptation of the m-guillotine method.

cs/0309016

Liam Wagner

Stuart McDonald and Liam Wagner

Using Simulated Annealing to Calculate the Trembles of Trembling Hand Perfection

To appear in the Proceedings of IEEE Congress on Evolutionary Computation 2003 (CEC'03)

Proceedings of IEEE Congress on Evolutionary Computation 2003, vol.4, pp. 2482-2489

cs.GT cs.CC cs.DS cs.LG cs.NE q-bio.PE

Within the literature on non-cooperative game theory, there have been a number of attempts to propose logorithms which will compute Nash equilibria. Rather than derive a new algorithm, this paper shows that the family of algorithms known as Markov chain Monte Carlo (MCMC) can be used to calculate Nash equilibria. MCMC is a type of Monte Carlo simulation that relies on Markov chains to ensure its regularity conditions. MCMC has been widely used throughout the statistics and optimization literature, where variants of this algorithm are known as simulated annealing. This paper shows that there is interesting connection between the trembles that underlie the functioning of this algorithm and the type of Nash refinement known as trembling hand perfection.

cs/0309023

Vladimir Batagelj

Vladimir Batagelj (University of Ljubljana, Slovenia)

Efficient Algorithms for Citation Network Analysis

inside the book: V. Batagelj, P. Doreian, A. Ferligoj, N. Kej\v{z}ar: Understanding Large Temporal Networks and Spatial Networks. Wiley, 2014. ISBN: 978-0-470-71452-2

IMFM 897

cs.DL cs.DM cs.DS

In the paper very efficient, linear in number of arcs, algorithms for determining Hummon and Doreian's arc weights SPLC and SPNP in citation network are proposed, and some theoretical properties of these weights are presented. The nonacyclicity problem in citation networks is discussed. An approach to identify on the basis of arc weights an important small subnetwork is proposed and illustrated on the citation networks of SOM (self organizing maps) literature and US patents.

cs/0309033

Pranab Sen

Pranab Sen and S. Venkatesh

Lower bounds for predecessor searching in the cell probe model

Journal version of a paper at ICALP 2001 (quant-ph/0104100) and a paper at CCC 2003. 27 pages

cs.CC cs.DS quant-ph

We consider a fundamental problem in data structures, static predecessor searching: Given a subset S of size n from the universe [m], store S so that queries of the form "What is the predecessor of x in S?" can be answered efficiently. We study this problem in the cell probe model introduced by Yao. Recently, Beame and Fich obtained optimal bounds on the number of probes needed by any deterministic query scheme if the associated storage scheme uses only n^{O(1)} cells of word size (\log m)^{O(1)} bits. We give a new lower bound proof for this problem that matches the bounds of Beame and Fich. Our lower bound proof has the following advantages: it works for randomised query schemes too, while Beame and Fich's proof works for deterministic query schemes only. It also extends to `quantum address-only' query schemes that we define in this paper, and is simpler than Beame and Fich's proof. We prove our lower bound using the round elimination approach of Miltersen, Nisan, Safra and Wigderson. Using tools from information theory, we prove a strong round elimination lemma for communication complexity that enables us to obtain a tight lower bound for the predecessor problem. Our strong round elimination lemma also extends to quantum communication complexity. We also use our round elimination lemma to obtain a rounds versus communication tradeoff for the `greater-than' problem, improving on the tradeoff in Miltersen et al. We believe that our round elimination lemma is of independent interest and should have other applications.

cs/0309043

Valmir Barbosa

A. H. L. Porto, V. C. Barbosa

Finding approximate palindromes in strings

Pattern Recognition 35 (2002), 2581-2591

10.1016/S0031-3203(01)00179-0

cs.DS

We introduce a novel definition of approximate palindromes in strings, and provide an algorithm to find all maximal approximate palindromes in a string with up to $k$ errors. Our definition is based on the usual edit operations of approximate pattern matching, and the algorithm we give, for a string of size $n$ on a fixed alphabet, runs in $O(k^2 n)$ time. We also discuss two implementation-related improvements to the algorithm, and demonstrate their efficacy in practice by means of both experiments and an average-case analysis.

cs/0310003

Darin Goldstein

Darin Goldstein and Nick Meyer

The Wake Up and Report Problem is Time-Equivalent to the Firing Squad Synchronization Problem

13 pages, 4 figures, in Symposium on Discrete Algorithms, (SODA) pp. 578-587, January 6-8, 2002 (journal version to appear in the Journal of Distributed Computing)

cs.DC cs.DS

We consider several problems relating to strongly-connected directed networks of identical finite-state processors that work synchronously in discrete time steps. The conceptually simplest of these is the Wake Up and Report Problem; this is the problem of having a unique "root" processor send a signal to all other processors in the network and then enter a special "done" state only when all other processors have received the signal. The most difficult of the problems we consider is the classic Firing Squad Synchronization Problem; this is the much-studied problem of achieving macro-synchronization in a network given micro-synchronization. We show via a complex algorithmic application of the "snake" data structure first introduced in Even, Litman, and Winkler [ELW], that these two problems are asymptotically time-equivalent up to a constant factor. This result leads immediately to the inclusion of several other related problems into this new asymptotic time-class.

cs/0310004

Darin Goldstein

Darin Goldstein

Determination of the Topology of a Directed Network

9 pages, no figures, accepted to appear in IPDPS 2002 (unable to attend), (journal version to appear in Information Processing Letters)

cs.DC cs.DS

We consider strongly-connected directed networks of identical synchronous, finite-state processors with in- and out-degree uniformly bounded by a network constant. Via a straightforward extension of Ostrovsky and Wilkerson's Backwards Communication Algorithm in [OW], we exhibit a protocol which solves the Global Topology Determination Problem, the problem of having the root processor map the global topology of a network of unknown size and topology, with running time O(ND) where N represents the number of processors and D represents the diameter of the network. A simple counting argument suffices to show that the Global Topology Determination Problem has time-complexity Omega(N logN) which makes the protocol presented asymptotically time-optimal for many large networks.

cs/0310019

Koskas Michel

Michel Koskas

A hierarchical Algorithm to Solve the Shortest Path Problem in Valued Graphs

18 pages, 5 figures

cs.DS cs.DM

This paper details a new algorithm to solve the shortest path problem in valued graphs. Its complexity is $O(D \log v)$ where $D$ is the graph diameter and $v$ its number of vertices. This complexity has to be compared to the one of the Dijkstra's algorithm, which is $O(e\log v)$ where $e$ is the number of edges of the graph. This new algorithm lies on a hierarchical representation of the graph, using radix trees. The performances of this algorithm show a major improvement over the ones of the algorithms known up to now.

cs/0310022

Daniel A. Spielman

Arvind Sankar, Daniel A. Spielman, Shang-Hua Teng

Smoothed Analysis of the Condition Numbers and Growth Factors of Matrices

corrected some minor mistakes

cs.NA cs.DS

Let $\orig{A}$ be any matrix and let $A$ be a slight random perturbation of $\orig{A}$. We prove that it is unlikely that $A$ has large condition number. Using this result, we prove it is unlikely that $A$ has large growth factor under Gaussian elimination without pivoting. By combining these results, we bound the smoothed precision needed by Gaussian elimination without pivoting. Our results improve the average-case analysis of Gaussian elimination without pivoting performed by Yeung and Chan (SIAM J. Matrix Anal. Appl., 1997).

cs/0310027

Sandor P. Fekete

Sandor P. Fekete and Joseph S.B. Mitchell and Karin Beurer

On the continuous Fermat-Weber problem

28 pages, 18 figures, Latex, to appear in Operations Research, extended abstract version appeared in SoCG 2000

cs.CG cs.DS

We give the first exact algorithmic study of facility location problems that deal with finding a median for a continuum of demand points. In particular, we consider versions of the ``continuous k-median (Fermat-Weber) problem'' where the goal is to select one or more center points that minimize the average distance to a set of points in a demand region. In such problems, the average is computed as an integral over the relevant region, versus the usual discrete sum of distances. The resulting facility location problems are inherently geometric, requiring analysis techniques of computational geometry. We provide polynomial-time algorithms for various versions of the L1 1-median (Fermat-Weber) problem. We also consider the multiple-center version of the L1 k-median problem, which we prove is NP-hard for large k.

cs/0310032

Sandor P. Fekete

Sandor P. Fekete and Joerg Schepers

A combinatorial characterization of higher-dimensional orthogonal packing

21 pages, 8 figures, Latex, to appear in Mathematics of Operations Research

cs.DS cs.CG

Higher-dimensional orthogonal packing problems have a wide range of practical applications, including packing, cutting, and scheduling. Previous efforts for exact algorithms have been unable to avoid structural problems that appear for instances in two- or higher-dimensional space. We present a new approach for modeling packings, using a graph-theoretical characterization of feasible packings. Our characterization allows it to deal with classes of packings that share a certain combinatorial structure, instead of having to consider one packing at a time. In addition, we can make use of elegant algorithmic properties of certain classes of graphs. This allows our characterization to be the basis for a successful branch-and-bound framework. This is the first in a series of papers describing new approaches to higher-dimensional packing.

cs/0310034

Sandor P. Fekete

Sandor P. Fekete and Marco Luebbecke and Henk Meijer

Minimizing the stabbing number of matchings, trees, and triangulations

25 pages, 12 figures, Latex. To appear in "Discrete and Computational Geometry". Previous version (extended abstract) appears in SODA 2004, pp. 430-439

10.1007/s00454-008-9114-6

cs.CG cs.DS

http://arxiv.org/licenses/nonexclusive-distrib/1.0/

The (axis-parallel) stabbing number of a given set of line segments is the maximum number of segments that can be intersected by any one (axis-parallel) line. This paper deals with finding perfect matchings, spanning trees, or triangulations of minimum stabbing number for a given set of points. The complexity of these problems has been a long-standing open question; in fact, it is one of the original 30 outstanding open problems in computational geometry on the list by Demaine, Mitchell, and O'Rourke. The answer we provide is negative for a number of minimum stabbing problems by showing them NP-hard by means of a general proof technique. It implies non-trivial lower bounds on the approximability. On the positive side we propose a cut-based integer programming formulation for minimizing the stabbing number of matchings and spanning trees. We obtain lower bounds (in polynomial time) from the corresponding linear programming relaxations, and show that an optimal fractional solution always contains an edge of at least constant weight. This result constitutes a crucial step towards a constant-factor approximation via an iterated rounding scheme. In computational experiments we demonstrate that our approach allows for actually solving problems with up to several hundred points optimally or near-optimally.

cs/0310036

Daniel A. Spielman

Daniel A. Spielman and Shang-Hua Teng

Solving Sparse, Symmetric, Diagonally-Dominant Linear Systems in Time $O (m^{1.31})$

fixed a typo on page 9

cs.DS cs.NA

We present a linear-system solver that, given an $n$-by-$n$ symmetric positive semi-definite, diagonally dominant matrix $A$ with $m$ non-zero entries and an $n$-vector $\bb $, produces a vector $\xxt$ within relative distance $\epsilon$ of the solution to $A \xx = \bb$ in time $O (m^{1.31} \log (n \kappa_{f} (A)/\epsilon)^{O (1)})$, where $\kappa_{f} (A)$ is the log of the ratio of the largest to smallest non-zero eigenvalue of $A$. In particular, $\log (\kappa_{f} (A)) = O (b \log n)$, where $b$ is the logarithm of the ratio of the largest to smallest non-zero entry of $A$. If the graph of $A$ has genus $m^{2\theta}$ or does not have a $K_{m^{\theta}} $ minor, then the exponent of $m$ can be improved to the minimum of $1 + 5 \theta $ and $(9/8) (1+\theta)$. The key contribution of our work is an extension of Vaidya's techniques for constructing and analyzing combinatorial preconditioners.

cs/0310037

Sandor P. Fekete

Sandor P. Fekete and Henk Meijer

Maximum dispersion and geometric maximum weight cliques

13 pages, 1 figure, Latex, to appear in Algorithmica

Algorithmica, 38 (3) 2004, 501-511.

cs.DS cs.CG

We consider a facility location problem, where the objective is to ``disperse'' a number of facilities, i.e., select a given number k of locations from a discrete set of n candidates, such that the average distance between selected locations is maximized. In particular, we present algorithmic results for the case where vertices are represented by points in d-dimensional space, and edge weights correspond to rectilinear distances. Problems of this type have been considered before, with the best result being an approximation algorithm with performance ratio 2. For the case where k is fixed, we establish a linear-time algorithm that finds an optimal solution. For the case where k is part of the input, we present a polynomial-time approximation scheme.

cs/0310049

Matjaz Zaversnik

V. Batagelj and M. Zaversnik

An O(m) Algorithm for Cores Decomposition of Networks

Advances in Data Analysis and Classification, 2011. Volume 5, Number 2, 129-145

cs.DS cs.DM

The structure of large networks can be revealed by partitioning them to smaller parts, which are easier to handle. One of such decompositions is based on $k$--cores, proposed in 1983 by Seidman. In the paper an efficient, $O(m)$, $m$ is the number of lines, algorithm for determining the cores decomposition of a given network is presented.

cs/0310051

Daniel A. Spielman

Daniel A. Spielman and Shang-Hua Teng

Nearly-Linear Time Algorithms for Graph Partitioning, Graph Sparsification, and Solving Linear Systems

withdrawn by author

cs.DS cs.NA

http://arxiv.org/licenses/nonexclusive-distrib/1.0/

This paper has been divided into three papers. arXiv:0809.3232, arXiv:0808.4134, arXiv:cs/0607105

cs/0310065

Mikkel Thorup

Stephen Alstrup, Jacob Holm, Kristian de Lichtenberg, Mikkel Thorup

Maintaining Information in Fully-Dynamic Trees with Top Trees

Preliminary versions of this work presented at ICALP'97 and SWAT'00. The new version takes layered top trees into account

cs.DS

We introduce top trees as a design of a new simpler interface for data structures maintaining information in a fully-dynamic forest. We demonstrate how easy and versatile they are to use on a host of different applications. For example, we show how to maintain the diameter, center, and median of each tree in the forest. The forest can be updated by insertion and deletion of edges and by changes to vertex and edge weights. Each update is supported in O(log n) time, where n is the size of the tree(s) involved in the update. Also, we show how to support nearest common ancestor queries and level ancestor queries with respect to arbitrary roots in O(log n) time. Finally, with marked and unmarked vertices, we show how to compute distances to a nearest marked vertex. The later has applications to approximate nearest marked vertex in general graphs, and thereby to static optimization problems over shortest path metrics. Technically speaking, top trees are easily implemented either with Frederickson's topology trees [Ambivalent Data Structures for Dynamic 2-Edge-Connectivity and k Smallest Spanning Trees, SIAM J. Comput. 26 (2) pp. 484-538, 1997] or with Sleator and Tarjan's dynamic trees [A Data Structure for Dynamic Trees. J. Comput. Syst. Sc. 26 (3) pp. 362-391, 1983]. However, we claim that the interface is simpler for many applications, and indeed our new bounds are quadratic improvements over previous bounds where they exist.

cs/0311018

Carla Piazza

Carla Piazza (1) and Alberto Policriti (2) ((1) Universita' Ca' Foscari di Venezia (2) Universita' degli Studi di Udine)

Ackermann Encoding, Bisimulations, and OBDDs

To appear on 'Theory and Practice of Logic Programming'

cs.LO cs.DS

We propose an alternative way to represent graphs via OBDDs based on the observation that a partition of the graph nodes allows sharing among the employed OBDDs. In the second part of the paper we present a method to compute at the same time the quotient w.r.t. the maximum bisimulation and the OBDD representation of a given graph. The proposed computation is based on an OBDD-rewriting of the notion of Ackermann encoding of hereditarily finite sets into natural numbers.

cs/0311020

Hsueh-I. Lu

Kai-min Chung and Hsueh-I Lu

An Optimal Algorithm for the Maximum-Density Segment Problem

15 pages, 12 figures, an early version of this paper was presented at 11th Annual European Symposium on Algorithms (ESA 2003), Budapest, Hungary, September 15-20, 2003

SIAM Journal on Computing, 34(2):373-387, 2004

10.1137/S0097539704440430

cs.DS cs.DM

We address a fundamental problem arising from analysis of biomolecular sequences. The input consists of two numbers $w_{\min}$ and $w_{\max}$ and a sequence $S$ of $n$ number pairs $(a_i,w_i)$ with $w_i>0$. Let {\em segment} $S(i,j)$ of $S$ be the consecutive subsequence of $S$ between indices $i$ and $j$. The {\em density} of $S(i,j)$ is $d(i,j)=(a_i+a_{i+1}+...+a_j)/(w_i+w_{i+1}+...+w_j)$. The {\em maximum-density segment problem} is to find a maximum-density segment over all segments $S(i,j)$ with $w_{\min}\leq w_i+w_{i+1}+...+w_j \leq w_{\max}$. The best previously known algorithm for the problem, due to Goldwasser, Kao, and Lu, runs in $O(n\log(w_{\max}-w_{\min}+1))$ time. In the present paper, we solve the problem in O(n) time. Our approach bypasses the complicated {\em right-skew decomposition}, introduced by Lin, Jiang, and Chao. As a result, our algorithm has the capability to process the input sequence in an online manner, which is an important feature for dealing with genome-scale sequences. Moreover, for a type of input sequences $S$ representable in $O(m)$ space, we show how to exploit the sparsity of $S$ and solve the maximum-density segment problem for $S$ in $O(m)$ time.

cs/0311030

Zoe Abrams

Zoe Abrams, Ashish Goel, Serge Plotkin

Set K-Cover Algorithms for Energy Efficient Monitoring in Wireless Sensor Networks

cs.DS

Wireless sensor networks (WSNs) are emerging as an effective means for environment monitoring. This paper investigates a strategy for energy efficient monitoring in WSNs that partitions the sensors into covers, and then activates the covers iteratively in a round-robin fashion. This approach takes advantage of the overlap created when many sensors monitor a single area. Our work builds upon previous work in "Power Efficient Organization of Wireless Sensor Networks" by Slijepcevic and Potkonjak, where the model is first formulated. We have designed three approximation algorithms for a variation of the SET K-COVER problem, where the objective is to partition the sensors into covers such that the number of covers that include an area, summed over all areas, is maximized. The first algorithm is randomized and partitions the sensors, in expectation, within a fraction 1 - 1/e (~.63) of the optimum. We present two other deterministic approximation algorithms. One is a distributed greedy algorithm with a 1/2 approximation ratio and the other is a centralized greedy algorithm with a 1 - 1/e approximation ratio. We show that it is NP-Complete to guarantee better than 15/16 of the optimal coverage, indicating that all three algorithms perform well with respect to the best approximation algorithm possible. Simulations indicate that in practice, the deterministic algorithms perform far above their worst case bounds, consistently covering more than 72% of what is covered by an optimum solution. Simulations also indicate that the increase in longevity is proportional to the amount of overlap amongst the sensors. The algorithms are fast, easy to use, and according to simulations, significantly increase the longevity of sensor networks. The randomized algorithm in particular seems quite practical.

cs/0312011

Giorgio Parisi

Giorgio Parisi

Constraint Optimization and Statistical Mechanics

22 pages, 1 figure Lectures given at the Varenna summer school

cs.CC cond-mat.dis-nn cs.DS

In these lectures I will present an introduction to the results that have been recently obtained in constraint optimization of random problems using statistical mechanics techniques. After presenting the general results, in order to simplify the presentation I will describe in details only the problems related to the coloring of a random graph.

cs/0312054

Krzysztof C. Kiwiel

Krzysztof C. Kiwiel

Partitioning schemes for quicksort and quickselect

21 pages

PMMO-03-01

cs.DS

We introduce several modifications of the partitioning schemes used in Hoare's quicksort and quickselect algorithms, including ternary schemes which identify keys less or greater than the pivot. We give estimates for the numbers of swaps made by each scheme. Our computational experiments indicate that ternary schemes allow quickselect to identify all keys equal to the selected key at little additional cost.

cs/0312055

Krzysztof C. Kiwiel

Krzysztof C. Kiwiel

Randomized selection with quintary partitions

21 pages

PMMO-03-02

cs.DS

We show that several versions of Floyd and Rivest's algorithm Select for finding the $k$th smallest of $n$ elements require at most $n+\min\{k,n-k\}+o(n)$ comparisons on average and with high probability. This rectifies the analysis of Floyd and Rivest, and extends it to the case of nondistinct elements. Our computational results confirm that Select may be the best algorithm in practice.

cs/0401001

Johan Bollen

Terry L. Harrison, Aravind Elango, Johan Bollen and Michael Nelson

Initial Experiences Re-Exporting Duplicate and Similarity Computation with an OAI-PMH aggregator

10 pages

cs.DL cs.DS

The proliferation of the Open Archive Initiative Protocol for Metadata Harvesting (OAI-PMH) has resulted in the creation of a large number of service providers, all harvesting from either data providers or aggregators. If data were available regarding the similarity of metadata records, service providers could track redundant records across harvests from multiple sources as well as provide additional end-user services. Due to the large number of metadata formats and the diverse mapping strategies employed by data providers, similarity calculation requirements necessitate the use of information retrieval strategies. We describe an OAI-PMH aggregator implementation that uses the optional ``<about>'' container to re-export the results of similarity calculations. Metadata records (3751) were harvested from a NASA data provider and similarities for the records were computed. The results were useful for detecting duplicates, similarities and metadata errors.

cs/0401003

Krzysztof C. Kiwiel

Krzysztof C. Kiwiel

Randomized selection with tripartitioning

19 pages

PMMO-04-01

cs.DS

We show that several versions of Floyd and Rivest's algorithm Select [Comm.\ ACM {\bf 18} (1975) 173] for finding the $k$th smallest of $n$ elements require at most $n+\min\{k,n-k\}+o(n)$ comparisons on average, even when equal elements occur. This parallels our recent analysis of another variant due to Floyd and Rivest [Comm. ACM {\bf 18} (1975) 165--172]. Our computational results suggest that both variants perform well in practice, and may compete with other selection methods, such as Hoare's Find or quickselect with median-of-3 pivots.

cs/0401011

Remi Monasson

Simona Cocco, Remi Monasson

Heuristic average-case analysis of the backtrack resolution of random 3-Satisfiability instances

to appear in Theoretical Computer Science

Theoretical Computer Science (2004) A 320, 345

cs.DS cond-mat.stat-mech cs.CC

An analysis of the average-case complexity of solving random 3-Satisfiability (SAT) instances with backtrack algorithms is presented. We first interpret previous rigorous works in a unifying framework based on the statistical physics notions of dynamical trajectories, phase diagram and growth process. It is argued that, under the action of the Davis--Putnam--Loveland--Logemann (DPLL) algorithm, 3-SAT instances are turned into 2+p-SAT instances whose characteristic parameters (ratio alpha of clauses per variable, fraction p of 3-clauses) can be followed during the operation, and define resolution trajectories. Depending on the location of trajectories in the phase diagram of the 2+p-SAT model, easy (polynomial) or hard (exponential) resolutions are generated. Three regimes are identified, depending on the ratio alpha of the 3-SAT instance to be solved. Lower sat phase: for small ratios, DPLL almost surely finds a solution in a time growing linearly with the number N of variables. Upper sat phase: for intermediate ratios, instances are almost surely satisfiable but finding a solution requires exponential time (2 ^ (N omega) with omega>0) with high probability. Unsat phase: for large ratios, there is almost always no solution and proofs of refutation are exponential. An analysis of the growth of the search tree in both upper sat and unsat regimes is presented, and allows us to estimate omega as a function of alpha. This analysis is based on an exact relationship between the average size of the search tree and the powers of the evolution operator encoding the elementary steps of the search heuristic.

cs/0401012

Hatem HADJ Kacem

Gerard Duchamp (LIFAR, LIPN), Hatem Hadj Kacem (LIFAR), Eric Laugerotte (LIFAR)

Algebraic Elimination of epsilon-transitions

13 decembre 2004

cs.SC cs.DS

We present here algebraic formulas associating a k-automaton to a k-epsilon-automaton. The existence depends on the definition of the star of matrices and of elements in the semiring k. For this reason, we present the theorem which allows the transformation of k-epsilon-automata into k-automata. The two automata have the same behaviour.

cs/0402005

Krzysztof C. Kiwiel

Krzysztof C. Kiwiel

Improved randomized selection

14 pages

PMMO-04-02

cs.DS

We show that several versions of Floyd and Rivest's improved algorithm Select for finding the $k$th smallest of $n$ elements require at most $n+\min\{k,n-k\}+O(n^{1/2}\ln^{1/2}n)$ comparisons on average and with high probability. This rectifies the analysis of Floyd and Rivest, and extends it to the case of nondistinct elements. Encouraging computational results on large median-finding problems are reported.

cs/0402019

Thom Fruehwirth

Thom Fruehwirth and Slim Abdennadher

The Munich Rent Advisor: A Success for Logic Programming on the Internet

cs.AI cs.DS

Most cities in Germany regularly publish a booklet called the {\em Mietspiegel}. It basically contains a verbal description of an expert system. It allows the calculation of the estimated fair rent for a flat. By hand, one may need a weekend to do so. With our computerized version, the {\em Munich Rent Advisor}, the user just fills in a form in a few minutes and the rent is calculated immediately. We also extended the functionality and applicability of the {\em Mietspiegel} so that the user need not answer all questions on the form. The key to computing with partial information using high-level programming was to use constraint logic programming. We rely on the internet, and more specifically the World Wide Web, to provide this service to a broad user group. More than ten thousand people have used our service in the last three years. This article describes the experiences in implementing and using the {\em Munich Rent Advisor}. Our results suggests that logic programming with constraints can be an important ingredient in intelligent internet systems.

cs/0402028

David Eppstein

David Eppstein

The lattice dimension of a graph

6 pages, 3 figures

Eur. J. Combinatorics 26(6):585-592, 2005

10.1016/j.ejc.2004.05.001

cs.DS math.CO

We describe a polynomial time algorithm for, given an undirected graph G, finding the minimum dimension d such that G may be isometrically embedded into the d-dimensional integer lattice Z^d.

cs/0402044

Sandor P. Fekete

Sandor P. Fekete and Joerg Schepers

A General Framework for Bounds for Higher-Dimensional Orthogonal Packing Problems

16 pages, 4 figures, Latex, to appear in Mathematical Methods of Operations Research

cs.DS cs.CG

Higher-dimensional orthogonal packing problems have a wide range of practical applications, including packing, cutting, and scheduling. In the context of a branch-and-bound framework for solving these packing problems to optimality, it is of crucial importance to have good and easy bounds for an optimal solution. Previous efforts have produced a number of special classes of such bounds. Unfortunately, some of these bounds are somewhat complicated and hard to generalize. We present a new approach for obtaining classes of lower bounds for higher-dimensional packing problems; our bounds improve and simplify several well-known bounds from previous literature. In addition, our approach provides an easy framework for proving correctness of new bounds.

cs/0402045

Sandor P. Fekete

Esther M. Arkin, Michael A. Bender, Sandor P. Fekete, Joseph S. B. Mitchell, and Martin Skutella

The Freeze-Tag Problem: How to Wake Up a Swarm of Robots

27 pages, 9 figures, Latex, to appear in Algorithmica. Cleaned up various parts of the paper, removed one overly technical section

cs.DS

An optimization problem that naturally arises in the study of swarm robotics is the Freeze-Tag Problem (FTP) of how to awaken a set of ``asleep'' robots, by having an awakened robot move to their locations. Once a robot is awake, it can assist in awakening other slumbering robots.The objective is to have all robots awake as early as possible. While the FTP bears some resemblance to problems from areas in combinatorial optimization such as routing, broadcasting, scheduling, and covering, its algorithmic characteristics are surprisingly different. We consider both scenarios on graphs and in geometric environments.In graphs, robots sleep at vertices and there is a length function on the edges. Awake robots travel along edges, with time depending on edge length. For most scenarios, we consider the offline version of the problem, in which each awake robot knows the position of all other robots. We prove that the problem is NP-hard, even for the special case of star graphs. We also establish hardness of approximation, showing that it is NP-hard to obtain an approximation factor better than 5/3, even for graphs of bounded degree.These lower bounds are complemented with several positive algorithmic results, including: (1) We show that the natural greedy strategy on star graphs has a tight worst-case performance of 7/3 and give a polynomial-time approximation scheme (PTAS) for star graphs. (2) We give a simple O(log D)-competitive online algorithm for graphs with maximum degree D and locally bounded edge weights. (3) We give a PTAS, running in nearly linear time, for geometrically embedded instances.

cs/0403022

Martin Ziegler

Michael N\"usken, Martin Ziegler

Fast Multipoint-Evaluation of Bivariate Polynomials

12 pages, 1 figure. To appear in Proc. 12th ESA 2004

cs.DS

We generalize univariate multipoint evaluation of polynomials of degree n at sublinear amortized cost per point. More precisely, it is shown how to evaluate a bivariate polynomial p of maximum degree less than n, specified by its n^2 coefficients, simultaneously at n^2 given points using a total of O(n^{2.667}) arithmetic operations. In terms of the input size N being quadratic in n, this amounts to an amortized cost of O(N^{0.334}) per point.

cs/0403028

Manuel Carro

Manuel Carro

An Application of Rational Trees in a Logic Programming Interpreter for a Procedural Language

LaTeX2e, 13 pages, 2 tables, 11 figures (several of them, text). Yet unpublished

cs.DS cs.LO

We describe here a simple application of rational trees to the implementation of an interpreter for a procedural language written in a logic programming language. This is possible in languages designed to support rational trees (such as Prolog II and its descendants), but also in traditional Prolog, whose data structures are initially based on Herbrand terms, but in which implementations often omit the occurs check needed to avoid the creation of infinite data structures. We provide code implementing two interpreters, one of which needs non-occurs-check unification, which makes it faster (and more economic). We provide experimental data supporting this, and we argue that rational trees are interesting enough as to receive thorough support inside the language.

cs/0403037

Sebastian Brand

Sebastian Brand and Krzysztof R. Apt

Schedulers and Redundancy for a Class of Constraint Propagation Rules

25 pages, to appear in the journal "Theory and Practice of Logic Programming"

cs.DS cs.PL

We study here schedulers for a class of rules that naturally arise in the context of rule-based constraint programming. We systematically derive a scheduler for them from a generic iteration algorithm of [Apt 2000]. We apply this study to so-called membership rules of [Apt and Monfroy 2001]. This leads to an implementation that yields a considerably better performance for these rules than their execution as standard CHR rules. Finally, we show how redundant rules can be identified and how appropriately reduced sets of rules can be computed.

cs/0403040

Fabrice Philippe

Guy Melancon, Fabrice Philippe

Generating connected acyclic digraphs uniformly at random

6 pages

cs.DM cs.DS

We describe a simple algorithm based on a Markov chain process to generate simply connected acyclic directed graphs over a fixed set of vertices. This algorithm is an extension of a previous one, designed to generate acyclic digraphs, non necessarily connected.

cs/0404028

Saju Jude Dominic

Saju Jude Dominic and G. Sajith

The Random Buffer Tree : A Randomized Technique for I/O-efficient Algorithms

13 pages with no figures, unpublished

cs.DS

In this paper, we present a probabilistic self-balancing dictionary data structure for massive data sets, and prove expected amortized I/O-optimal bounds on the dictionary operations. We show how to use the structure as an I/O-optimal priority queue. The data structure, which we call as the random buffer tree, abstracts the properties of the random treap and the buffer tree and has the same expected I/O-bounds as the buffer tree.

cs/0404036

Sandor P. Fekete

Sandor P. Fekete and Rolf Klein and Andreas Nuechter

Online Searching with an Autonomous Robot

16 pages, 8 figures, 12 photographs, 1 table, Latex, submitted for publication

cs.RO cs.DS

We discuss online strategies for visibility-based searching for an object hidden behind a corner, using Kurt3D, a real autonomous mobile robot. This task is closely related to a number of well-studied problems. Our robot uses a three-dimensional laser scanner in a stop, scan, plan, go fashion for building a virtual three-dimensional environment. Besides planning trajectories and avoiding obstacles, Kurt3D is capable of identifying objects like a chair. We derive a practically useful and asymptotically optimal strategy that guarantees a competitive ratio of 2, which differs remarkably from the well-studied scenario without the need of stopping for surveying the environment. Our strategy is used by Kurt3D, documented in a separate video.

cs/0404046

Sanjay Rana

Sanjay Rana and Mike Batty

Visualising the structure of architectural open spaces based on shape analysis

10 pages, 9 figures

International Journal of Architectural Computing, 2(1), 2004

cs.CV cs.CG cs.DS

This paper proposes the application of some well known two-dimensional geometrical shape descriptors for the visualisation of the structure of architectural open spaces. The paper demonstrates the use of visibility measures such as distance to obstacles and amount of visible space to calculate shape descriptors such as convexity and skeleton of the open space. The aim of the paper is to indicate a simple, objective and quantifiable approach to understand the structure of open spaces otherwise impossible due to the complex construction of built structures.

cs/0404058

Maggie McLoughlin

Donald E. Knuth, Frank Ruskey

Efficient coroutine generation of constrained Gray sequences

Lecture Notes in Computer Science 2635 (2004), 183--204

Knuth migration 11/2004

cs.DS

We study an interesting family of cooperating coroutines, which is able to generate all patterns of bits that satisfy certain fairly general ordering constraints, changing only one bit at a time. (More precisely, the directed graph of constraints is required to be cycle-free when it is regarded as an undirected graph.) If the coroutines are implemented carefully, they yield an algorithm that needs only a bounded amount of computation per bit change, thereby solving an open problem in the field of combinatorial pattern generation.

cs/0405006

Docteur Gregory Mounie

Pierre-Francois Dutot (ID - IMAG), Lionel Eyraud (ID - IMAG), Gr\'egory Mouni\'e (ID - IMAG), Denis Trystram (ID - IMAG)

Bi-criteria Algorithm for Scheduling Jobs on Cluster Platforms

ACM Symposium on Parallel Algorithms and Architectures (2004) 125-132

cs.DC cs.DS

We describe in this paper a new method for building an efficient algorithm for scheduling jobs in a cluster. Jobs are considered as parallel tasks (PT) which can be scheduled on any number of processors. The main feature is to consider two criteria that are optimized together. These criteria are the makespan and the weighted minimal average completion time (minsum). They are chosen for their complementarity, to be able to represent both user-oriented objectives and system administrator objectives. We propose an algorithm based on a batch policy with increasing batch sizes, with a smart selection of jobs in each batch. This algorithm is assessed by intensive simulation results, compared to a new lower bound (obtained by a relaxation of ILP) of the optimal schedules for both criteria separately. It is currently implemented in an actual real-size cluster platform.

cs/0405041

Vladimir Migunov

Vladimir V. Migunov

The modulus in the CAD system drawings as a base of developing of the problem-oriented extensions

2 pages, no figures, in Russian

cs.CE cs.DS

The concept of the "modulus" in the CAD system drawings is characterized, being a base of developing of the problem-oriented extensions. The modulus consists of visible geometric elements of the drawing and invisible parametric representation of the modelling object. The technological advantages of moduluss in a complex CAD system developing are described.

cs/0405047

Vladimir Migunov

Vladimir V. Migunov

Modular technology of developing of the problem-oriented extensions of a CAD system of reconstruction of the plant

8 pages, no figures, in Russian

cs.CE cs.DS

The modular technology of creation of the problem-oriented extensions of a CAD system is described, which was realised in a system TechnoCAD GlassX for designing of reconstruction of the plants. The modularity of the technology is expressed in storage of all parameters of the design in one element of the drawing - modulus, with automatic generation of a geometrical part of the modulus from these parameters. The common principles of the system organization of extensions developing are described: separation of the part of the design to automize in this extension, architecture of parameters in the form of the lists of objects with their properties and links to another objects, separation of common and special operations, stages of the developing, boundaries of applicability of technology.

cs/0405053

Boris D. Lubachevsky

Boris Lubachevsky and Alan Weiss

Synchronous Relaxation for Parallel Ising Spin Simulations

Extended abstract. Conference version. The full paper in preparation

15th Workshop on Parallel and Distributed Simulation, Lake Arrowhead, California, May 2001, pp.185-192

cs.DC cond-mat.mtrl-sci cs.DS physics.comp-ph

A new parallel algorithm for simulating Ising spin systems is presented. The sequential prototype is the n-fold way algorithm cite{BKL75}, which is efficient but is hard to parallelize using conservative methods. Our parallel algorithm is optimistic. Unlike other optimistic algorithms, e.g., Time Warp, our algorithm is synchronous. It also belongs to the class of simulations known as ``relaxation'' cite{CS8 hence it is named ``synchronous relaxation.'' We derive performance guarantees for this algorithm. If N is the number of PEs, then under weak assumptions we show that the number of correct events processed per unit of time is, on average, at least of order N/log(N). All communication delays, processing time, and busy waits are taken into account.

cs/0405054

Vladimir Migunov

Vladimir V. Migunov

The model of the tables in design documentation for operating with the electronic catalogs and for specifications making in a CAD system

5 pages, 4 figures, in Russian

cs.CE cs.DS

The hierarchic block model of the tables in design documentation as a part of a CAD system is described, intended for automatic specifications making of elements of the drawings, with usage of the electronic catalogs. The model is created for needs of a CAD system of reconstruction of the industrial plants, where the result of designing are the drawings, which include the specifications of different types. The adequate simulation of the specification tables is ensured with technology of storing in the drawing of the visible geometric elements and invisible parametric representation, sufficient for generation of this elements.

cs/0405055

Vladimir Migunov

Vladimir V. Migunov, Rustem R. Kafiatullov, Ilsur T. Safin

Modular technology of developing of the extensions of a CAD system. Axonometric piping diagrams. Parametric representation

8 pages, 1 figure, in Russian

cs.CE cs.DS

Applying the modular technology of developing of the problem-oriented extensions of a CAD system to a problem of automation of creating of the axonometric piping diagrams on an example of the program system TechnoCAD GlassX is described. The proximity of composition of the schemas is detected for special technological pipe lines, systems of a water line and water drain, heating, heat supply, ventilating, air conditioning. The structured parametric representation of the schemas, including properties of objects, their link, common settings, settings by default and the special links of compatibility is reviewed.

cs/0405056

Vladimir Migunov

Ilsur T. Safin, Vladimir V. Migunov, Rustem R. Kafiatullov

Modular technology of developing of the extensions of a CAD system. The axonometric piping diagrams. Common and special operations

8 pages, 7 figures, in Russian

cs.CE cs.DS

Applying the modular technology of developing of the problem-oriented extensions of a CAD system to a problem of automation of creating of the axonometric piping diagrams on an example of the program system TechnoCAD GlassX is described. The features of realization of common operations, composition and realization of special operations of a designing of the schemas of the special technological pipe lines, systems of a water line and water drain, heating, heat supply, ventilating, air conditioning are reviewed.

cs/0405057

Vladimir Migunov

Vladimir V. Migunov

Mathematical and programming toolkit of the computer aided design of the axonometric piping diagrams

3 pages, no figures, in Russian

cs.CE cs.DS

The problem of the automation of the designing of the axonometric piping diagrams include, as the minimum, manipulations with the flat schemas of three-dimensional wireframe objects (with dimension of 2,5). The specialized model, methodical and mathematical approaches are required because of large bulk of calculuss. Coordinate systems, data types, common principles of realization of operation with data and composition of the basic operations are described which are realised in the complex CAD system of the reconstruction of the plants TechnoCAD GlassX.

cs/0405058

Sandor P. Fekete

Sandor P. Fekete, Alexander Kroeller, Dennis Pfisterer, Stefan Fischer, and Carsten Buschmann

Neighborhood-Based Topology Recognition in Sensor Networks

14 pages, 6 figures, Latex, to appear in Workshop on Algorithms Aspects of Sensor Networks (ALGOSENSORS 2004)

cs.DS cs.DC

We consider a crucial aspect of self-organization of a sensor network consisting of a large set of simple sensor nodes with no location hardware and only very limited communication range. After having been distributed randomly in a given two-dimensional region, the nodes are required to develop a sense for the environment, based on a limited amount of local communication. We describe algorithmic approaches for determining the structure of boundary nodes of the region, and the topology of the region. We also develop methods for determining the outside boundary, the distance to the closest boundary for each point, the Voronoi diagram of the different boundaries, and the geometric thickness of the network. Our methods rely on a number of natural assumptions that are present in densely distributed sets of nodes, and make use of a combination of stochastics, topology, and geometry. Evaluation requires only a limited number of simple local computations.

cs/0405077

Boris D. Lubachevsky

Boris D. Lubachevsky

Fast Simulation of Multicomponent Dynamic Systems

38 pages, 9 figures

Bell Labs Technical Journal, Vol.5, No.2, April-June 2000, pp.134-156

cs.DS cond-mat.mtrl-sci cs.DC

A computer simulation has to be fast to be helpful, if it is employed to study the behavior of a multicomponent dynamic system. This paper discusses modeling concepts and algorithmic techniques useful for creating such fast simulations. Concrete examples of simulations that range from econometric modeling to communications to material science are used to illustrate these techniques and concepts. The algorithmic and modeling methods discussed include event-driven processing, ``anticipating'' data structures, and ``lazy'' evaluation, Poisson dispenser, parallel processing by cautious advancements and by synchronous relaxations. The paper gives examples of how these techniques and models are employed in assessing efficiency of capacity management methods in wireless and wired networks, in studies of magnetization, crystalline structure, and sediment formation in material science, in studies of competition in economics.

cs/0405094

Taneli Mielik\"ainen

Taneli Mielik\"ainen and Esko Ukkonen

The Complexity of Maximum Matroid-Greedoid Intersection and Weighted Greedoid Maximization

Report C-2004-2, Department of Computer Science, University of Helsinki

cs.DS

The maximum intersection problem for a matroid and a greedoid, given by polynomial-time oracles, is shown $NP$-hard by expressing the satisfiability of boolean formulas in 3-conjunctive normal form as such an intersection. The corresponding approximation problems are shown $NP$-hard for certain approximation performance bounds. Moreover, some natural parameterized variants of the problem are shown $W[P]$-hard. The results are in contrast with the maximum matroid-matroid intersection which is solvable in polynomial time by an old result of Edmonds. We also prove that it is $NP$-hard to approximate the weighted greedoid maximization within $2^{n^{O(1)}}$ where $n$ is the size of the domain of the greedoid. A preliminary version ``The Complexity of Maximum Matroid-Greedoid Intersection'' appeared in Proc. FCT 2001, LNCS 2138, pp. 535--539, Springer-Verlag 2001.

cs/0405110

Gopal Ananthraman

Gopal Ananthraman

An analysis of a bounded resource search puzzle

4 Pages

cs.DS cs.DM

Consider the commonly known puzzle, given $k$ glass balls, find an optimal algorithm to determine the lowest floor of a building of $n$ floors from which a thrown glass ball will break. This puzzle was originally posed in its original form in \cite{focs1980}and was later cited in the book \cite{algthc}. There are several internet sites that presents this puzzle and its solution to the special case of $k=2$ balls. This is the first such analysis of the puzzle in its general form. Several variations of this puzzle have been studied with applications in Network Loading \cite{cgstctl} which analyzes a case similar to a scenario where an adversary is changing the lowest floor with time. Although the algorithm specified in \cite{algthc} solves the problem, it is not an efficient algorithm. In this paper another algorithm for the same problem is analyzed. It is shown that if $m$ is the minimum number of attempts required then for $k \geq m$ we have $m = \log (n+1)$ and for $k < m$ we have, $1 + \sum_{i=1}^{k}{{m-1}\choose{i}} < n \leq \sum_{i=1}^{k}{{m}\choose{i}}$

cs/0406003

Andr\'e Kempe

Andre Kempe (1), Franck Guingne (1,2), Florent Nicart (1,2) ((1) Xerox Research Centre Europe, France, (2) Rouen University, France)

Algorithms for weighted multi-tape automata

28 pages, 7 figures, LaTeX (+ .eps)

XRCE Research Report 2004/031

cs.CL cs.DS

This report defines various operations for weighted multi-tape automata (WMTAs) and describes algorithms that have been implemented for those operations in the WFSC toolkit. Some algorithms are new, others are known or similar to known algorithms. The latter will be recalled to make this report more complete and self-standing. We present a new approach to multi-tape intersection, meaning the intersection of a number of tapes of one WMTA with the same number of tapes of another WMTA. In our approach, multi-tape intersection is not considered as an atomic operation but rather as a sequence of more elementary ones, which facilitates its implementation. We show an example of multi-tape intersection, actually transducer intersection, that can be compiled with our approach but not with several other methods that we analysed. To show the practical relavance of our work, we include an example of application: the preservation of intermediate results in transduction cascades.

cs/0406020

David Eppstein

David Eppstein

Algorithms for Drawing Media

13 pages, 11 figures

cs.DS cs.CG

We describe algorithms for drawing media, systems of states, tokens and actions that have state transition graphs in the form of partial cubes. Our algorithms are based on two principles: embedding the state transition graph in a low-dimensional integer lattice and projecting the lattice onto the plane, or drawing the medium as a planar graph with centrally symmetric faces.

cs/0406028

Manor Mendel

Yair Bartal, Bela Bollobas, Manor Mendel

Ramsey-type theorems for metric spaces with applications to online problems

Fix an error in the metadata. 31 pages, 0 figures. Preliminary version in FOCS '01. To be published in J. Comput. System Sci

J. Comput. System Sci. 72(5):890-921, 2006

10.1016/j.jcss.2005.05.008

cs.DS

A nearly logarithmic lower bound on the randomized competitive ratio for the metrical task systems problem is presented. This implies a similar lower bound for the extensively studied k-server problem. The proof is based on Ramsey-type theorems for metric spaces, that state that every metric space contains a large subspace which is approximately a hierarchically well-separated tree (and in particular an ultrametric). These Ramsey-type theorems may be of independent interest.