Dynamic Streaming Algorithms for Geometric Independent Set
Abstract
We present the first space-efficient, fully dynamic streaming algorithm for computing a constant-factor approximation of the maximum independent set size of axis-aligned rectangles in two dimensions. For an arbitrarily small constant , our algorithm obtains an approximation and requires space and update time with high probability, assuming that coordinates are integers bounded by . We also obtain a similar result for fat objects in any constant dimension. This extends recent non-streaming algorithms by Bhore and Chan from SODA’25, and also greatly extends previous streaming results, which were limited to special types of geometric objects such as one-dimensional intervals and unit disks.
Keywords and phrases:
Geometric Independent Set, Dynamic Streaming AlgorithmsCopyright and License:
2012 ACM Subject Classification:
Theory of computation Computational geometryEditors:
Pat Morin and Eunjin OhSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
In this paper, we study dynamic streaming algorithms for a fundamental geometric optimization problem: maximum independent set (MIS) of geometric intersection graphs. Given a set of objects in dimensions, the problem is to compute a maximum-cardinality subset of independent (i.e., pairwise-disjoint) objects. Exact geometric MIS is NP-hard even for unit squares111 Throughout this paper, all squares and rectangles are axis-aligned by default. in 2D, and there has been a rich body of work on approximation algorithms [33, 25, 26, 16, 19, 27, 22]. The dynamic version of the problem (maintaining an approximate solution under insertions and deletions of objects in ) has also gained much attention in the last few years [32, 6, 10, 13, 8].
In particular, MIS for rectangles in 2D has been extensively studied. Early algorithms, based on simple divide-and-conquer, achieved logarithmic approximation ratios [2, 37, 41, 17, 5]. For -approximation, Adamaszek, Har-Peled, and Weise [1] obtained a quasi-PTAS with running time , which was subsequently improved to by Chuzhoy and Ene [21]. For polynomial-time results, Chalermsook and Chuzhoy [14] obtained an -approximation algorithm via LP rounding, and in a major breakthrough, Mitchell [39] obtained the first -approximation algorithm, running in time, via dynamic programming (DP). The approximation ratio was subsequently improved to for any constant by Gálvez, Khan, Mari, Mömke, Pittu, and Wiese [31, 30]. Recently, the running time has also been improved to for any constant by Bhore and Chan [8], with approximation ratio dependent on (polynomially); if only an approximate size is desired, the time bound can be further improved to . With the static time bound reduced to near linear, one can next turn to the question of efficient dynamic algorithms. Indeed, Bhore and Chan showed that their static algorithm can be dynamized to obtain the first fully dynamic, constant-approximation algorithm, with amortized update time.
For fat objects in any constant dimension , PTASes were known [33, 16, 25], but the running time is high (). For faster algorithms, a simple greedy strategy gives an -approximation in quadratic time [25], and Bhore and Chan [7] recently obtained an improved -time, -approximation algorithm. Bhore and Chan [8] also obtained fully dynamic -approximation algorithms with amortized update time. For disks in specifically, polylogarithmic amortized update time is also known [6, 7].
Meanwhile, streaming algorithms for geometric optimization problems also have a rich history. The dynamic streaming model, allowing streams of updates (both insertions and deletions), is also known as the turnstile model (viewing insertions/deletions as incrementing/ decrementing the multiplicity of an element – we assume that the multiplicity of each element is nonnegative). We seek algorithms that use one pass and small (sublinear) space. Typically, one needs to assume that input points lie in a bounded integer universe222 denotes . , and allow (Monte Carlo) randomization. For the streaming version of MIS, it is more natural to consider outputting an approximate size rather than the solution itself (since the MIS itself may have linear size).
Indyk [35] initiated the study of dynamic streaming algorithms for geometric problems, and considered basic problems such as Euclidean minimum spanning tree (EMST), min-weight matching, facility location, and -median. Follow-up works investigated -clustering [11, 29, 34], facility location [24], maximum cut [29, 38, 20], EMST [28], geometric Steiner forest [23], width and -kernels [3, 18], etc.
Streaming algorithms for geometric MIS, however, have received relatively limited success. Cabello and Pérez-Lantero [12] obtained tight approximation ratio for MIS of 1D intervals in insertion-only streams. Bakshi, Chepurko, and Woodruff [4] extended their result to fully dynamic (turnstile) streams, and also gave a dynamic streaming algorithm with polylogarithmic space for MIS of weighted unit disks in 2D. Bhore, Klute, and Oostveen [9] gave a 4-approximate insertion-only streaming algorithm for axis-aligned unit-height rectangles using space, where denotes the size of the MIS (which could be large). They also showed that for line segments, constant-approximation algorithms require linear space even for insertion-only streams. The above lines of work raise the following natural question:
“Do there exist fully dynamic streaming -approximation algorithms with sublinear space and update time for MIS for rectangles, or other types of geometric objects (more general than 1D intervals, 2D unit-height rectangles, and 2D unit disks)?”
New results.
We answer this question in the affirmative by presenting the first space-efficient, fully dynamic streaming -approximation algorithm for MIS for rectangles in the plane. Specifically, our algorithm computes an -approximation of the optimal size with space and update time w.h.p.,333 With high probability, i.e., probability for an arbitrarily large constant . where coordinates are in . In particular, for polynomially bounded universe size , the space and update time is (after adjusting by a constant factor).
We also obtain a similar result for (unweighted and weighted) fat objects in any constant dimension ; in particular, this is new even for arbitrary-radii disks in the plane. Here, our algorithm computes an -approximation of the optimal size with space and update time w.h.p., assuming that the objects are contained in and have diameter (and weights are in ).
Techniques.
Our algorithms are based on Bhore and Chan’s recent dynamic algorithms in the non-streaming setting [8]. Although most dynamic data structures do not adapt well to the streaming model and inherently require linear space or worse, we show that Bhore and Chan’s approach does, luckily! Their approach for MIS for rectangles can be viewed as a combination of the old divide-and-conquer method [2] with Mitchell’s constant-approximation DP-based algorithm [39]. More precisely, they used a -way divide-and-conquer to reduce the problem to special subproblems in which the input rectangles are stabbable by horizontal and vertical lines. The approximation ratio increases by an factor, which is constant if we choose . They observed that for these special subproblems, one can round the input to reduce the input size to , while increasing the approximation ratio by at most a constant; when the input size is this small, one can afford to run Mitchell’s polynomial-time approximation algorithm as a black box.
It turns out that the rounding trick is a perfect fit for dynamic streaming. The divide-and-conquer part, however, requires rethinking. We provide a new interpretation of the divide-and-conquer, by directly assigning input rectangles to levels of the recursion (this is possible due to the bounded integer universe assumption, with factors instead of ); this simpler interpretation actually helps understand Bhore and Chan’s algorithm better. To achieve sublinear space, we cannot afford to solve all subproblems across a level. Rather, we estimate the answer by taking a small random sample of the subproblems (the idea of using random sampling to approximate a sum appeared already in one version of Bhore and Chan’s static algorithm [8], but not dynamic). In the dynamic setting, the right sampling rate is not known ahead of time. Our idea is to try all sampling rates (powers of 2) simultaneously. However, for sampling rates that are too large, the space usage would be too large. We resolve this issue by hashing to a small universe. This ensures that space is kept small for all sampling rates, and at the same time, for the right sampling rate, collision is likely avoided. We remark that sampling and hashing are both commonly used in the streaming literature, but we will keep our presentation largely self-contained, to make it accessible to computational geometers without prior background on streaming.
MIS for fat objects can be solved in a similar way, using shifted quadtrees for the divide-and-conquer part.
2 Preliminaries on Streaming
We begin by describing a key tool on dynamic streaming that we need. We formulate it in a general form, as stated in Theorem 1 below (even though the ideas in the proof may not be new to experts on streaming, our formulation will make applications easier).
The setup is roughly the following: we have a collection of subproblems, where each input object is assigned to one subproblem (a substream). Each subproblem individually admits an efficient dynamic streaming algorithm. We want to approximate the sum of the answers to these subproblems, subject to a stream of updates (insertions and deletions of objects), assuming that answers to nonempty subproblems lie in a bounded range . Obtaining sublinear space is a challenge, because we cannot afford to explicitly store the answers to all subproblems.
Theorem 1.
Let be any function that maps sets to and satisfies the following two properties:
-
iff ;
-
there is a dynamic streaming algorithm for maintaining under insertions and deletions of objects in with space and time w.h.p., where .
Then we can design a dynamic streaming algorithm for maintaining a -approximation of , for a collection of sets , with space and time per update (insertion/deletion of an object to for a given ), where , w.h.p.
Before proving the theorem, we first consider a special case stated in the lemma below: when the number of nonempty subproblems is small, we can actually maintain the sum exactly. The precise statement is a little subtle, since the number of nonempty subproblems may vary over time as objects are inserted and deleted: at times when the number is larger than the threshold , the maintained answer may not be correct, but when the number gets back to below , the maintained answer would become correct again. The lemma is proved by a simple bucketing approach using pairwise-independent hash functions, with buckets.
Lemma 2.
Let be any function that maps sets to numbers and satisfies the following two properties:
-
iff ;
-
there is a dynamic streaming algorithm for maintaining under insertions and deletions of objects in with space and time w.h.p., where .
Let be a parameter. Then we can design a dynamic streaming algorithm for maintaining for a collection of sets , with space and time per update (insertion/deletion of an object to for a given ), where . The algorithm is correct w.h.p. when . Furthermore, this condition can be tested w.h.p. with the same space and time.
Proof.
Let be a random function chosen from a pairwise independent hash family, for ; by standard constructions (e.g. [40, Theorem 8.16]), can be represented using space.
Our streaming algorithm is simple: for each , we use the given algorithm to maintain for the set
i.e., when we insert/delete an object in , we compute and then insert/delete that object in using algorithm . Finally, let
and when , we output
For correctness, we discuss the two cases. Suppose . We claim that (and trivially) with probability at least . To see this, observe that when there are no colliding pairs, i.e., no pairs with , , and . The expected number of colliding pairs is at most . By Markov’s inequality, the probability that there is a colliding pair is less than .
Conversely, suppose . We claim that with probability at least . To see this, pick nonempty subsets . By the same argument as above, with probability at least , there are no colliding pairs among these nonempty subsets , implying .
The error probability is bounded by a constant, but can be lowered by running logarithmically many independent copies of the algorithm and taking the majority of the answers.
Note that alternatively, the above condition can be tested by directly applying known techniques for sampling elements (an “-sampler”) in a turnstile stream [28, 36] (viewing an insertion/deletion in as incrementing/decrementing the multiplicity of ). The proof above may be viewed as an adaptation or extension of such techniques.
We now reduce the general case to the special case by random sampling, using logarithmically many random subsets with different sampling rates. Chebyshev’s inequality shows that the sum of a random subset approximates the overall sum, assuming pairwise independence.
Lemma 3.
Let , where . Let be a random subset of such that for each , , and the events “” over all are pairwise independent. For , if , then gives a -approximation of with probability .
Proof.
Let , where denotes the Iverson bracket. Then , and by pairwise independence, . By Chebyshev’s inequality, .
Proof of Theorem 1.
For each , let be a random subset of with sampling rate , where the events “” are pairwise independent. By standard constructions (e.g. [40, Theorem 8.16]), such a subset can be represented using space (so that we can tell if a given index is in in time).
We will apply the algorithm in Lemma 2 to try to maintain
with for a sufficiently large constant . Pick the largest for which (recall that this condition can be tested w.h.p. by Lemma 2). Then the algorithm from Lemma 2 will succeed in computing w.h.p. and we return .
For the analysis, let . Let be a power of 2 with . Then by Chebyshev’s inequality,
On the other hand, for each , by Chebyshev’s inequality,
By a geometric series over all , . Thus, with probability , must be a value among . For each such value , the probability that but is not a -approximation of is at most , by applying Lemma 3 to the sum , which has nonempty terms.
The error probability is bounded by a constant, but can again be lowered by running logarithmically many independent copies of the algorithm and taking the majority of the answers. (For simplicity, we have not attempted to optimize the factors.)
3 Maximum Independent Set for Rectangles
We now present our dynamic streaming algorithm for MIS for rectangles. We begin by considering a special case in which the input rectangles are stabbable by a small number of horizontal as well as vertical lines. Bhore and Chan [8] solved this case by a simple rounding trick, which we observe works well in the dynamic streaming setting:
Lemma 4.
Let be a set of horizontal/vertical lines in 2D. Let be a set of axis-aligned rectangles in 2D with the property that each rectangle in is stabbed by at least one horizontal line and at least one vertical line in . Then we can design a dynamic streaming algorithm for maintaining an -approximation of the maximum independent set for with space and time w.h.p.
Proof.
The lines in form a (non-uniform) grid with grid cells. (See Figure 1.) Place two rectangles of in the same class if they intersect the same subset of grid cells. There are classes. Let be a subset of where we keep one “representative” element from each class. Then . We apply Mitchell’s algorithm [39] (or its subsequent improvement [31, 30]) to compute an -approximation of the maximum independent set for the rectangles in . This takes time polynomial in , i.e., time (note that the optimal size must be at most under the input assumption). Bhore and Chan [8] proved that this is an -approximation of the maximum independent set for .
To implement the algorithm in the dynamic streaming model, it suffices to maintain one representative element per class, since we can re-run Mitchell’s algorithm from scratch. Frahling, Indyk, and Sohler [28] (see also [36]) showed how to maintain a random element of a set in the dynamic streaming model; we can just apply their algorithm to each class and use the random element as the representative.
We now solve the main problem by reinterpreting the divide-and-conquer approach by Bhore and Chan [8] and incorporating Theorem 1.
Theorem 5.
Given a set of axis-aligned rectangles in 2D with coordinates in as a dynamic geometric stream, we can compute an -approximation of the maximum independent set size for using space and update time w.h.p.
Proof.
Write each coordinate value in base ; the number of digits in each value is .
Consider a rectangle in . Suppose that the most significant digit which and differ in is the -th most significant digit, and the most significant digit which and differ in is the -th most significant digit. Let be the most significant digits of and . Let be the most significant digits of and . We place in a set ; in turn, we place the set in a collection .444 Roughly, Bhore and Chan’s recursion [8] generates a primary tree (essentially a -ary interval tree in ), where each node stores a secondary tree (a -ary interval tree in ). Each set corresponds to a node of a secondary tree. Each collection corresponds to a “level” of the whole structure (namely, the -th level of all nodes at the -th level of the primary tree). (See Figure 2.)
For each , we maintain an -approximation of
using Theorem 1. Here, is defined as the maximum independent set size for , where denotes the rectangle obtained from by removing the most significant digits from and and the most significant digits from and , assuming that and differ in the -th most significant digit and and differ in the -th most significant digit (if the assumption is not satisfied, make undefined). Note that for an individual set , is the same as the maximum independent set size for (although this may not be true for a general set ). Also note that every rectangle is stabbed by one of the vertical lines at for some , and one of the horizontal lines at for some , and so we can maintain using Lemma 4 (note that ). The conditions of Theorem 1 are fulfilled with and . We return the maximum of the approximations of over all .
Observe that is just the maximum independent set size for , because rectangles in do not overlap with rectangles in for any two different sets . Thus, (the maximum independent set size for ) is at most . It follows that the returned value is an -approximation of . Finally, we set .
Although the preceding proof is compact, the details are subtle. For example, some readers may wonder why we didn’t define more simply as the maximum independent set size for , bypassing the definition of . The reason is that Theorem 1 requires working with for general sets , not just the ’s: indeed, the proof of Lemma 2 maintains intermediate sets that are unions of ’s (from a common bucket); without replacing with , the rectangles in such composite sets may not be stabbable by vertical/horizontal lines. Admittedly, defining as the maximum independent set for is somewhat counterintuitive, as its value seems irrelevant or meaningless when is a union of two or more sets ’s. (To picture such a set , imagine overlaying the two violet cells in Figure 2 on top of each other.) However, under the “right” circumstances, when we don’t have collisions, as in the proof of Lemma 2, would revert to a single , and would become meaningful again.
Remark 6.
Curiously, the approach of Theorem 5 extends to yield a space-efficient, -approximation streaming algorithm of boxes (hyperrectangles) in any constant dimension beyond 2. The catch is that the update time is prohibitively large (), as Mitchell’s algorithm works only in 2D. (Obtaining a polynomial-time -approximation algorithm for boxes in 3D is a major open problem even in the non-streaming setting.)
As in Bhore and Chan’s paper [8], our approach can also solve the minimum piercing set problem for 2D rectangles in the dynamic streaming model, but the approximation ratio increases to with space and update time.
4 Maximum Independent Set for Fat Objects
We now consider the case of fat objects, again adapting Bhore and Chan’s non-streaming algorithm [8]. Our algorithm extends to the weighted version of independent set.
In the following, we adapt notation and definitions from [8]. Let denote the diameter of an object , where diameter refers to -diameter. A collection of objects is -fat if for every hypercube , there exist points piercing all objects in that intersect and have diameter at least . A quadtree box is a hypercube of the form for integers .
An object is -good if it is contained in a quadtree box with diameter at most .
Fact 7 (Shifting Lemma [15, 16]).
Suppose is even. Let . For every object , there exists such that is -good.
Bhore and Chan [8] solved the following special case by rounding, which we observe works well in the dynamic streaming setting:
Lemma 8.
Let be constants. Let be disjoint quadtree boxes. Let be a set of -good objects in of constant description complexity from a -fat collection , with the property that each object in intersects the boundary of at least one quadtree box of . Each object is given a weight in . Then we can design a dynamic streaming algorithm for maintaining an -approximation of the maximum-weight independent set for with space and time w.h.p.
Proof.
First round the weights to powers of 2; the approximation ratio increases by at most a factor of 2.
Place two objects of in the same class if they intersect the same subset of cells in . There are at most classes (as noted in [8]). Let be a subset of where we keep one “representative” element from each class, namely, a largest-weight element from the class. Then . We apply a known algorithm (e.g., [16]) to compute an -approximation to the maximum-weight independent set for the fat objects in . This takes time polynomial in , i.e., time. Bhore and Chan [8] proved that this is an -approximation of the maximum independent set for (using the goodness assumption).
To implement the algorithm in the dynamic streaming model, it suffices to maintain a representative element per class. Frahling, Indyk, and Sohler [28] (see also [36]) showed how to maintain a random element of a set in the dynamic streaming model; we can just apply their algorithm to each class restricted to elements of each weight, and use the random element as the representative for the largest weight whose set is nonempty. There are only possible weights.
We now solve the main problem, via quadtree-based divide-and-conquer, as in [8],555Bhore and Chan [8] needed a balanced version of quadtrees (requiring cells that are differences of two quadtree boxes), but we are able to simplify the divide-and-conquer because of the bounded universe assumption. but in combination with Theorem 1.
Theorem 9.
For any constant dimension , given a set of -fat objects in as a dynamic geometric stream, where the diameter of each object is at least 1 and each object has a weight in , we can compute an -approximation of the maximum independent set weight for using space and update time w.h.p.
Proof.
We assume that all objects of are -good. This is without loss of generality by the shifting lemma (Fact 7): for each of the shifts , we can solve the problem for the good objects of in parallel, and return the maximum of the answers. The approximation ratio increases by a factor of .
Furthermore, we assume that all objects have weights in a common interval . This is without loss of generality, if we increase the approximation ratio by an extra factor of (since there are choices for ). By rescaling, we may now assume that all objects have weights in .
Consider an object . Let be the smallest quadtree box containing such that is a power of (the parameter will be a power of 2). Suppose that . We place in a set ; in turn, we place the set in a collection .666 Each corresponds to a node in the -ary variant of the quadtree. Each corresponds to one level of the quadtree.
For each , we maintain an -approximation of using Theorem 1. Here, is defined as the maximum independent set weight for , where denotes the object shifted by , where is the quadtree box containing with , and is the lexicograpically smallest vertex of , assuming that is not contained in any quadtree box with diameter (if the assumption is not satisfied, make undefined). Note that for an individual set , is the same as the maximum independent set weight for . Also note that every object intersects the boundary of one of the quadtree boxes of diameter contained in , and so we can maintain using Lemma 4 after replacing with (note that , since all objects have weights in ). The conditions of Theorem 1 are fulfilled with and . We return the maximum of the approximations of over all .
Observe that is just the maximum independent set weight for , because rectangles in do not overlap with rectangles in for any two different sets . Thus, (the maximum independent set weight for ) is at most . It follows that the returned value is an -approximation of , under the assumption that objects have weights in . We thus obtain approximation ratio for the general problem. Finally, we set .
Remark 10.
Without weights, the approximation ratio is . If the ratio of the maximum to the minimum diameter of the objects and the ratio of the maximum to the minimum weight of the objects are bounded by , then the factors can be reduced to .
As in Bhore and Chan’s paper [8], the approach also works for the minimum piercing set problem for fat objects.
References
- [1] Anna Adamaszek, Sariel Har-Peled, and Andreas Wiese. Approximation schemes for independent set and sparse subsets of polygons. J. ACM, 66(4):29:1–29:40, 2019. doi:10.1145/3326122.
- [2] Pankaj K. Agarwal, Marc J. van Kreveld, and Subhash Suri. Label placement by maximum independent set in rectangles. Comput. Geom., 11(3-4):209–218, 1998. doi:10.1016/S0925-7721(98)00028-5.
- [3] Alexandr Andoni and Huy L. Nguyên. Width of points in the streaming model. ACM Trans. Algorithms, 12(1):5:1–5:10, 2016. doi:10.1145/2847259.
- [4] Ainesh Bakshi, Nadiia Chepurko, and David P. Woodruff. Weighted maximum independent set of geometric objects in turnstile streams. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM), volume 176 of LIPIcs, pages 64:1–64:22, 2020. doi:10.4230/LIPICS.APPROX/RANDOM.2020.64.
- [5] Piotr Berman, Bhaskar DasGupta, S. Muthukrishnan, and Suneeta Ramaswami. Improved approximation algorithms for rectangle tiling and packing. In Proceedings of the 12th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 427–436, 2001. URL: http://dl.acm.org/citation.cfm?id=365411.365496.
- [6] Sujoy Bhore, Jean Cardinal, John Iacono, and Grigorios Koumoutsos. Dynamic geometric independent set. In Abstracts of 23rd Thailand-Japan Conference on Discrete and Computational Geometry, Graphs, and Games (TJDCG), 2021. arXiv:2007.08643.
- [7] Sujoy Bhore and Timothy M. Chan. Dynamic independent set of disks (and hypercubes) made easier. In Proceedings of the 8th SIAM Symposium on Simplicity in Algorithms (SOSA), pages 485–495, 2025. doi:10.1137/1.9781611978315.36.
- [8] Sujoy Bhore and Timothy M. Chan. Fast static and dynamic approximation algorithms for geometric optimization problems: Piercing, independent set, vertex cover, and matching. In Proceedings of the 36th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2357–2386, 2025. doi:10.1137/1.9781611978322.79.
- [9] Sujoy Bhore, Fabian Klute, and Jelle J. Oostveen. On streaming algorithms for geometric independent set and clique. In Proceedings of the 20th International Workshop on Approximation and Online Algorithms (WAOA), volume 13538 of Lecture Notes in Computer Science, pages 211–224. Springer, 2022. doi:10.1007/978-3-031-18367-6_11.
- [10] Sujoy Bhore, Martin Nöllenburg, Csaba D. Tóth, and Jules Wulms. Fully dynamic maximum independent sets of disks in polylogarithmic update time. In Proceedings of the 40th International Symposium on Computational Geometry (SoCG), volume 293 of LIPIcs, pages 19:1–19:16, 2024. doi:10.4230/LIPICS.SOCG.2024.19.
- [11] Vladimir Braverman, Gereon Frahling, Harry Lang, Christian Sohler, and Lin F. Yang. Clustering high dimensional dynamic data streams. In Proceedings of the 34th International Conference on Machine Learning (ICML), pages 576–585, 2017. URL: http://proceedings.mlr.press/v70/braverman17a.html.
- [12] Sergio Cabello and Pablo Pérez-Lantero. Interval selection in the streaming model. Theor. Comput. Sci., 702:77–96, 2017. doi:10.1016/J.TCS.2017.08.015.
- [13] Jean Cardinal, John Iacono, and Grigorios Koumoutsos. Worst-case efficient dynamic geometric independent set. In Proceedings of the 29th Annual European Symposium on Algorithms (ESA), volume 204 of LIPIcs, pages 25:1–25:15, 2021. doi:10.4230/LIPICS.ESA.2021.25.
- [14] Parinya Chalermsook and Julia Chuzhoy. Maximum independent set of rectangles. In Proceedings of the 20th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 892–901. SIAM, 2009. doi:10.1137/1.9781611973068.97.
- [15] Timothy M. Chan. Approximate nearest neighbor queries revisited. Discret. Comput. Geom., 20(3):359–373, 1998. doi:10.1007/PL00009390.
- [16] Timothy M. Chan. Polynomial-time approximation schemes for packing and piercing fat objects. J. Algorithms, 46(2):178–189, 2003. doi:10.1016/S0196-6774(02)00294-8.
- [17] Timothy M. Chan. A note on maximum independent sets in rectangle intersection graphs. Inf. Process. Lett., 89(1):19–23, 2004. doi:10.1016/J.IPL.2003.09.019.
- [18] Timothy M. Chan. Dynamic streaming algorithms for epsilon-kernels. In Proceedings of the 32nd International Symposium on Computational Geometry (SoCG), volume 51 of LIPIcs, pages 27:1–27:11, 2016. doi:10.4230/LIPICS.SOCG.2016.27.
- [19] Timothy M. Chan and Sariel Har-Peled. Approximation algorithms for maximum independent set of pseudo-disks. Discret. Comput. Geom., 48(2):373–392, 2012. doi:10.1007/S00454-012-9417-5.
- [20] Xiaoyu Chen, Shaofeng H.-C. Jiang, and Robert Krauthgamer. Streaming Euclidean max-cut: Dimension vs data reduction. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing (STOC), pages 170–182, 2023. doi:10.1145/3564246.3585170.
- [21] Julia Chuzhoy and Alina Ene. On approximating maximum independent set of rectangles. In Proceedings of the 57th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 820–829, 2016. doi:10.1109/FOCS.2016.92.
- [22] Jana Cslovjecsek, Michał Pilipczuk, and Karol Wegrzycki. A polynomial-time -approximation algorithm for maximum independent set of connected subgraphs in a planar graph. In Proceedings of the 35th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 625–638, 2024. doi:10.1137/1.9781611977912.23.
- [23] Artur Czumaj, Shaofeng H.-C. Jiang, Robert Krauthgamer, and Pavel Veselý. Streaming algorithms for geometric Steiner forest. ACM Trans. Algorithms, 20(4):28:1–28:38, 2024. doi:10.1145/3663666.
- [24] Artur Czumaj, Christiane Lammersen, Morteza Monemizadeh, and Christian Sohler. -approximation for facility location in data streams. In Proceedings of the 24th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1710–1728, 2013. doi:10.1137/1.9781611973105.123.
- [25] Alon Efrat, Matthew J. Katz, Frank Nielsen, and Micha Sharir. Dynamic data structures for fat objects and their applications. Comput. Geom., 15(4):215–227, 2000. doi:10.1016/S0925-7721(99)00059-0.
- [26] Thomas Erlebach, Klaus Jansen, and Eike Seidel. Polynomial-time approximation schemes for geometric intersection graphs. SIAM Journal on Computing, 34(6):1302–1323, 2005. doi:10.1137/S0097539702402676.
- [27] Jacob Fox and János Pach. Computing the independence number of intersection graphs. In Proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1161–1165, 2011. doi:10.1137/1.9781611973082.87.
- [28] Gereon Frahling, Piotr Indyk, and Christian Sohler. Sampling in dynamic data streams and applications. Int. J. Comput. Geom. Appl., 18(1/2):3–28, 2008. doi:10.1142/S0218195908002520.
- [29] Gereon Frahling and Christian Sohler. Coresets in dynamic geometric data streams. In Proceedings of the 37th Annual ACM Symposium on Theory of Computing, pages 209–217. ACM, 2005. doi:10.1145/1060590.1060622.
- [30] Waldo Gálvez, Arindam Khan, Mathieu Mari, Tobias Mömke, Madhusudhan Reddy Pittu, and Andreas Wiese. A -approximation algorithm for maximum independent set of rectangles. CoRR, abs/2106.00623, 2021. arXiv:2106.00623.
- [31] Waldo Gálvez, Arindam Khan, Mathieu Mari, Tobias Mömke, Madhusudhan Reddy Pittu, and Andreas Wiese. A 3-approximation algorithm for maximum independent set of rectangles. In Proceedings of the 33rd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 894–905, 2022. doi:10.1137/1.9781611977073.38.
- [32] Monika Henzinger, Stefan Neumann, and Andreas Wiese. Dynamic approximate maximum independent set of intervals, hypercubes and hyperrectangles. In Proceedings of the 36th International Symposium on Computational Geometry (SoCG), volume 164 of LIPIcs, pages 51:1–51:14, 2020. doi:10.4230/LIPICS.SOCG.2020.51.
- [33] Dorit S. Hochbaum and Wolfgang Maass. Approximation schemes for covering and packing problems in image processing and VLSI. Journal of the ACM, 32(1):130–136, 1985. doi:10.1145/2455.214106.
- [34] Wei Hu, Zhao Song, Lin F Yang, and Peilin Zhong. Nearly optimal dynamic -means clustering for high-dimensional data. arXiv preprint, 2018. arXiv:1802.00459.
- [35] Piotr Indyk. Algorithms for dynamic geometric problems over data streams. In Proceedings of the 36th Annual ACM Symposium on Theory of Computing, pages 373–380, 2004. doi:10.1145/1007352.1007413.
- [36] Hossein Jowhari, Mert Saglam, and Gábor Tardos. Tight bounds for samplers, finding duplicates in streams, and related problems. In Proceedings of the 30th ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems (PODS), pages 49–58, 2011. doi:10.1145/1989284.1989289.
- [37] Sanjeev Khanna, S. Muthukrishnan, and Mike Paterson. On approximating rectangle tiling and packing. In Proceedings of the 9th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 384–393, 1998. URL: http://dl.acm.org/citation.cfm?id=314613.314768.
- [38] Christiane Lammersen, Anastasios Sidiropoulos, and Christian Sohler. Streaming embeddings with slack. In Proceedings of the 11th International Symposium on Algorithms and Data Structures (WADS), volume 5664 of Lecture Notes in Computer Science, pages 483–494. Springer, 2009. doi:10.1007/978-3-642-03367-4_42.
- [39] Joseph S. B. Mitchell. Approximating maximum independent set for rectangles in the plane. In Proceedings of the 62nd Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 339–350, 2022. doi:10.1109/FOCS52979.2021.00042.
- [40] Rajeev Motwani and Prabhakar Raghavan. Randomized Algorithms. Cambridge University Press, 1995. doi:10.1017/CBO9780511814075.
- [41] Frank Nielsen. Fast stabbing of boxes in high dimensions. Theor. Comput. Sci., 246(1-2):53–72, 2000. doi:10.1016/S0304-3975(98)00336-3.
