[1]
S. Collette and J. Iacono. Distances and shortest paths on graphs of bounded highway dimension: simple, fast, dynamic. In Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA'24), 2024. [ bib ]
Dijkstra's algorithm is the standard method for computing shortest paths on arbitrary graphs. However, it is slow for large graphs, taking at least linear time. It has been long known that for real world road networks, creating a hierarchy of well-chosen shortcuts allows fast distance and path computation, with exact distance queries seemingly being answered in logarithmic time. However, these methods were but heuristics until the work of Abraham et al. [JACM 2016], where they defined a graph parameter called highway dimension which is constant for real-world road networks, and showed that in graphs of constant highway dimension, a shortcut hierarchy exists that guarantees shortest distance computation takes O(log(U+V)) time and O(V log(U+V)) space, where U is the ratio of the smallest to largest edge, and V is the number of vertices. The problem is that they were unable to efficiently compute the hierarchy of shortcuts. Here we present a simple and efficient algorithm to compute the needed hierarchy of shortcuts in time and space O(V log(U+V)), as well as supporting updates in time O( log(U+V)).
[2]
P. Bose, S. Collette, R. Fagerberg, and S. Langerman. De-amortizing binary search trees. In Proceedings of the 39th International Colloquium on Automata, Languages and Programming (ICALP 2012), LNCS, 2012. [ bib ]
[3]
S. Collette, J. Iacono, and S. Langerman. Confluent persistence revisited. In Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA'12), pages 593--601, 2012. [ bib ]
It is shown how to enhance any data structure in the pointer model to make it confluently persistent, with efficient query and update times and limited space overhead. Updates are performed in O(logn) amortized time, and following a pointer takes O(logc logn) time where c is the in-degree of a node in the data structure. In particular, this proves that confluent persistence can be achieved at a logarithmic cost in the bounded in-degree model used widely in previous work. This is a O(n/logn)-factor improvement over the previous known transform to make a data structure confluently persistent.
[4]
G. Aloupis, J. Cardinal, S. Collette, E. D. Demaine, M. L. Demaine, M. Dulieu, R. Fabila-Monroy, V. Hart, F. Hurtado, S. Langerman, M. Saumell, C. Seara, and P. Taslakian. Matching points with things. In Proceedings of the 8th Latin American Theoretical Informatics (LATIN'10), LNCS, 2010. 12 pages. [ bib ]
[5]
G. Aloupis, J. Cardinal, S. Collette, S. Imahori, M. Korman, S. Langerman, O. Schwartz, S. Smorodinsky, and P. Taslakian. Colorful strips. In Proceedings of the 8th Latin American Theoretical Informatics (LATIN'10), LNCS, 2010. 12 pages. [ bib ]
[6]
G. Aloupis, J. Cardinal, S. Collette, S. Langerman, D. Orden, and P. Ramos. Decomposition of multiple coverings into more parts. In Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA'09), 2009. 9 pages. [ bib ]
We prove that for every centrally symmetric convex polygon Q, there exists a constant alpha such that any alpha*k-fold covering of the plane by translates of Q can be decomposed into k coverings. This improves on a quadratic upper bound proved by Pach and Toth (SoCG'07). The question is motivated by a sensor network problem, in which a region has to be monitored by sensors with limited battery lifetime.
[7]
G. Aloupis, S. Collette, M. Damian, E. Demaine, D. El-Khechen, R. Flatland, S. Langerman, J. O'Rourke, V. Pinciu, S. Ramaswami, V. Sacristan, and S. Wuhrer. Realistic reconfiguration of crystalline (and telecube) robots. In Proceedings of the Workshop on the Algorithmic Foundations of Robotics (WAFR'08), 2008. 18 pages. [ bib ]
In this paper we propose novel algorithms for reconfiguring cube-style modular robots that are composed of n identical atoms. Each atom has the shape of a unit cube and can expand/contract each face by half a unit, as well as attach/detach to faces of neighboring atoms. For universal reconfiguration, it is necessary for atoms to be arranged in 2x2x2 modules. We respect certain physical constraints: each module reaches at most unit velocity and (via expansion) can displace at most one other module. We only require one of the modules to be able to store a map of the target configuration.

Reconfiguration via our algorithms involves a total of O(n^2) such atom operations, but is performed in O(n) parallel steps. This improves on previous reconfiguration algorithms, which either use O(n^2) parallel steps or do not respect the constraints mentioned above. In fact, in the setting considered, our algorithms are worst-case optimal. A further advantage by our algorithmsis that reconfiguration can take place within the union of the source and target configurations.

[8]
P. Bose, P. Carmi, S. Collette, and M. Smid. On the stretch factor of convex delaunay graphs. In Proceedings of the International Symposium on Algorithms and Computation (ISAAC 2008), volume 5369 of LNCS, 2008. 12 pages. [ bib ]
Let C be a compact and convex set in the plane that contains the origin in its interior, and let S be a finite set of points in the plane. The Delaunay graph DG_C(S) of S is defined to be the dual of the Voronoi diagram of S with respect to the convex distance function defined by C. We prove that DG_C(S) is a t-spanner for S, for some constant t that depends only on the shape of the set C. Thus, for any two points p and q in S, the graph DG_C(S) contains a path between p and q whose Euclidean length is at most t times the Euclidean distance between p and q.
[9]
G. Aloupis, S. Collette, E. D. Demaine, S. Langerman, V. Sacristan, and S. Wuhrer. Reconfiguration of cube-style modular robots using O(log n) parallel moves. In Proceedings of the International Symposium on Algorithms and Computation (ISAAC 2008), volume 5369 of LNCS, 2008. 12 pages. [ bib ]
We consider a model of reconfigurable robot, introduced and prototyped by the robotics community. The robot consists of independently manipulable unit-square atoms that can extend/contract arms on each side and attach/detach from neighbors. The optimal worst-case number of sequential moves required to transform one connected configuration to another was shown to be Theta(n) at ISAAC 2007. However, in principle, atoms can all move simultaneously. We develop a parallel algorithm for reconfiguration that runs in only O(log n) parallel steps, although the total number of operations increases slightly to Theta(n log n). The result is the first (theoretically) almost-instantaneous universally reconfigurable robot built from simple units.
[10]
G. Aloupis, J. Cardinal, S. Collette, S. Langerman, and S. Smorodinsky. Coloring geometric range spaces. In Proceedings of the 8th Latin American Theoretical Informatics (LATIN'08), volume 4957 of LNCS, 2008. 12 pages. [ bib | DOI ]
We study several coloring problems for geometric range-spaces. In addition to their theoretical interest, some of these problems arise in sensor networks. Given a set of points in R^2 or R^3, we want to color them such that every region of a certain family (e.g., every disk containing at least a certain number of points) contains points of many different colors. In this paper, we think of the number of colors and the number of points as functions of k. Obviously, for a fixed k using k colors, it is not always possible to ensure that every region containing k points has all colors present. Thus, we introduce two types of relaxations: either we allow the number of colors to increase to c(k), or we require that the number of points in each region increases to p(k).

Symmetrically, given a finite set of regions in R^2 or R^3, we want to color them such that every point covered by a sufficiently large number of regions is contained in regions of k different colors. This requires the number of covering regions or the number of allowed colors to be greater than k.

The goal of this paper is to bound these two functions for several types of region families, such as halfplanes, halfspaces, disks and pseudo-disks. We improve and generalize previous results of Pach, Tardos and Toth on decompositions of space coverings.

[11]
S. Collette, V. Dujmović, J. Iacono, S. Langerman, and P. Morin. Distribution-sensitive point location in convex subdivisions. In Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA'08), 2008. 11 pages. [ bib ]
A data structure is presented for point location in convex planar subdivisions when the distribution of queries is known in advance. The data structure has an expected query time that differs from the optimal one by only lower order terms in the linear comparison tree model.
[12]
G. Aloupis, S. Collette, M. Damian, E. D. Demaine, R. Flatland, S. Langerman, J. O'Rourke, S. Ramaswami, V. Sacristan, and S. Wuhrer. Linear reconfiguration of cube-style modular robots. In Proceedings of the International Symposium on Algorithms and Computation (ISAAC 2007), volume 4835 of LNCS, 2007. 14 pages. [ bib | DOI ]
In this paper we propose a novel algorithm that, given a source robot S and a target robot T, reconfigures S into T. Both S and T are robots composed of n atoms arranged in 2 x 2 x 2 meta-modules. The reconfiguration involves a total of O(n) atom operations (expand, contract, attach, detach) and is performed in O(n) parallel steps. This improves on previous reconfiguration algorithms, which require O(n^2) parallel steps. Our algorithm is in place; that is, the reconfiguration takes place within the union of the bounding boxes of the source and target robots. We show that the algorithm can also be implemented in a synchronous, distributed fashion.
[13]
S. Collette, L. Cucu, and J. Goossens. Algorithm and complexity for the global scheduling of sporadic tasks on multiprocessors with work-limited parallelism. In Proceedings of the 15th International Conference on Real-Time and Network systems (RTNS'2007), 2007. 6 pages. [ bib ]
We investigate the global scheduling of sporadic, implicit deadline, real-time task systems on identical multiprocessor platforms. We provide a task model which integrates work-limited job parallelism. For work-limited parallelism, we prove that the time-complexity of deciding if a task set is feasible is linear relatively to the number of (sporadic) tasks for a fixed number of processors. Based on this proof, we propose an optimal scheduling algorithm. Moreover, we provide an exact feasibility utilization bound.
[14]
G. Aloupis, J. Cardinal, S. Collette, and S. Langerman. Lumines strategies. In Proceedings of the 5th International Conference on Computers and Games (CG 2006), volume 4630 of LNCS, pages 190--199, 2007. [ bib | DOI | .pdf ]
We analyze a new popular video-game called Lumines, which was developed by Sony for the PSP platform. It involves a sequence of bichromatic 2x2 blocks that fall in a grid and must be shifted or rotated by the player before they land. Patterns of monochromatic 2x2 blocks in the terrain are regularly deleted. The primary goal is to contain the terrain within a fixed height and, if possible, clear the grid. We deal with questions such as the following: Can the game be played indefinitely? Can all terrains be eliminated? We examine how answers to these questions depend on the size of the grid and the rate at which blocks are deleted.
[15]
S. Collette, J.-F. Raskin, and F. Servais. On the symbolic computation of the hardest configurations of the rush hour game. In Proceedings of the 5th International Conference on Computers and Games (CG 2006), volume 4630 of LNCS, pages 220--233, 2007. [ bib | DOI | .pdf ]
Rushhour is a sliding block game where blocks represent cars stuck in a traffic jam on a 6x6 board. The goal of the game is to allow one of the cars (the target car) to exit this traffic jam by moving the other cars out of its way. In this paper, we study the problem of finding difficult initial configurations for this game. An initial configuration is difficult if the number of car moves necessary to exit the target car is high. To solve the problem, we model the game in propositional logic and we apply symbolic model-checking techniques to study the huge graph of configurations that underlies the game. On the positive side, we show that this huge graph (containing 3.6x10^10 vertices) can be completely analyzed using symbolic model-checking techniques with reasonable computing resources. We have classified every possible initial configuration of the game according to the length of its shortest solution. On the negative side, we prove a general theorem that shows some limits of symbolic model-checking methods for board games. This result explains why some natural modeling of board games leads to the explosion of the size of symbolic data-structures.