Algorithm Theory — SWAT 2002: 8th Scandinavian Workshop on Algorithm Theory Turku, Finland, July 3–5, 2002 Proceedings

455 Pages·2002·4.98 MB·English

by  Torben Hagerup

Springer LINK: Lecture Notes in Computer Science

M. Penttonen, E. Meineche Schmidt (Eds.):
Algorithm Theory - SWAT 2002
8th Scandinavian Workshop on Algorithm Theory, Turku,
Finland, July 3-5, 2002. Proceedings

LNCS 2368

Ordering Information

Table of Contents
Title pages in PDF (9 KB)
In Memory of Timo Raita in PDF (14 KB)
Preface in PDF (15 KB)
Organization in PDF (20 KB)
Table of Contents in PDF (45 KB)
Invited Speakers
An Efficient Quasidictionary
Torben Hagerup and Rajeev Raman
LNCS 2368, p. 1 ff.
Abstract | Full article in PDF (217 KB)
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (1 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
Combining Pattern Discovery and Probabilistic Modeling in Data Mining
Heikki Mannila
LNCS 2368, p. 19
Abstract | Full article in PDF (33 KB)
Scheduling
Time and Space Efficient Multi-method Dispatching
Stephen Alstrup, Gerth Stølting Brodal, Inge Li Gørtz, and Theis Rauhe
LNCS 2368, p. 20 ff.
Abstract | Full article in PDF (160 KB)
Linear Time Approximation Schemes for Vehicle Scheduling
John E. Augustine and Steven S. Seiden
LNCS 2368, p. 30 ff.
Abstract | Full article in PDF (160 KB)
Minimizing Makespan for the Lazy Bureaucrat Problem
Clint Hepner and Cliff Stein
LNCS 2368, p. 40 ff.
Abstract | Full article in PDF (149 KB)
A PTAS for the Single Machine Scheduling Problem with Controllable Processing Times
Monaldo Mastrolilli
LNCS 2368, p. 51 ff.
Abstract | Full article in PDF (154 KB)
Computational Geometry
Optimum Inapproximability Results for Finding Minimum Hidden Guard Sets in
Polygons and Terrains
Stephan Eidenbenz
LNCS 2368, p. 60 ff.
Abstract | Full article in PDF (138 KB)
Simplex Range Searching and Nearest Neighbors of a Line Segment in 2D
Partha P. Goswami, Sandip Das, and Subhas C. Nandy
LNCS 2368, p. 69 ff.
Abstract | Full article in PDF (208 KB)
Adaptive Algorithms for Constructing Convex Hulls and Triangulations of Polygonal
Chains
Christos Levcopoulos, Andrzej Lingas, and Joseph S.B. Mitchell
LNCS 2368, p. 80 ff.
Abstract | Full article in PDF (149 KB)
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (2 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
Exact Algorithms and Approximation Schemes for Base Station Placement Problems
Nissan Lev-Tov and David Peleg
LNCS 2368, p. 90 ff.
Abstract | Full article in PDF (174 KB)
A Factor-2 Approximation for Labeling Points with Maximum Sliding Labels
Zhongping Qin and Binhai Zhu
LNCS 2368, p. 100 ff.
Abstract | Full article in PDF (153 KB)
Optimal Algorithm for a Special Point-Labeling Problem
Sasanka Roy, Partha P. Goswami, Sandip Das, and Subhas C. Nandy
LNCS 2368, p. 110 ff.
Abstract | Full article in PDF (171 KB)
Random Arc Allocation and Applications
Peter Sanders and Berthold Vöcking
LNCS 2368, p. 121 ff.
Abstract | Full article in PDF (159 KB)
On Neighbors in Geometric Permutations
Micha Sharir and Shakhar Smorodinsky
LNCS 2368, p. 131 ff.
Abstract | Full article in PDF (152 KB)
Graph Algorithms
Powers of Geometric Intersection Graphs and Dispersion Algorithms
Geir Agnarsson, Peter Damaschke, and Magnús M. Halldórsson
LNCS 2368, p. 140 ff.
Abstract | Full article in PDF (179 KB)
Efficient Data Reduction for DOMINATING SET: A Linear Problem Kernel for the
Planar Case
Jochen Alber, Michael R. Fellows, and Rolf Niedermeier
LNCS 2368, p. 150 ff.
Abstract | Full article in PDF (242 KB)
Planar Graph Coloring with Forbidden Subgraphs: Why Trees and Paths Are Dangerous
Hajo Broersma, Fedor V. Fomin, Jan Kratochvíl, and Gerhard J. Woeginger
LNCS 2368, p. 160 ff.
Abstract | Full article in PDF (158 KB)
Approximation Hardness of the Steiner Tree Problem on Graphs
Miroslav Chlebík and Janka Chlebíková
LNCS 2368, p. 170 ff.
Abstract | Full article in PDF (146 KB)
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (3 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
The Dominating Set Problem Is Fixed Parameter Tractable for Graphs of Bounded Genus
J. Ellis, H. Fan, and Michael R. Fellows
LNCS 2368, p. 180 ff.
Abstract | Full article in PDF (175 KB)
The Dynamic Vertex Minimum Problem and Its Application to Clustering-Type
Approximation Algorithms
Harold N. Gabow and Seth Pettie
LNCS 2368, p. 190 ff.
Abstract | Full article in PDF (131 KB)
A Polynomial Time Algorithm to Find the Minimum Cycle Basis of a Regular Matroid
Alexander Golynski and Joseph D. Horton
LNCS 2368, p. 200 ff.
Abstract | Full article in PDF (160 KB)
Approximation Algorithms for Edge-Dilation -Center Problems
Jochen Könemann, Yanjun Li, Ojas Parekh, and Amitabh Sinha
LNCS 2368, p. 210 ff.
Abstract | Full article in PDF (176 KB)
Forewarned Is Fore-Armed: Dynamic Digraph Connectivity with Lookahead Speeds Up a
Static Clustering Algorithm
Sarnath Ramnath
LNCS 2368, p. 220 ff.
Abstract | Full article in PDF (137 KB)
Improved Algorithms for the Random Cluster Graph Model
Ron Shamir and Dekel Tsur
LNCS 2368, p. 230 ff.
Abstract | Full article in PDF (187 KB)
-List Vertex Coloring in Linear Time
San Skulrattanakulchai
LNCS 2368, p. 240 ff.
Abstract | Full article in PDF (145 KB)
Robotics
Robot Localization without Depth Perception
Erik D. Demaine, Alejandro López-Ortiz, and J. Ian Munro
LNCS 2368, p. 249 ff.
Abstract | Full article in PDF (189 KB)
Online Parallel Heuristics and Robot Searching under the Competitive Framework
Alejandro López-Ortiz and Sven Schuierer
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (4 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
LNCS 2368, p. 260 ff.
Abstract | Full article in PDF (159 KB)
Analysis of Heuristics for the Freeze-Tag Problem
Marcelo O. Sztainberg, Esther M. Arkin, Michael A. Bender, and Joseph S.B. Mitchell
LNCS 2368, p. 270 ff.
Abstract | Full article in PDF (175 KB)
Approximation Algorithms
Approximations for Maximum Transportation Problem with Permutable Supply Vector
and Other Capacitated Star Packing Problems
Esther M. Arkin, Refael Hassin, Shlomi Rubinstein, and Maxim Sviridenko
LNCS 2368, p. 280 ff.
Abstract | Full article in PDF (150 KB)
All-Norm Approximation Algorithms
Yossi Azar, Leah Epstein, Yossi Richter, and Gerhard J. Woeginger
LNCS 2368, p. 288 ff.
Abstract | Full article in PDF (147 KB)
Approximability of Dense Instances of NEAREST CODEWORD Problem
Cristina Bazgan, W. Fernandez de la Vega, and Marek Karpinski
LNCS 2368, p. 298 ff.
Abstract | Full article in PDF (152 KB)
Data Communication
Call Control with Rejections
R. Sai Anand, Thomas Erlebach, Alexander Hall, and Stamatis Stefanakos
LNCS 2368, p. 308 ff.
Abstract | Full article in PDF (95 KB)
On Network Design Problems: Fixed Cost Flows and the Covering Steiner Problem
Guy Even, Guy Kortsarz, and Wolfgang Slany
LNCS 2368, p. 318 ff.
Abstract | Full article in PDF (164 KB)
Packet Bundling
Jens S. Frederiksen and Kim S. Larsen
LNCS 2368, p. 328 ff.
Abstract | Full article in PDF (148 KB)
Algorithms for the Multi-constrained Routing Problem
Anuj Puri and Stavros Tripakis
LNCS 2368, p. 338 ff.
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (5 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
Abstract | Full article in PDF (178 KB)
Computational Biology
Computing the Threshold for -Gram Filters
Juha Kärkkäinen
LNCS 2368, p. 348 ff.
Abstract | Full article in PDF (173 KB)
On the Generality of Phylogenies from Incomplete Directed Characters
Itsik Pe'er, Ron Shamir, and Roded Sharan
LNCS 2368, p. 358 ff.
Abstract | Full article in PDF (193 KB)
Data Storage and Manipulation
Sorting with a Forklift
M.H. Albert and M.D. Atkinson
LNCS 2368, p. 368 ff.
Abstract | Full article in PDF (117 KB)
Tree Decompositions with Small Cost
Hans L. Bodlaender and Fedor V. Fomin
LNCS 2368, p. 378 ff.
Abstract | Full article in PDF (166 KB)
Computing the Treewidth and the Minimum Fill-in with the Modular Decomposition
Hans L. Bodlaender and Udi Rotics
LNCS 2368, p. 388 ff.
Abstract | Full article in PDF (164 KB)
Performance Tuning an Algorithm for Compressing Relational Tables
Jyrki Katajainen and Jeppe Nejsum Madsen
LNCS 2368, p. 398 ff.
Abstract | Full article in PDF (147 KB)
A Randomized In-Place Algorithm for Positioning the Element in a Multiset
Jyrki Katajainen and Tomi A. Pasanen
LNCS 2368, p. 408 ff.
Abstract | Full article in PDF (165 KB)
Paging on a RAM with Limited Resources
Tony W. Lai
LNCS 2368, p. 418 ff.
Abstract | Full article in PDF (105 KB)
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (6 of 7) [9/30/2002 10:21:43 PM]
Springer LINK: Lecture Notes in Computer Science
An Optimal Algorithm for Finding NCA on Pure Pointer Machines
A. Dal Palú, E. Pontelli, and D. Ranjan
LNCS 2368, p. 428 ff.
Abstract | Full article in PDF (173 KB)
Amortized Complexity of Bulk Updates in AVL-Trees
Eljas Soisalon-Soininen and Peter Widmayer
LNCS 2368, p. 439 ff.
Abstract | Full article in PDF (139 KB)
Author Index
LNCS 2368, p. 449 ff.
Author Index in PDF (18 KB)
Online publication: June 21, 2002
[email protected]
© Springer-Verlag Berlin Heidelberg 2002
http://buffy.lib.unimelb.edu.au:2150/link/service/series/0558/tocs/t2368.htm (7 of 7) [9/30/2002 10:21:43 PM]
An Efficient Quasidictionary
Torben Hagerup1 and Rajeev Raman2(cid:1)
1 Institut fu¨r Informatik, Johann Wolfgang Goethe-Universit¨at Frankfurt,
D–60054 Frankfurt am Main. [email protected]
2 Department of Maths and Computer Science, University of Leicester,
Leicester LE1 7RH, UK. [email protected]
Abstract. We define a quasidictionary to be a data structure that
supports the following operations: check-in(v) inserts a data item v
and returns a positive integer tag to be used in future references to v;
check-out(x)deletesthedataitemwithtagx;access(x)inspectsand/or
modifies the data item with tag x. A quasidictionary is similar to a
dictionary, the difference being that the names identifying data items
are chosen by the data structure rather than by its user. We describe a
deterministic quasidictionary that executes the operations check-in and
accessinconstanttimeandcheck-outinconstantamortizedtime,works
inlinearspace,andusesonlytagsboundedbythemaximumnumberof
dataitemsstoredsimultaneouslyinthequasidictionarysinceitwaslast
empty.
1 Introduction
Many data structures for storing collections of elements and executing certain
operations on them have been developed. For example, the red-black tree [14]
supports the operations insert, delete, and access, among others, and the Fi-
bonacci heap [10] supports such operations as insert, decrease, and extractmin.
An element is typically composed of a number of fields, each of which holds a
value.Manycommonoperationsoncollectionsofelementslogicallypertaintoa
specificelementamongthosecurrentlystored.E.g.,thetaskofadeleteoperation
is to remove an element from the collection, and that of a decrease operation is
to lower the value of a field of a certain element. Therefore the question arises
of how a user of a data structure can refer to a specific element among those
present in the data structure.
Theelementsstoredinared-blacktreeallcontainadistinguishedkeydrawn
from some totally ordered set, and the tree is ordered with respect to the keys.
In some cases, it suffices to specify an element to be deleted, say, through its
key. If several elements may have the same key, however, this approach is not
usable, as it may not be immaterial which of the elements with a common key
gets deleted. Even when keys are unique, specifying an element to be deleted
from a Fibonacci heap through its key is not a good idea, as Fibonacci heaps
(cid:1) Supported in part by EPSRC grant GR L/92150.
M.PenttonenandE.MeinecheSchmidt(Eds.):SWAT2002,LNCS2368,pp.1–18,2002.
(cid:1)c Springer-VerlagBerlinHeidelberg2002
2 T. Hagerup and R. Raman
do not support (efficient) searching: Locating the relevant key may involve the
inspectionofessentiallyalloftheelementsstored,anunacceptableoverhead.In
stillothercases,suchaswithfingertrees[5,17],eventhoughreasonablyefficient
search is available, it may be possible to execute certain operations such as
deletions faster if one already knows “where to start”.
For these reasons, careful specifications of data-structure operations such as
delete state that one of their arguments, rather than being the element to be
operated on, is a pointer to that element. Several interpretations of the exact
meaning of this are possible. In their influential textbook, Cormen et al. use the
convention that elements are actually stored “outside of” the data structures,
the latter storing only pointers to the elements [6, Part III, Introduction]. Thus
insertanddeleteoperationsaliketakeapointertoanelementastheirargument.
In contrast, the convention employed by the LEDA library is that (copies of)
elements are stored “inside” the data structures, and that an insertion of an
element returns a pointer (a “dependent item”, in LEDA parlance) to be used
in future references to the element [19, Section 2.2].
The method employed by Cormen et al. can have its pitfalls. Consider, e.g.,
the code proposed for the procedure Binomial-Heap-Decrease-Key in [6,
Section 20.2] and note that the “bubbling up” step repeatedly exchanges the
key fields and all satellite fields of two nodes y and z, in effect causing y and z
to refer to different elements afterwards. Because of this, repeated calls such as
Binomial-Heap-Decrease-Key(H,x,k ); Binomial-Heap-Decrease-Key
1
(H,x,k ), despite their appearance, may not access the same logical element.
2
Indeed, as binomial heaps do not support efficient searching, it will not be easy
forausertogetholdofvalidargumentsxtouseincallsoftheformBinomial-
Heap-Decrease-Key(H,x,k). One might think that this problem could be
solvedbypreservingthekey andsatellitefieldsofthenodesy andz andinstead
exchanging their positions within the relevant binomial tree. Because of the
high degrees of some nodes in binomial trees, however, this would ruin the time
bounds established for the Binomial-Heap-Decrease-Key operation.
Presumably in recognition of this problem, in the second edition of their
book, Cormen et al. include a discussion of so-called handles [7, Section 6.5].
One kind of handle, which we might call an inward handle, is a pointer from an
element of an application program to its representation in a data structure in
which,conceptually,itisstored.Theinwardhandlehasacorrespondingoutward
handle that points in the opposite direction. Whenever the representation of an
element is moved within a data structure, its outward handle is used to locate
and update the corresponding inward handle. While this solution is correct, it
is not modular, in that the data structure must incorporate knowledge of the
applicationprogramthatusesit.Itcanbearguedthatthisgoesagainstcurrent
trends in software design.
A solution that does not suffer from this drawback can be obtained by em-
ploying the LEDA convention described above and introducing one more level
of indirection: The pointer supplied by the user of a binomial heap would then
point not into the heap itself, but to an auxiliary location that contains the
An Efficient Quasidictionary 3
actualpointerintotheheapandisupdatedappropriatelywhenevertheelement
designated moves within the heap.
In the following, we adopt the LEDA convention and assume that every
insertion of an element into a data structure returns a pointer to be used in
future references to the element. The pointer can be interpreted as a positive
integer,whichwewillcallthetag oftheelement.Ateveryinsertionofanelement,
thedatastructuremusttherefore“invent”asuitabletagandhandittotheuser,
whomaysubsequentlyaccesstheelementanarbitrarynumberoftimesthrough
its tag. Eventually the user may delete the element under consideration, thus in
effect returning its tag to the data structure for possible reuse. During the time
interval in which a user is allowed to access some element through a tag, we say
that the tag is in use. When the tag is not in use, it is free. Fig. 1 contrasts the
solution using handles with the one based on tags.
Application Data structure Application Data structure
handles
tags
(a) (b)
Fig.1.Theinterplaybetweenanapplicationandadatastructurebasedon(a)handles
and (b) tags.
It might seem that the only constraint that a data structure must observe
when “inventing” a tag is that the tag should not already be in use. This con-
straint can easily be satisfied by maintaining the set of free tags in a linked list:
When a new tag is needed, the first tag on the free list is deleted from the list
and put into use, and a returned tag is inserted at the front of the list. In gen-
eral,however,adatastructurehasclosetonocontroloverwhichtagsareinuse.
In particular, it may happen that at some point, it contains only few elements,
but that these have very large tags. Recall that the purpose of a tag is to allow
efficient access to an element stored in the data structure. The straightforward
way to realize this is to store pointers to elements inside the data structure in
a tag array indexed by tag values. Now, if some tags are very large (compared
to the current number of elements), the tag array may have to be much bigger
than the remaining parts of the data structure, putting any bounds established
for its space consumption in jeopardy.
In his discussion of adding the delete operation to priority queues that lack
it, Thorup [23, Section 2.3] proposes the use of tags (called “identifiers”) and a
tag array (called “D”). He recognizes the problem that identifiers may become
toobigforthecurrentnumberofelements.Thesolutionthatheputsforwardto