An Algorithmic Study of Fully Dynamic Independent Sets for Map Labeling
AAn Algorithmic Study of Fully DynamicIndependent Sets for Map Labeling
Sujoy Bhore
Algorithms and Complexity Group, TU Wien, Vienna, [email protected]
Guangping Li
Algorithms and Complexity Group, TU Wien, Vienna, [email protected]
Martin Nöllenburg
Algorithms and Complexity Group, TU Wien, Vienna, [email protected]
Abstract
Map labeling is a classical problem in cartography and geographic information systems (GIS)that asks to place labels for area, line, and point features, with the goal to select and place themaximum number of independent, i.e., overlap-free, labels. A practically interesting case is pointlabeling with axis-parallel rectangular labels of common size. In a fully dynamic setting, at eachtime step, either a new label appears or an existing label disappears. Then, the challenge is tomaintain a maximum cardinality subset of pairwise independent labels with sub-linear update time.Motivated by this, we study the maximal independent set (
MIS ) and maximum independent set(
Max-IS ) problems on fully dynamic (insertion/deletion model) sets of axis-parallel rectangles oftwo types—(i) uniform height and width and (ii) uniform height and arbitrary width; both settingscan be modeled as rectangle intersection graphs.We present the first deterministic algorithm for maintaining a
MIS (and thus a 4-approximate
Max-IS ) of a dynamic set of uniform rectangles with amortized sub-logarithmic update time. Thisbreaks the natural barrier of Ω(∆) update time (where ∆ is the maximum degree in the graph) for vertex updates presented by Assadi et al. (STOC 2018). We continue by investigating
Max-IS andprovide a series of deterministic dynamic approximation schemes. For uniform rectangles, we firstgive an algorithm that maintains a 4-approximate
Max-IS with O (1) update time. In a subsequentalgorithm, we establish the trade-off between approximation quality 2(1 + k ) and update time O ( k log n ), for k ∈ N . We conclude with an algorithm that maintains a 2-approximate Max-IS for dynamic sets of unit-height and arbitrary-width rectangles with O ( ω log n ) update time, where ω is the maximum size of an independent set of rectangles stabbed by any horizontal line. Wehave implemented our algorithms and report the results of an experimental comparison exploringthe trade-off between solution quality and update time for synthetic and real-world map labelinginstances. Theory of computation → Computational geometry; Theory ofcomputation → Dynamic graph algorithms
Keywords and phrases
Independent Sets, Dynamic Algorithms, Rectangle Intersection Graphs,Approximation Algorithms, Experimental Evaluation
Supplement Material
Source code and benchmark data at https://dyna-mis.github.io/dynaMIS/ . Funding
Research supported by the Austrian Science Fund (FWF), grant P 31119. a r X i v : . [ c s . C G ] A ug An Algorithmic Study of Fully Dynamic Independent Sets for Map Labeling
Map Labeling is a classical problem in cartography and geographic information systems(GIS), that has received significant attention in the past few decades and is concerned withselecting and positioning labels on a map for area, line, and point features. The focus in thecomputational geometry community has been on labeling point features [3, 20, 39, 40]. Thelabels are typically modeled as the bounding boxes of short names, which correspond preciselyto unit height, but arbitrary width rectangles; alternatively, labels can be standardized iconsor symbols, which correspond to rectangles of uniform size. In map labeling, a key task is infact to select an independent (i.e., overlap-free) set of labels from a given set of candidatelabels. Commonly the optimization goal is related to maximizing the number of labels. Givena set R of rectangular labels, Map Labeling is essentially equivalent to the problem offinding a maximum independent set in the intersection graph induced by R .The independent set problem is a fundamental graph problem with a wide range ofapplications. Given a graph G = ( V, E ), a set of vertices M ⊂ V is independent if no twovertices in M are adjacent in G . A maximal independent set (MIS) is an independent set thatis not a proper subset of any other independent set. A maximum independent set ( Max-IS )is a maximum cardinality independent set. While
Max-IS is one of Karp’s 21 classic NP -complete problems [31], computing a MIS can easily be done by a simple greedy algorithm in O ( | E | ) time. The MIS problem has been studied in the context of several other prominentproblems, e.g., graph coloring [33], maximum matching [30], and vertex cover [36]. On theother hand, Max-IS serves as a natural model for many real-life optimization problems,including map labeling [3], computer vision [6], information retrieval [37], and scheduling [38].Stronger results for independent set problems in geometric intersection graphs are known incomparison to general graphs. For instance, it is known that
Max-IS on general graphs cannotbe approximated better than | V | − (cid:15) in polynomial time for any (cid:15) > NP = ZPP [27].In contrast, a randomized polynomial-time algorithm exists that computes for rectangleintersection graphs an O (log log n )-approximate solution to Max-IS with high probability [12],as well as QPTASs [2,16]. The
Max-IS problem is already NP -Hard on unit square intersectiongraphs [21], however, it admits a polynomial-time approximation scheme ( PTAS ) for unitsquare intersection graphs [19] and more generally for pseudo disks [13]. Moreover, forrectangles with either uniform size or at least uniform height and bounded aspect ratio, thesize of an MIS is not arbitrarily worse than the size of a
Max-IS . For instance, any MIS of aset of uniform rectangles is a 4-approximate solution to the
Max-IS problem, since eachrectangle can have at most four independent neighbors.Past research has mostly considered static label sets in static maps [3, 20, 39, 40] andin dynamic maps allowing zooming [7] or rotations [25], but not fully dynamic label setswith insertions and deletions of labels. Recently, Klute et al. [32] proposed a frameworkfor semi-automatic label placement, where domain experts can interactively insert anddelete labels. In their setting an initially computed large independent set of labels can beinteractively modified by a cartographer, who can easily take context information and softcriteria such as interactions with the background map or surrounding labels into account.Standard map labeling algorithms typically do not handle such aspects well. Based on thesemodifications (such as deletion, forced selection, translation, or resizing), the solution isupdated by a dynamic algorithm while adhering to the new constraints. Another scenario fordynamic labels are maps, in which features and labels (dis-)appear over time, e.g., based ona stream of geotagged, uniform-size photos posted on social media or, more generally, mapswith labels of dynamic spatio-temporal point sets [22]. For instance, a geo-located event . Bhore, G. Li, and M. Nöllenburg 3 that happens at time t triggers the availability of a new label for a certain period of time,after which it vanishes again. Examples beyond social media are reports of earth quakes,forest fires, or disease incidences. Motivated by this, we study the independent set problemfor dynamic rectangles of two types—(i) uniform height and width and (ii) uniform heightand arbitrary width. We consider fully dynamic algorithms for maintaining independentsets under insertions and deletions of rectangles, i.e., vertex insertions and deletions in thecorresponding dynamic rectangle intersection graph. Dynamic graphs are subject to discrete changes over time, i.e., insertions or deletionsof vertices or edges [18]. A dynamic graph algorithm solves a computational problem, suchas the independent set problem, on a dynamic graph by updating efficiently the previoussolution as the graph changes over time, rather than recomputing it from scratch. A dynamicgraph algorithm is called fully dynamic if it allows both insertions and deletions, and partiallydynamic if only insertions or only deletions are allowed. While general dynamic independentset algorithms can obviously also be applied to rectangle intersection graphs, our goal is toexploit their geometric properties to obtain more efficient algorithms.
Related Work.
There has been a lot of work on dynamic graph algorithms in the lastdecade and dynamic algorithms still receive considerable attention in theoretical computerscience. We point out some of these works, e.g., on spanners [9], vertex cover [10], set cover [1],graph coloring [11], and maximal matching [23]. In particular, the maximal independent setproblem on dynamic graphs with edge updates has attracted significant attention in the lasttwo years [4, 5, 8, 15, 17]. Recently, Henzinger et al. [28] studied the
Max-IS problem forintervals, hypercubes and hyperrectangles in d dimensions, with special assumptions. Theyassumed that the objects are axis-parallel and contained in the space [0 , N ] d ; the value of N is given in advance, and each edge of an input object has length at least 1 and at most N .Moreover, they have designed dynamic approximation algorithms and lower bounds, wherethe update time depends on N and is of high complexity. Gavruskin et al. [24] studied the Max-IS problem for dynamic proper intervals (intervals cannot contain one another), andshowed how to maintain a
Max-IS with polylogarithmic update time.
Results and Organization.
We study MIS and
Max-IS problems for dynamic sets of O ( n )axis-parallel rectangles of two types: (i) congruent rectangles of uniform height and widthand (ii) rectangles of uniform height and arbitrary width. For both classes of rectangles aMIS can be maintained in Ω(∆) update time by using the recent algorithm of Assadi et al. [4],where ∆ is the maximum degree of the intersection graph. A (1 + (cid:15) )-approximate Max-IS canbe maintained for unit squares in O ( n /(cid:15) ) time [19], and a (1 + k )-approximate Max-IS canbe maintained for unit height and arbitrary width rectangles in O ( n k − ) update time [3] forany integer k ≥
1. In this paper we design and implement algorithms for dynamic MIS and
Max-IS that demonstrate the trade-off between update time and approximation factor, bothfrom a theoretical perspective and in an experimental evaluation. In contrast to the recentdynamic MIS algorithms, which are randomized [4, 5, 8, 15], our algorithms are deterministic.In Section 3 we present an algorithm that maintains a
MIS of a dynamic set of unitsquares in amortized O (log / o (1) n ) update time, improving the best known update timeΩ(∆) [4]. A major, but generally unavoidable bottleneck of that algorithm is that the entiregraph is stored explicitly, and thus insertions/deletions of vertices take Ω(∆) time. We usestructural geometric properties of the unit squares along with a dynamic orthogonal rangesearching data structure to bypass the explicit intersection graph and break this bottleneck.In Section 4, we study the Max-IS problem. For dynamic unit squares, we give an
An Algorithmic Study of Fully Dynamic Independent Sets for Map Labeling algorithm that maintains a 4-approximate
Max-IS with O (1) update time. We generalizethis algorithm and improve the approximation factor to 2(1 + k ), which increases the updatetime to O ( k log n ). We conclude with an algorithm that maintains a 2-approximate Max-IS for a dynamic set of unit-height and arbitrary-width rectangles (in fact, for a dynamic intervalgraph, which is of independent interest) with O ( ω log n ) output-sensitive update time, where ω is the maximum size of an independent set of rectangles stabbed by any horizontal line.Finally, Section 5 provides an experimental evaluation of the proposed Max-IS approxi-mation algorithms on synthetic and real-world map labeling data sets using unit squares.The experiments explore the trade-off between solution size and update time, as well as thespeed-up of the dynamic algorithms over their static counterparts. See the supplementalmaterial for source code and benchmark data.
Let R = { r , . . . , r ν } be a set of ν axis-parallel, unit-height rectangles in the plane. Ifthe rectangles are of uniform height and width, we can use an affine transformation tomap R to a set of unit squares S = { s , . . . , s ν } instead. We use the shorthand notation[ n ] = { , , . . . , n } . In our setting we assume that R is dynamically updated by a sequence of N ∈ N insertions and deletions. We denote the set of rectangles at step i ∈ [ N ] as R i . For aset of unit squares S i = { s , . . . , s ν } at step i ∈ [ N ] we further define the set C i = { c , . . . , c ν } of the corresponding square centers. Let n = max {|R i | | i ∈ [ N ] } be the maximum numberof rectangles over all steps. The rectangle intersection graph defined by R i at time step i is denoted as G i = ( R i , E i ), where two rectangles r, r ∈ R i are connected by an edge { r, r } ∈ E i if and only if r ∩ r = ∅ . We use M i to denote a maximal independent set in G i , and OP T i to denote a maximum independent set in G i . For a graph G = ( V, E ) and avertex v ∈ V , let N ( v ) denote the set of neighbors of v in G . This notation also extends toany subset U ⊆ V by defining N ( U ) = S v ∈ U N ( v ). We use deg( v ) to denote the degree of avertex v ∈ V . For any vertex v ∈ V , let N r ( v ) be the r -neighborhood of v , i.e., the set ofvertices that are within distance at most r from v (excluding v ). In this section, we study the MIS problem for dynamic uniform rectangles. As stated beforewe can assume w.l.o.g. that the rectangles are unit squares. We design an algorithm thatmaintains a MIS for a dynamic set of O ( n ) unit squares in sub-logarithmic update time.Assadi et al. [4] presented an algorithm for maintaining a MIS on general dynamic graphs withΩ(∆) update time, where ∆ is the maximum degree in the graph. In the worst case, however,that algorithm takes O ( n ) update time. In fact, it seems unavoidable for an algorithm thatexplicitly maintains the (intersection) graph to perform a MIS update in less than Ω(deg( v ))time for an insertion/deletion of a vertex v . In contrast, our proposed algorithm in thissection does not explicitly maintain the intersection graph G i = ( S i , E i ) (for any i ∈ [ N ]),but rather only the set of squares S i in a suitable dynamic geometric data structure. For theease of explanation, however, we do use graph terms at times.Let i ∈ [ N ] be any time point in the sequence of updates. For each square s v ∈ S i , let s av be a square of side length a concentric with s v . Further, let M i denote the MIS that wecompute for G i = ( S i , E i ), and let C ( M i ) ⊆ C i be their corresponding square centers. Wemaintain two fully dynamic orthogonal range searching data structures throughout: (i) adynamic range tree T ( C i ) for the entire point set C i and (ii) a dynamic range tree T ( C ( M i )) . Bhore, G. Li, and M. Nöllenburg 5 s x s x s x P x P x R R R R R (a) (b) Figure 1
Example for the deletion of a square s x . (a) Square s x , its neighborhood with centersin s x , its 2-neighborhood with centers in s x , and the polygon P x . (b) Vertical slab partition of P x . for the point set C ( M i ) corresponding to the centers of M i . They can be implementedwith dynamic fractional cascading [34], which yields O (log n log log n ) update time and O ( k + log n log log n ) query time for reporting k points. The currently best fully dynamicdata structure for orthogonal range reporting requires O (log / o (1) n ) amortized updatetime and O ( k + log n log log n ) amortized query time [14].We compute the initial MIS M for G = ( S , E ) by using a simple linear-time greedyalgorithm. First we initialize the range tree T ( C i ). Then we iterate through the set S aslong as it is not empty, select a square s v for M and insert its center into T ( C ( M i )), find itsneighbors N ( s v ) by a range query in T ( C i ) with the concentric square s v , and delete N ( s v )from S . It is clear that once this process terminates, M is a MIS.When we move in the next step from G i = ( S i , E i ) to G i +1 = ( S i +1 , E i +1 ), either asquare is inserted into S i or deleted from S i . Let s x be the square that is inserted or deleted. Insertion:
When we insert a square s x into S i to obtain S i +1 , we do the following operations.First, we obtain T ( C i +1 ) by inserting the center of s x into T ( C i ). Next, we have to detectwhether s x can be included in M i +1 . If there exists a square s u from M i intersecting s x , weshould not include s x ; otherwise we will add it to the MIS. To check this, we search withthe range s x in T ( C ( M i )). By a simple packing argument, we know that no more than fourpoints (the centers of four independent squares) of C ( M i ) can be in the range s x . If thequery returns such a point, then s x would intersect with another square in M i and we set M i +1 = M i . Otherwise, we insert s x into T ( C ( M i )) to get T ( C ( M i +1 )). Deletion:
When we delete a square s x from S i , it is possible that s x ∈ M i . In this case wemay have to add squares from N ( s x ) into M i +1 to keep it maximal. Since any square canhave at most four independent neighbors, we can add in this step up to four squares to M i +1 .First, we check if s x ∈ M i . If not, then we simply delete s x from T ( C i ) to get T ( C i +1 )and set M i +1 = M i . Otherwise, we delete again s x from T ( C i ) and also from T ( C ( M i )). Inorder to detect which neighbors of s x can be added to M i , we use suitable queries in thedata structures T ( C ( M i )) and T ( C i ). Figure 1a illustrates the next observations. The centersof all neighbors in N ( s x ) must be contained in the square s x . But some of these neighborsmay intersect other squares in M i . In fact, these squares would by definition belong tothe 2-neighborhood, i.e., be in the set Q x = N ( s x ) ∩ M i . We can obtain Q x by querying T ( C ( M i )) with the range s x . Since s x ∈ M i , we know that Q x ∩ s x = ∅ and hence the centerpoints of the squares in Q x lie in the annulus s x − s x . A simple packing argument implies An Algorithmic Study of Fully Dynamic Independent Sets for Map Labeling that | Q x | ≤
12 and therefore querying T ( C ( M i )) will return at most 12 points.Next we define the rectilinear polygon P x = s x − S s y ∈ Q x s y , which contains all possiblecenter points of squares that are neighbors of s x but do not intersect any square s y ∈ M i \{ s x } . (cid:73) Observation 1.
The polygon P x has at most corners. Proof.
We know that Q x contains at most 12 squares s y , for each of which we subtract s y from s x . Since all squares have the same side length, at most two new corners can be createdin P x when subtracting a square s y . Initially P x had four corners, which yields the claimedbound of at most 28 corners. (cid:74) Next we want to query T ( C i ) with the range P x , which we do by vertically partitioning P x into rectangular slabs R , . . . , R c for some c ≤
28 (see Figure 1b). For each slab R j ,where 1 ≤ j ≤ c , we perform a range query in T ( C i ). If a center p is returned, we can add thecorresponding square s p into M i +1 , and p into T ( C ( M i )) to obtain T ( C ( M i +1 )). Moreover,we have to update P x ← P x − s p , refine the slab partition and continue querying T ( C i ) withthe slabs of P x . We know that the deleted square s x can have at most four independentneighbors. So after adding at most four new squares to M i +1 we know that P x = ∅ and wecan stop searching. (cid:73) Lemma 2.
The set M i is a maximal independent set of G i = ( S i , E i ) for each step i ∈ [ N ] . Proof.
The correctness proof is inductive. By construction the initial set M is a MIS for G . Let us consider some step i > M i − is a MIS for G i − .If a new square s x is inserted in step i , we add it to M i if it does not intersect any othersquare in M i − ; otherwise we keep M i − . In either case M i is a MIS of G i . If a square s x isdeleted in step i and s x M i − , then M i = M i − is a MIS of G i . Finally, let s x ∈ M i − .Assume for contradiction that M i is not a MIS, i.e., some square s q could be added to M i .Since M i − was a MIS, s q ∈ N ( s x ) and thus its center must lie in the region P x . But thenwe would have found s q in our range queries with the slabs of P x . Hence M i is indeed a MISof G i . (cid:74) Both the
Insertion and the
Deletion operations consist of (i) a constant number ofinsertions or deletions in the two fully dynamic orthogonal range searching data structuresand (ii) of a constant number of orthogonal range reporting queries. These queries returnat most 12 points in T ( C ( M i − )). While the query range P x for T ( C i − ) in the Deletion operation may contain many points, an arbitrary point in P x is sufficient for adding a newsquare to the independent set. Thus we do not need to enumerate all contained points,but just a single witness. In the orthogonal range searching data structure of Chan andTsakalidis [14], the amortized update time for an insertion/deletion is O (log / o (1) n ); thisdominates the query time and together with Lemma 2 yields: (cid:73) Theorem 3.
We can maintain a maximal independent set of a dynamic set of unit squares,deterministically, in amortized O (log / o (1) n ) update time. Proof.
The correctness follows from Lemma 2. It remains to show the running time forthe fully dynamic updates. At each step i we perform either an Insertion or a
Deletion operation. Let us first discuss the update time for the insertion of a square. As describedabove, an insertion performs one or two insertions of the center of the square into therange trees and one range query in T ( C ( M i − )), which will return at most four points.Using dynamic fractional cascading [34], this requires O (log n log log n ) time; with the datastructure of Chan and Tsakalidis [14], the amortized update time for inserting a square is . Bhore, G. Li, and M. Nöllenburg 7 O (log / o (1) n ), the time for inserting a new point into their range searching data structure;this dominates the query time. The deletion of a square triggers either just a single deletionfrom the range tree T ( C i − ) or, if it was contained in the MIS M i − , two deletions, up tofour insertions, and a sequence of range queries: one query in T ( C ( M i − )), which can returnat most 12 points and a constant number of queries in T ( C i − ) with the constant-complexityslab partition of P x . Note that while the number of points in P x can be large, for our purposeit is sufficient to return a single point in each query range if it is not empty. Therefore, theupdate time for a deletion is again O (log n log log n ) with dynamic fractional cascading [34]or amortized O (log / o (1) n ) [14], depending on the selected data structure. (cid:74) For unit square intersection graphs, recall that any square in a MIS can have at mostfour mutually independent neighbors. Therefore, maintaining a dynamic MIS immediatelyimplies maintaining a dynamic 4-approximate
Max-IS . (cid:73) Corollary 4.
We can maintain a 4-approximate maximum independent set of a dynamicset of unit squares, deterministically, in amortized O (log / o (1) n ) update time. In this section, we study the
Max-IS problem for dynamic unit squares as well as forunit-height and arbitrary-width rectangles. In a series of dynamic schemes proposed in thissection, we establish the trade-off between the update time and the solution size, i.e., theapproximation factors. First, we design a 4-approximation algorithm with O (1) updatetime for Max-IS on dynamic unit squares (Section 4.1). We improve this to an algorithmthat maintains a 2(1 + k )-approximate Max-IS with O ( k log n ) update time (Section 4.2).Finally, we conclude with an algorithm that deterministically maintains a 2-approximate Max-IS with output-sensitive O ( ω log n ) update time, where ω is the maximum size of anindependent set of the unit-height rectangles stabbed by any horizontal line (Section 4.3).Let B be a bounding square of the dynamic set of 1 × S i ∈ [ N ] S i ofside length κ × κ ; we can assume that κ = O ( n ); otherwise we could contract emptyhorizontal/vertical strips of B . Let H = { h , . . . , h κ } and L = { l , . . . , l κ } be a set oftop-to-bottom and left-to-right ordered equidistant horizontal and vertical lines partitioning B into a square grid of side-length-1 cells, see Figure 2. Let E H = { h i ∈ H | i = 0 (mod 2) } and O H = { h i ∈ H | i = 1 (mod 2) } be the set of even and odd horizontal lines, respectively. We design a 4-approximation algorithm for the
Max-IS problem on dynamic unit squareintersection graphs with constant update time. Our algorithm is based on a grid partitioningapproach. Consider the square grid on B induced by the sets H and L of horizontal andvertical lines. We denote the grid points as g p,q for p, q ∈ [ κ ], where g p,q is the intersectionpoint of lines h p and l q . Under a general position assumption (otherwise we slightly perturbthe grid position to handle degenerate cases), each unit square in any set S i , for i ∈ [ N ]contains exactly one grid point. For each g p,q , we store a Boolean activity value S i (for any step i ∈ [ N ]). If g p,q intersects at least one square of S i ,we say that it is active and set the value to 1; otherwise, we set the value to 0. Observe thatfor each grid point g p,q and each time step i at most one square of S i intersecting g p,q canbe chosen in any Max-IS . This holds because all squares that intersect the same grid pointform a clique in G i , and at most one square from a clique can be chosen in any independentset. An Algorithmic Study of Fully Dynamic Independent Sets for Map Labeling g , g , g , g , h h h h l l l l Figure 2
Example instance with bounding square B partitioned into a 5 × M ( O ( H )). We first initialize an independent set M for G = ( S , E ) with | M | ≥ | OP T | /
4. Foreach horizontal line h j ∈ H , we compute two independent sets M h j and M h j , where M h j (resp. M h j ) contains an arbitrary square intersecting each odd (resp. even) grid point on h j .Since every other grid point is omitted in these sets, any two selected squares are independent.Let M ( h j ) = arg max {| M h j | , | M h j |} be the larger of the two independent sets. We define p ( h j ) = | M h j | and q ( h j ) = | M h j | , as well as c ( h j ) = | M ( h j ) | = max { p ( h j ) , q ( h j ) } .We construct the independent sets M ( E H ) = S b κ/ c j =1 ( M ( h j )) for E H and M ( O H ) = S b κ/ c j =1 ( M ( h j − ) for O H . We return M = arg max {| M ( E H ) | , | M ( O H ) |} as the independentset for G . See Figure 2 for an illustration. The initialization of all O ( κ ) variables and thecomputation of the first set M take O ( κ ) time. (Alternatively, a hash table would be morespace efficient, but could not provide the O (1)-update time guarantee.) (cid:73) Lemma 5.
The set M is an independent set of G = ( S , E ) with | M | ≥ | OP T | / andcan be computed in O ( κ ) time. Proof.
By construction, each set M ( h j ) for j ∈ [ κ ] is already an independent set for thesubset of squares stabbed by the line h j . In M we either choose the solution from all evenhorizontal lines (i.e., M ( E H )) or from all odd horizontal lines (i.e., M ( O H )). Therefore notwo squares s i and s j stabbed by different horizontal lines in M can intersect vertically.Hence, M is indeed a feasible independent set of G that can be computed in O ( κ ) time.Since S is partitioned into the squares stabbed by the set of even lines E H and thosestabbed by the set of odd lines O H and we choose the larger of the two independent sets M ( E H ) and M ( O H ), the solution M would contain at least | OP T | / M ( E H )and M ( O H ) were maximum independent sets of E H and O H , respectively. Recall, however,that for each horizontal line h j we took the maximum of the independent sets M h j and M h j restricted to the odd and even vertical lines. This means that for each h j the chosen set M ( h j ) contains at least half as many elements as a Max-IS of the squares stabbed by h j .This implies that | M | ≥ | OP T | / (cid:74) In the following step, when we move from G i to G i +1 , for any i ∈ [ N ], a square s x isinserted into S i or deleted from S i . Intuitively, we check the activity value of the grid point . Bhore, G. Li, and M. Nöllenburg 9 that s x intersects. If the update has no effect on its activity value, we keep M i +1 = M i .Otherwise, we update the activity value, the corresponding cardinality counters, and reportthe solution accordingly. All of these operations can be performed in O (1)-time.A more detailed description of the Insertion and
Deletion operations is given in thefollowing. When we move in the next step from G i to G i +1 (for some 1 ≤ i < N ), weeither insert a new square into S i or delete one square from S i . et s x be the square that isinserted or deleted and let g u,v (for some u, v ∈ [ κ ]) be the grid point that intersects s x . Wenext describe how to maintain a 4-approximate Max-IS with constant update time. Wedistinguish between the two operations
Insertion and
Deletion . Insertion: If g u,v is active for S i , there is at least one square intersecting g u,v that wasconsidered while computing M i . Hence, even if we would include s x in a modified independentset M i +1 , it would not make any impact on its cardinality. Hence, we simply set M i +1 ← M i .Otherwise, we perform a series of update operations: (1) Change the activity value of g u,v from 0 to 1. (2) Include s x in M h u (resp. M h u ) if v is odd (resp. even), and increase thevalue of p ( h u ) (resp. q ( h u )) by 1. This lets us reevaluate the cardinality c ( h u ) of M ( h u )in constant time. (3) Reevaluate M ( E H ) and M ( O H ) and their cardinalities based on theupdated value of c ( h u ). Note that none of these operations takes more than O (1) time. Deletion:
There are two cases: either s x ∈ M i or s x / ∈ M i . (i) s x ∈ M i : If there is no other square intersecting g u,v then we perform the followingthree steps. (1) Exclude s x from M i +1 and reset the activity value of g u,v to 0. (2)Decrease the value of p ( h u ) (resp. q ( h u )) by 1 if v is odd (resp. even). (3) Reevaluate M ( E H ) and M ( O H ).Else, there is at least one other square s ‘ = s x intersecting g u,v . We replace s x by s ‘ in M i +1 . This makes no impact on the calculations of M ( E H ), M ( O H ) and theircardinalities, therefore no further effort is needed. (ii) s x / ∈ M i : If there is a square other than s x intersecting g u,v , then g u,v stays active, elsewe reset its activity to 0. We do not need to reevaluate M ( E H ), M ( O H ), and theircardinalities in this situation. (cid:73) Lemma 6.
The set M i is an independent set of G i = ( S i , E i ) for each i ∈ [ N ] and | M i | ≥ | OP T i | / . Proof.
We prove the lemma by induction. Let us first argue that M i is indeed an independentset for G i assuming by induction that M i − is an independent set for G i − of size | M i − | ≥| OP T i − | /
4. This is easy to argue because the set M i is still composed of a set of squaresintersecting grid points that are at least 2 units apart horizontally and vertically and hencecannot intersect each other. If s x is a newly inserted square in S i then by construction it isonly considered for a solution if no other square previously intersected its grid point in S i − .It remains to show the approximation ratio. Let g u,v be the grid point intersecting s x .While due to the update some of the cardinalities of the independent sets M h u or M h u , andconsequently M ( h u ), M ( E H ), and M ( O H ), can change, the update procedure describedabove makes sure that the respective cardinality maximizations for M ( h u ) and finally for M i are reevaluated and updated. Accordingly, as in the proof of Lemma 5, we obtain that | M i | ≥ | OP T i | / (cid:74) Running Time.
We perform either an insertion or a deletion operation at every step i ∈ [ N ]. Both of theses operations perform only local operations: (i) compute the grid pointintersecting the updates square and check its activity value; (ii) reevaluate the values p ( h j ) h j g j, g j, . . . Figure 3
Illustration of a group on line h j for k = 3 with the two subgroups I ( h j ) and I ( h j ). and q ( h j ) of the horizontal line h j intersecting the square—this may or may not flip theindependent set M ( h j ) and its cardinality from p ( h j ) to q ( h j ), or vice versa; (iii) finally,if the cardinality of M ( h j ) changes, we reevaluate the sets M ( E H ) and M ( O H ). All theseoperations possibly change one activity value, increase or decrease at most three variablesby 1 and perform at most two comparison operation. Therefore, the overall update processtakes O (1) time in each step. Recall that the process to initialize the data structures for theset S and to compute M for G takes O ( κ ) time.Lemmas 5 and 6 and the above discussion of the the O (1) update time yield: (cid:73) Theorem 7.
We can maintain a -approximate maximum independent set in a dynamicunit square intersection graph, deterministically, in O (1) update time. k ) -Approximation Algorithm with O ( k ) Update Time
Next, we improve the approximation factor from 4 to 2(1 + k ), for any k ≥
1, by combiningthe shifting technique [29] with the insights gained from Section 4.1. This comes at thecost of an increase of the update time to O ( k log n ), which illustrates the trade-off betweensolution quality and update time. We reuse the grid partition and some notations fromSection 4.1. We first describe how to obtain a solution M for the initial graph G that is ofsize at least | OP T | / k ) and then discuss how to maintain this under dynamic updates.Let h j ∈ H be a horizontal stabbing line and let S ( h j ) ⊆ S be the set of squares stabbedby h j . Since they are all stabbed by h j , the intersection graph of S ( h j ) is equivalent to theunit interval intersection graph obtained by projecting each unit square s x ∈ S ( h j ) to a unitinterval i x on the line h j ; we denote this set of unit intervals as I ( h j ). First, we sort theintervals in I ( h j ) from left to right. Next we define k + 1 groups with respect to h j that areformed by deleting those squares and their corresponding intervals from S ( h j ) and I ( h j ),respectively, that intersect every k + 1-th grid point on h j , starting from some g j,α with α ∈ [ k + 1]. Now consider the k consecutive grid points on h j between two deleted grid pointsin one such group, say, { g j,‘ , . . . , g j,‘ + k − } for some ‘ ∈ [ κ ]. Let I k‘ ( h j ) ⊆ I ( h j ) be the set ofunit intervals intersecting the k grid points g j,‘ to g j,‘ + k − . We refer to them as subgroups .See Figure 3 for an illustration. Observe that the maximum size of an independent set ofeach subgroup is at most k , since the width of each subgroup is strictly less than k + 1 andeach interval has unit length.We compute M for G as follows. For each stabbing line h j ∈ H , we form the k +1 differentgroups of I ( h j ). For each group, a Max-IS is computed optimally and separately inside eachsubgroup. Since any two subgroups are horizontally separated and thus independent, we canthen take the union of the independent sets of the subgroups to get an independent set forthe entire group. This is done with the linear-time greedy algorithm to compute maximumindependent sets for interval graphs [26]. Let { M h j , . . . , M k +1 h j } be k +1 maximum independentsets for the k + 1 different groups and let M ( h j ) = arg max {| M h j | , | M h j | , . . . , | M k +1 h j |} beone with maximum size. We store its cardinality as c ( h j ) = max {| M ih j | | i ∈ [ k + 1] } . Next, . Bhore, G. Li, and M. Nöllenburg 11 we compute an independent set for E H , denoted by M ( E H ), by composing it from thebest solutions M ( h j ) from the even stabbing lines, i.e., M ( E H ) = S b κ/ c j =1 M ( h j ) and itscardinality | M ( E H ) | = P b κ/ c j =1 c ( h j ). Similarly, we compute an independent set for O H as M ( O H ) = S b κ/ c j =1 M ( h j − ) and its cardinality | M ( O H ) | = P b κ/ c j =1 c ( h j − ). Finally, wereturn M = arg max {| M ( E H ) | , | M ( O H ) |} as the solution for G . (cid:73) Lemma 8.
The independent set M of G = ( S , E ) can be computed in O ( n log n + kn ) time and | M | ≥ | OP T | / k ) . Proof.
Let us begin with the analysis for one horizontal line, say, h j . The objective is toshow that for h j , the size of our solution is least the optimum solution size for h j divided by(1 + k ). Recall that, a group of S ( h j ) and I ( h j ) is formed by deleting the squares and theircorresponding intervals from S ( h j ) and I ( h j ), respectively, which intersect every k + 1-thgrid point on h j , starting at some index α ∈ [ k + 1]. Now consider a hypothetical Max-IS
OP T ( h j ) on h j . By the pigeonhole principle, for at least one of the k + 1 groups of S ( h j )we deleted at most | OP T ( h j ) | / ( k + 1) squares from OP T ( h j ). Assume that this groupcorresponds to the independent set M ‘h j for some ‘ ∈ [ k + 1], which is maximum withineach subgroup. Then we know that | M ( h j ) | ≥ | M ‘h j | ≥ | OP T ( h j ) | − | OP T ( h j ) | / ( k + 1) = | OP T ( h j ) | / (1 + k ). Since this is true for each individual stabbing line h j and since any twolines in E H (or O H ) are independent, this implies that | M ( E H ) | ≥ | OP T ( E H ) | / (1 + k ) and | M ( O H ) | ≥ | OP T ( O H ) | / (1 + k ). Again by pigeonhole principle, if we choose M as thelarger of the two independent sets M ( E H ) and M ( O H ), then we lose by at most anotherfactor of 2, i.e., | M | ≥ | OP T | / k ).The algorithm requires O ( n log n ) time to sort all intervals and then computes Max-IS for the different subgroups with the linear time greedy algorithm. Since each square belongsto at most k different subgroups, this takes O ( kn ) time in total. (cid:74) Next, we describe a pre-processing step, which is required for the dynamic updates.
Pre-Processing:
For each horizontal line h j ∈ H , consider a group. For each subgroup I k‘ ( h j ) (for some ‘ ∈ [ k + 1]), we construct a balanced binary tree T ( I k‘ ( h j )) storing theintervals of I k‘ ( h j ) in left-to-right order (indexed by their left endpoints) in the leaves. Thisprocess is done for each group of every horizontal line h j ∈ H . We mark those leaves in T ( I k‘ ( h j )) as selected that correspond to an independent interval in the solution and maintaina list of pointers to those independent intervals. This tree also lets us quickly identify thelocation of an interval that is inserted or deleted. In fact, while we run the greedy algorithmon I k‘ ( h j ), we can already mark precisely the selected intervals for the independent set.When we perform the update step from G i = ( S i , E i ) to G i +1 = ( S i +1 , E i +1 ), either asquare is inserted into S i or deleted from S i . Let s x and i x be this square and its correspondinginterval. Let g u,v (for some u, v ∈ [ κ ]) be the grid point that intersects s x . Insertion:
The insertion of i x affects all but one of the groups on line h u . We describethe procedure for one such group on h u ; it is then repeated for the other groups. In eachgroup, i x appears in exactly one subgroup and the other subgroups remain unaffected. Thissubgroup, say I k‘ ( h u ), is determined by the index v of the grid point g u,v intersecting i x .First, we locate i x in the sorted list of intervals of I k‘ ( h u ), which can be done in O (log n ) timeby searching in the associated tree T ( I k‘ ( h u )). If i x is immediately left of a selected interval i y , but does not intersect the previous selected interval, then i x becomes a new selectedinterval that replaces i y and triggers a sequence of updates of the later selected intervals.Let us first consider the case that i x is not selected as a new independent interval. Then we simply insert i x into T ( I k‘ ( h u )) in O (log n ) time. Otherwise, we mark i x as selected, removethe selection mark from its successor interval i y , and replace i y by i x in the maintainedsubsolution. Since the right endpoint of i x is left of the right endpoint of i y , this changepossibly triggers a sequence of updates to the subsequent selected intervals.We thus identify in T ( I k‘ ( h u )) the leftmost interval i z that starts to the right of the rightendpoint of i x . This takes O (log n ) time. If this interval i z is not yet marked as selected, wereplace the previous successor of i x in the current list of selected intervals by i z and repeatthe update process for i z . Otherwise, if i z is already selected, we can stop the update of thesubsolution as there would be no further changes.Since a maximum independent set in each subgroup contains at most k intervals, theupdate time is O ( k log n ) per group and O ( k log n ) for all k affected groups.While doing the updates, we collect the new selected intervals as the Max-IS for thesubgroup I k‘ ( h u ). For all groups affected by the insertion of i x we update the correspondingindependent sets M ph u for p ∈ [ k + 1], whenever some updates of selected intervals werenecessary. Then we select the largest independent set of all k + 1 groups as M ( h j ) and updateits new cardinality in c ( h j ). Finally, we update the independent sets M ( E H ) and M ( O H ) andtheir cardinalities and return M i +1 = arg max {| M ( E H ) | , | M ( O H ) |} as the solution for G i +1 . Deletion:
Similar to the
Insertion operation, deleting i x affects all but one of the groupsdefined on h u . As before, we describe the procedure for one such group on h u ; it is thenrepeated for the other groups. In that group, i x appears in the interval set of exactly onesubgroup, say I k‘ ( h u ); the other subgroups remain unaffected. We use the tree T ( I k‘ ( h u )) tolocate i x and check whether it is a selected interval.If it is not a selected interval, we can simply delete it in O (log n ) time from T ( I k‘ ( h u ))and no further updates are necessary. Otherwise, we need to replace i x by a new selectedinterval, namely by its right neighbor i y . We mark i y as selected. Since i y is to the rightof i x , it may intersect with the next selected interval i w . If this is the case, we remove theselection mark of i w , find in O (log n ) time the leftmost interval i z starting to the right of i y , mark it as selected and repeat as long as the newly selected interval intersects the nextselected interval.At most k such updates to the set of selected intervals are needed, each of which requires O (log n ) time querying T ( I k‘ ( h u )). The total update time for all k affected groups is thus O ( k log n ). The newly selected intervals form the Max-IS for I k‘ ( h u ) and we update accord-ingly the independent sets and their cardinalities of all k affected groups. Finally, we update M ( E H ) and M ( O H ) and their cardinalities and return M i +1 = arg max {| M ( E H ) | , | M ( O H ) |} as the solution for G i +1 = ( S i +1 , E i +1 ). (cid:73) Lemma 9.
The set M i is an independent set of G i = ( S i , E i ) for each i ∈ [ N ] and | M i | ≥ | OP T i | / k ) . Proof.
The fact that M i is an independent set follows directly from the construction: Theselected intervals forming the independent set of each subgroup are disjoint by definition,any two subgroups in one group are horizontally sufficiently separated and thus independent,and finally in M i either all selected stabbing lines are even or all are odd, and thus verticallysufficiently separated and independent.It remains to show the approximation ratio, which we do by induction. By Lemma 8 theclaim is true for M . So let us assume the lemma holds for M i − and let s x be the squareinserted or deleted in step i ≥
2. Let g u,v be the grid point intersecting s x and let i x be itscorresponding unit interval. . Bhore, G. Li, and M. Nöllenburg 13 For all unaffected stabbing lines h j we know by induction that their computed independentsets M ( h j ) are (1 + k )-approximate. We need to show that this remains true for M ( h u ) aswell, for which it is sufficient to prove that in all affected subgroups on h u we maintain a Max-IS when doing the selection update operations. Assume for contradiction that for somesubgroup I k‘ ( h u ) there exists an independent set that contains at least one interval morethan the set of seeds selected by our update algorithm. An independent set of this cardinalitywill also be computed when running from scratch the greedy Max-IS algorithm on the set I k‘ ( h u ), which always selects the leftmost possible independent interval. But in fact, ourupdate algorithm constructs the same set of independent intervals. The intervals that areentirely left of i x are unaffected by our updates and thus are a maximum independent setby induction. If i x becomes a new selected interval or is a selected interval that is deleted,then we must update our selected set of independent intervals. But since all the intervalsare sorted and of unit length, the intervals computed by the left-to-right greedy algorithmare precisely those intervals that our update procedure selects, namely always the leftmostpossible intervals to the right of the previous selected interval. So the set of selected intervalsis indeed a Max-IS for I k‘ ( h u ).The remaining arguments for the claimed approximation ratio of M i +1 are exactly thesame as in the proof of Lemma 8. (cid:74) Running Time.
At every step, we perform either an insertion or a deletion operation.Recall from the description of these two operations that an update affects a single stabbingline, say h u , for which we have defined k + 1 groups. Of those groups, k are affected by theupdate, but only inside a single subgroup. Updating a subgroup can trigger up to k selectionupdates, each taking O (log n ) time. In total this yields an update time of O ( k log n ).With Lemma 9 and the above update time discussion we obtain: (cid:73) Theorem 10.
We can maintain a k ) -approximate maximum independent set in adynamic unit square intersection graph, deterministically, in O ( k log n ) update time. O ( ω log n ) Update Time
We finally design a 2-approximation algorithm for the
Max-IS problem on dynamic axis-aligned unit height, but arbitrary width rectangles. Let B be the bounding box of thedynamic set of rectangles e R = S i ∈ [ N ] R i . We begin by dividing B into horizontal stripsof height 1 defined by the set H = { h , . . . , h κ } of κ = O ( n ) horizontal lines. We assume,w.l.o.g., that every rectangle in e R is stabbed by exactly one line in H . For a set of rectangles R , we denote the subset stabbed by a line h j as R ( h j ) ⊆ R .We first describe how to obtain an independent set M for the initial graph G = ( R , E )such that | M | ≥ | OP T | / h j ∈ H , we compute a maximum independent set for R ( h j ). Theset R i ( h j ) (for any i ∈ [ N ] and j ∈ [ κ ]) can again be seen as an interval graph. For a setof n intervals, a Max-IS can be computed by a left-to-right greedy algorithm visiting theintervals in the order of their right endpoints in O ( n log n ) time. So for each horizontal line h j ∈ H , let M ( h j ) be a Max-IS of R ( h j ), and let c ( h j ) = | M ( h j ) | . Then we construct theindependent set M ( E H ) = S b κ/ c j =1 ( M ( h j )) for E H . Similarly, we construct the independentset M ( O H ) = S b κ/ c j =1 ( M ( h j − ) for O H . We return M = arg max {| M ( E H ) | , | M ( O H ) |} asthe independent set for G = ( R , E ). See Figure 4 for an illustration. (cid:73) Lemma 11 (Theorem 2, [3]) . The set M is an independent set of G = ( R , E ) with | M | ≥ | OP T | / and can be computed in O ( n log n ) time. h h h h Figure 4
Example instance with four horizontal lines. Red rectangles represent the computed2-approximate solution, which here is M ( E ( H )). We describe the following pre-processing step to initialize in O ( n log n ) time the datastructures that are required for the subsequent dynamic updates. Pre-Processing:
Consider a stabbing line h j and the stabbed set of rectangles R i ( h j ) forsome i ∈ [ N ]. We denote the corresponding set of intervals as I ( h j ). We build a balancedbinary search tree T l ( I ( h j )), storing the intervals in I ( h j ) in left-to-right order based ontheir left endpoints. This is called the left tree of I ( h j ). We augment the left tree such thateach tree node additionally stores a pointer to the interval with leftmost right endpoint inits subtree. This pointer structure can easily be computed by a bottom-up pass through T l ( I ( h j )). Note that a leaf update in T l ( I ( h j )) takes O (log n ) time as for standard binarysearch trees, but we can in the same O (log n ) time propagate the change that potentiallyaffects the leftmost right endpoints of the tree nodes along the path to the root. Additionally,we store the set of selected independent intervals for the Max-IS of I ( h j ) in left-to-rightorder in another balanced binary search tree T s ( I ( h j )) (the so-called solution tree ). Let ω j be the cardinality of the maximum independent of I ( h j ) for j ∈ [ κ ], and let ω = max j ω j bethe maximum of these cardinalities over all stabbing lines h j .When we move from G i to G i +1 (for some 1 ≤ i < N ), either we insert a new rectangleinto R i or delete one rectangle from R i . Let r x be the rectangle that is inserted or deleted,let i x be its corresponding interval, and let h j (for some j ∈ [ κ ]) be the horizontal line thatintersects r x . In what follows, we describe how to maintain a 2-approximate Max-IS with O ( ω j log n ) = O ( ω log n ) update time. We distinguish Insertion and
Deletion . Insertion:
We first determine whether i x should be a new selected interval or not. Becausethe greedy algorithm for constructing the Max-IS visits the intervals in left-to-right orderbased on the right endpoints, we need to reconstruct the state of the algorithm when itwould visit i x . We query the solution tree T s ( I ( h j )) with both endpoints of i x in O (log ω j )time. If and only if both search paths end up between the same two leaves belonging to twoconsecutive selected intervals i y and i z (considering their right endpoints), then i x wouldhave been chosen as the next selected interval after i y and before i z in the greedy algorithm.This implies that i y and i x are independent, but i x and i z may or may not intersect.If the two search paths in the solution tree are different, then i x does not become a newselected interval, and we simply insert it into T l ( I ( h j )) in O (log n ) time. Else we also insert i x into T l ( I ( h j )), but we also have to perform a sequence of selection update operations, whichare more involved for intervals of arbitrary length compared to the updates in Section 4.2.Figure 5 shows an example. First we mark i x as selected and insert it into T s ( I ( h j )). Nowwe need to identify the next selected interval right of i x that would have been found by thegreedy algorithm. We use the left tree T l ( I ( h j )) to search in O (log n ) time for the interval . Bhore, G. Li, and M. Nöllenburg 15 (a) i x h j (b) h j i y i (cid:48) z Figure 5
Illustration of the updates triggered by the insertion of an interval; selected independentintervals are marked by a dotted bounding box and intervals intersected by a selected interval havethe same color as the rightmost such interval. (a) Before insertion of i x , (b) after insertion of i x . i z with leftmost right endpoint, whose left endpoint is right of the right endpoint p of i x .More precisely, we search for p in T l ( I ( h j )) and whenever the search path branches into theleft subtree, we compare whether the leftmost right endpoint stored in the root of the rightsubtree is left of the right endpoint of the current candidate interval. Once a leaf is reached,the leftmost found candidate interval is the desired interval i z . This interval i z is preciselythe first interval after i x in the order considered by the greedy algorithm that is independentof i x and thus must be the next selected interval. If i z = i z , we repeat the update processfor i z as if it would have been the newly inserted interval until we reach the end of I ( h j );otherwise we keep i z as the successor of i x and stop the update process.For each update of a selected interval, we perform one search in T l ( I ( h j )) in O (log n )time. There are at most ω j updates, so the update time is O ( ω j log n ). Finally, we needto delete O ( ω j ) old selected intervals from and insert O ( ω j ) new selected intervals into thesolution tree T s ( I ( h j )), which takes O (log ω j ) time for each insertion and deletion. We nowre-evaluate the new Max-IS M ( h j ) and its cardinality c ( h j ), which possibly affects M ( E H )or M ( O H ). We obtain the new independent set M i +1 = arg max {| M ( E H ) | , | M ( O H ) |} for G i +1 = ( R i +1 , E i +1 ). Deletion:
If the interval i x to be deleted is not a selected interval, it is sufficient to deleteit from the left tree T l ( I ( h j )) in O (log n ) time. Otherwise, if i x is a selected interval, let i y be the selected interval preceding i x in the solution tree T s ( I ( h j )). We first delete i x from T l ( I ( h j )) and T s ( I ( h j )). Then we need to select a new interval to replace i x according to thegreedy Max-IS algorithm, which is the interval i z whose right endpoint is leftmost amongall intervals that are completely to the right of i y . We find this interval i z again by a searchin the left tree T l ( I ( h j )) with the right endpoint of i y as the query point. We make i z anew selected interval and use the right endpoint of i z as the query point for finding the nextselected interval in T l ( I ( h j )). We repeat this process until we have reached the last intervalof I ( h j ).As for the Insertion step, each update of a selected interval requires O (log n ) timedue to the query for the next selected interval in T l ( I ( h j )). There are O ( ω j ) such updates.Further, we need to update the solution tree T s ( I ( h j )) by performing O ( ω j ) insertions anddeletions of seeds, each in O (log ω j ) time. Once all updates to the selected intervals andthe data structures for I ( h j ) are done, we re-evaluate the new Max-IS M ( h j ) and itscardinality c ( h j ), which possibly affects M ( E H ) or M ( O H ). This yields the new independentset M i +1 = arg max {| M ( E H ) | , | M ( O H ) |} for G i +1 = ( R i +1 , E i +1 ). (cid:73) Lemma 12.
The set M i is an independent set of G i = ( R i , E i ) for each i ∈ [ N ] and | M i | ≥ | OP T i | / . Proof.
We prove the lemma by induction. From Lemma 11 we know that M satisfies theclaim, and in particular each set M ( h ) for h ∈ H is a Max-IS of the interval set I ( h ). So let us consider the set M i for i ≥ M i − satisfies the claim by the inductionhypothesis. Let r x and i x be the updated rectangle and its interval, and assume that itbelongs to the stabbing line h j . Then we know that for each h k ∈ H with k = j the set M ( h k ) is not affected by the update to r x and thus is a Max-IS by the induction hypothesis.It remains to show that the update operations described above restore a
Max-IS M ( h j )for the set I ( h j ). But in fact the updates are designed in such a way that the resulting setof selected intervals is identical to the set of intervals that would be found by the greedy Max-IS algorithm for I ( h j ). Therefore M ( h j ) is a Max-IS for I ( h j ) and by the pigeonholeprinciple | M i | ≥ | OP T i | / (cid:74) Running Time.
Each update of a rectangle r x (and its interval i x ) triggers either an Insertion or a
Deletion operation on the unique stabbing line of r x . As we have arguedin the description of these two update operations, the insertion or deletion of i x requires one O (log n )-time update in the left tree data structure. If i x is a selected independent interval,the update further triggers a sequence of at most ω j selection updates, each of which requires O (log n ) time. Hence the update time is bounded by O ( ω j log n ) = O ( ω log n ). Recall that ω j and ω are output-sensitive parameters describing the maximum size of an independentset of I ( h ) for a specific stabbing line h = h j or any stabbing line h . (cid:73) Theorem 13.
We can maintain a -approximate maximum independent set in a dynamicunit-height arbitrary-width rectangle intersection graph, deterministically, in O ( ω log n ) time,where ω is the cardinality of a maximum independent set of the rectangles stabbed by thehorizontal stabbing line affected by the dynamic update. (cid:73) Remark 14.
We note that Gavruskin et al. [24] gave a dynamic algorithm for maintaininga
Max-IS on proper interval graphs. Their algorithm runs in amortized time O (log n ) forinsertion and deletion, and O (log n ) for element-wise decision queries. The complexity toreport a Max-IS J is Θ( | J | ). Whether the same result holds for general interval graphswas posed as an open problem [24]. Our algorithm in fact solves the Max-IS problem onarbitrary dynamic interval graphs, which is of independent interest. Moreover, it explicitlymaintains a
Max-IS at every step.
We implemented all our
Max-IS approximation algorithms presented in Sections 3 and 4 inorder to empirically evaluate their trade-offs in terms of solution quality , i.e., the cardinalityof the computed independent sets, and update time measured on a set of suitable syntheticand real-world map-labeling benchmark instances with unit squares. The goal is to identifythose algorithms that best balance the two performance criteria. Moreover, for smallerbenchmark instances with up to 2 000 squares, we compute exact
Max-IS solutions usinga MaxSAT model by Klute et al. [32] that we solve with MaxHS 3.0 (see ).These exact solutions allow us to evaluate the optimality gaps of the different algorithmsin light of their worst-case approximation guarantees. Finally, we investigate the speed-upsgained by using our dynamic update algorithms compared to the baseline of recomputingnew solutions from scratch with their respective static algorithm after each update.
Implemented Algorithms.
We have implemented the following five algorithms (and theirgreedy augmentation variants) in C++. . Bhore, G. Li, and M. Nöllenburg 17
MIS-graph
A naive graph-based dynamic
MIS algorithm, explicitly maintaining the squareintersection graph and a MIS [4, Sec. 3]. In order to evaluate and compare the performanceof our algorithm
MIS-ORS (Section 3) for the
MIS problem, we have implemented thisalternative dynamic algorithm. This algorithm, instead of maintaining the currentinstance in a dynamic geometric data structure, maintains the rectangle intersectiongraph explicitly as a baseline approach. We use standard adjacency lists to represent theintersection graph, implemented as unordered sets in C++. Now, to obtain a
MIS atthe first step, we add an arbitrary (unmarked) vertex v to the solution and mark N ( v )in the corresponding intersection graph. This process is repeated iteratively until thereis no unmarked vertex left in the intersection graph. Clearly, by following this greedymethod, we obtain a MIS . Moreover, for each vertex v , we maintain an augmenting counter that stores the number of vertices from its neighborhood N ( v ) that are containedin the current MIS .This approach handles the updates in a straightforward manner. When a new vertex is in-serted, its corresponding rectangle introduces new intersections in the current intersectiongraph. Therefore, when adding this vertex, we also determine the edges that are requiredto be added to the intersection graph. Notice that, unlike the canonical vertex updateoperation defined in the literature, where the adjacencies of the new vertex are part of thedynamic update, here, we actually need to figure out the neighborhood of a vertex. Thisis done by iterating over each vertex and checking whether its corresponding rectangle isoverlapping with the newly inserted rectangle. Thus, it takes O ( n ) time to obtain theneighborhood of this vertex. If the newly inserted rectangle has no intersection withany rectangle from the current solution, then we simply add its vertex to the solution;otherwise, we ignore it. Finally, we update the counters. If a vertex is deleted, we updatethe intersection graph by deleting its corresponding rectangle. If the deleted vertex wasin the solution, then we decrease the counters of its neighbors by 1. Once the counterof a vertex is updated to 0, we add this vertex into the solution. Both the insertion(after computing N ( v )) and deletion operation for a vertex v take O (deg( v )) time eachto update the intersection graph and the MIS solution.
MIS-ORS
The dynamic
MIS algorithm based on orthogonal range searching (Section 3);this algorithm provides a 4-approximation. In the implementation we used the dynamicorthogonal range searching data structure implemented in CGAL (version 4.11.2), which isbased on a dynamic Delaunay triangulation [35, Chapter 10.6]. Hence, this implementationdoes not provide the sub-logarithmic worst-case update time of Theorem 3. grid
The grid-based 4-approximation algorithm (Section 4.1). grid- k The shifting-based 2(1+ k )-approximation algorithm (Section 4.2). In the experimentswe use k = 2 (i.e., a 3-approximation) and k = 4 (i.e., a 2 . line The stabbing-line based 2-approximation algorithm (Section 4.3).Since the algorithms grid , grid- k , and line are based on partitioning the set of squaresand considering only sufficiently segregated subsets, they produce a lot of white space inpractice. For instance, they ignore the squares stabbed by either all the even or all theodd stabbing lines completely in order to create isolated subinstances. In practice, it istherefore interesting to augment the computed approximate Max-IS by greedily addingindependent, but initially discarded squares. We have also implemented the greedy variantsof these algorithms, which are denoted as g-grid , g-grid- k , and g-line . System Specifications.
The experiments were run on a server equipped with two IntelXeon E5-2640 v4 processors (2.4 GHz 10-core) and 160GB RAM. The machine ran the 64-bit post-CH peaks-AT hotels-CH hotels-AT peaks-CH hamlets-CHfeatures ( n ) 646 652 1 788 2 209 4 320 4 326overlaps ( m ) 5 376 5 418 28 124 68 985 107 372 159 270density ( m/n ) 8.32 8.31 15.73 31.23 24.85 36.92 Table 1
Specification of the six OSM instances. version of Ubuntu Bionic (18.04.2 LTS). The code was compiled with g++ 7.4.0.
Benchmark Data.
We created three types of benchmark instances. The synthetic data setsconsist of n × B of size 1 080 ×
720 pixels,which also creates different densities. The real-world instances use the same square size, butgeographic feature distributions. For the updates we consider three models: insertion-only , deletion-only , and mixed , where the latter selects insertion or deletion uniformly at random. Gaussian
In the Gaussian model, we generate n squares randomly in B according to anoverlay of three Gaussian distributions, where 70% of the squares are from the firstdistribution, 20% from the second one, and 10% from the third one. The means aresampled uniformly at random in B and the standard deviation is 100 in both dimensions. Uniform
In the uniform model, we generate n squares in B uniformly at random. Real-world
We created six real-world data sets by extracting point features from Open-StreetMap (OSM), see Table 1 for their detailed properties.
Time-quality trade-offs.
For our first set of experiments we compare the five implementedalgorithms, including their greedy variants, in terms of update time and size of the computedindependent sets. Figure 6 shows scatter plots of runtime vs. solution size on uniform andGaussian benchmarks, where algorithms with dots in the top-left corner perform well in bothmeasures.We first consider the results for the uniform instances with n = 10 000 squares in the toprow of Figure 6. Each algorithm performed N = 400 updates, either insertions (Figure 6a)or deletions (Figure 6b) and each update is shown as one point in the respective color.Both plots show that the two MIS algorithms compute the best solutions with almost thesame size and well ahead of the rest. While MIS-ORS is clearly faster than
MIS-graph oninsertions, they are comparably fast for deletions, with some slower outliers of
MIS-ORS . Theapproximation algorithms grid , grid- grid-
4, and line (without the greedy optimizations)show their predicted relative behavior: The better the solution quality, the worse the updatetimes. Algorithms line and g-line show a wide range of update times, spanning almosttwo orders of magnitude. Adding the greedy optimization drastically improves the solutionquality in all cases, but typically at the cost of higher runtimes. For g-grid- k the algorithmsget slower by an order of magnitude and increase the solution size by 30–50%. For g-grid ,the additional runtime is not as significant (but deletions are slower than insertions), andthe solution size almost doubles. Finally, g-line is nearly as fast as line , and reaches the bestquality among the approximation algorithms with about 80% of the MIS solutions, but fasterby one or two orders of magnitude.For the results of the Gaussian instances with n = 10 000 squares and N = 400 updatesplotted in Figures 6c (insertions) and 6d (deletions) we observe the same ranking between the . Bhore, G. Li, and M. Nöllenburg 19 runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (a) Uniform, n = 10 000, 400 insertions runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (b) Uniform, n = 10 000, 400 deletions runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (c) Gaussian, n = 10 000, 400 insertions runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (d) Gaussian, n = 10 000, 400 deletions Figure 6
Time-quality scatter plots for synthetic benchmark instances. The x-axis (log-scale)shows runtime, the y-axis shows the solution size. different algorithms. However, due to the non-uniform distribution of squares, the solutionsizes are more varying, especially for the insertions. For the deletions it is interesting tosee that grid and
MIS-graph have more strongly varying runtimes, which is in contrast tothe deletions in the uniform instance, possibly due to the dependence on the vertex degree.The best solutions are computed by
MIS-ORS and
MIS-graph , which show similar deletiontimes, but the insertion times of
MIS-ORS are one order of magnitude faster than
MIS-graph .Algorithm g-line again reaches more than 80% of the quality of the MIS algorithms, with aspeed-up between one and two orders of magnitude.
Optimality gaps.
Next, let us look at the results of the real-world instances in Figure 7.The first four instances in Figure 7a–d, were small enough so that we could compute each
Max-IS exactly with MaxHS and compare the solutions of the approximation algorithmswith the optimum on the y-axis. The largest two instances in Figure 7e and 7f plot the solution size on the y-axis. First, let us consider Figure 7c as a representative, which isbased on a data set of 1 788 hotels and hostels in Switzerland with mixed updates of 10%of the squares ( N = 179). Generally speaking, the results of the different algorithms aremuch more overlapping in terms of quality than for the synthetic instances. The plot showsthat the MIS algorithms reach consistently between 80% and 85% of the optimum, butare sometimes outperformed by g-grid- g-line . Regarding the runtime, MIS-ORS hasmore homogeneous update times ranging between the extrema of
MIS-graph , which suffersfrom the rather slow insertions. The original approximations are well above their respectiveworst-case ratios, but stay between 45% and 65% of the optimum. The greedy extensionspush this towards larger solutions, at the cost of higher runtimes. However, g-line seemsto provide a very good balance between quality and speed. We point out that because theupdates comprise insertions and deletions, the marks for algorithms that are sensitive to theupdate type, such as g-grid and
MIS-graph form two separate runtime clusters. The samerelative observations of the algorithms’ performance can be made in Figures 7a–d, yet theyshow different absolute quality offsets and variance.Let us next consider the largest OSM instance in Figure 7f. It again reflects the samefindings as obtained from the smaller instances. The instance consists of n = 4 326 hamlets inSwitzerland with 10% mixed updates ( N = 433) and is denser by a factor of about 2 . ±
50 squares. In contrast, g-line , the best of the approximationalgorithms, is competing well and is more stable in terms of solution size and again about anorder of magnitude faster than the MIS algorithms. The update-type dependent behavior of
MIS-graph with its significantly slower insertions is observed once more, making
MIS-ORS the better choice for a mixed update model.Finally, Figure 8 shows the optimality ratios of the algorithms for small uniform andGaussian instances with n = 1 000 squares. They confirm our earlier observations, but alsoshow that for these small instances, MIS-graph is about as fast as
MIS-ORS for insertionsand faster than
MIS-ORS for deletions. This is because the graph size and vertex degrees donot yet influence the running time of
MIS-graph strongly. Yet, as the next experiment shows,this changes drastically, as the instance size grows.
Runtimes.
In our last experiment, we explore in more detail the scalability of the algorithmsfor larger instances, both relative to each other and in comparison to the re-computationtimes of their corresponding static algorithms. We generated one random instance with n = 1 000 k squares for each k ∈ { , , , , , } and measured the average update timesover n/
10 insertions or deletions. The results for the Gaussian and uniform model are plottedin Figure 9. Considering the update times for insertions, we confirm the observations fromthe scatter plots in terms of the performance ranking. Most algorithms grow only very slowlyin terms of their running time, with the notable exception of
MIS-graph , but that was to beexpected. For deletions,
MIS-graph is initially faster than
MIS-ORS , but again shows thesteepest increase in runtime. Deletions in the Gaussian model also affect the runtime of grid and g-grid quite noticeably, yet one order of magnitude below
MIS-graph .In the comparison with their non-dynamic versions, i.e., re-computing solutions after eachupdate, the dynamic algorithms indeed show a significant speed-up in practice, already forsmall instance sizes of n = 1 000, and even more so as n grows (notice the different y-offsets).For some algorithms, including MIS-ORS and g-line , this can be as high as 3–4 orders of . Bhore, G. Li, and M. Nöllenburg 21 runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (a) post-CH, 10% mixed updates runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (b) peaks-AT, 10% mixed updates runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (c) hotels-CH, 10% mixed updates runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (d) hotels-AT, 10% mixed updates runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (e) peaks-CH, 10% mixed updates runtime[ms] s o l u t i on s i z e | A | lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (f) hamlets-CH, 10% mixed updates Figure 7
Time-quality scatter plots for the OSM instances. The x-axis (log-scale) shows runtime.The y-axis shows the quality ratio compared to an optimal
Max-IS solution for the smaller instances(a)–(d), and the solution size for the larger instances (e)–(f). runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (a) Uniform, 100 insertions runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (b) Uniform, 100 deletions runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (c) Gaussian, 100 insertions runtime[ms] qua li t y r a t i o ( | A | / | O P T | ) lineg-linegridg-gridgrid-2g-grid-2grid-4g-grid-4MIS-ORSMIS-graph (d) Gaussian, 100 deletions
Figure 8
Time-quality scatter plots for uniform and Gaussian instances with n = 1 000 squares.The x-axis (log-scale) shows runtime. The y-axis shows the quality ratio compared to an optimal Max-IS solution. magnitude for n = 32 000. It clearly confirms that the investigation of algorithms for dynamicMIS and Max-IS problems for rectangles is well justified also from a practical point of view.
Our experimental evaluation provides several interesting insights into the practical perfor-mance of the different algorithms. First of all, both
MIS -based algorithms generally showedthe best solution quality in the field, reaching 85% of the exact
Max-IS size, where we couldcompare against optimal solutions. This is in strong contrast to their factor-4 worst-caseapproximation guarantee of only 25%.Our algorithm
MIS-ORS avoids storing the intersection graph explicitly. Instead, weonly store the relevant geometric information in a dynamic data structure and derive edgeson demand. Therefore it breaks the natural barrier of Ω(∆) (amortized) vertex update in a . Bhore, G. Li, and M. Nöllenburg 23 instance size r un t i m e [ m s ] line g-line grid g-grid grid-2 g-grid-2 grid-4 g-grid-4 MIS-ORS MIS-graph instance size r un t i m e [ m s ] (a) Update times for insertions (Gaussian) instance size r un t i m e [ m s ] (b) Update times for deletions (Gaussian) instance size r un t i m e [ m s ] (c) Re-computation times for insertions (Gaus-sian) instance size r un t i m e [ m s ] (d) Re-computation times for deletions (Gaus-sian) instance size r un t i m e [ m s ] (e) Update times for insertions (uniform) instance size r un t i m e [ m s ] (f) Update times for deletions (uniform) instance size r un t i m e [ m s ] (g) Re-computation times for insertions (uni-form) instance size r un t i m e [ m s ] (h) Re-computation times for deletions (uni-form)
Figure 9
Log-log runtime plots (notice the different y-offsets) for dynamic updates and re-computation on Gaussian instances (a)–(d) and uniform instances (e)–(h) of size n = 1 000 to 32 000,averaged over n/
10 updates. Error bars indicate the standard deviation. dynamic graph, where ∆ is the maximum degree in the graph. However, it has to find theintersections using the complex range query, which takes O (log n ) time. We did not involveany geometric data structure in the baseline MIS approach MIS-graph . Recall that, theupdate of the intersection graph when adding a new rectangle includes the time to figure outthe neighborhood of the newly added vertex. Therefore, the graph-based algorithm showed aslow insertion update and was quite sensitive to the size of instances in insertion updates.However, the deletion update only depends on the degree of the involved vertex, not thesize of instances directly. And as expected, the graph-based algorithm was indeed muchfaster for small instances, but
MIS-ORS was more scalable in our experiment. However, theintersection graph update for
MIS-graph can be improved by using additionally a geometricdata structure to store the rectangle set and detect intersections. We expect that it wouldshow improvements for insertion updates, but may slow down deletions, since the state-of-theart data structure provides only an amortized update time guarantee. Therefore, it is an openquestion whether the performance of
MIS-graph can indeed be improved by using a suitabledynamic geometric data structure. Note,
MIS-ORS too, can sometimes show slower deletions,due to the necessary complex orthogonal range search in some cases. Recall that, in ourimplementation, we used a dynamic range searching data structure from CGAL, which doesnot provide the theoretical sub-logarithmic worst-case update time of Chan et al. [14] used inTheorem 3. Exploring how
MIS-ORS can benefit from such a state-of-the-art dynamic datastructure in practice remains to be investigated in future work. Notwithstanding, it remainsto state that even with the suboptimal data structure,
MIS-ORS was able to compute itssolutions for up to 32 000 squares in less than 1ms. So if solution quality is the priority, thenthe
MIS-ORS algorithm is the method of choice. It provides the best solutions (togetherwith
MIS-graph ), but is significantly more scalable.An expected observation is that while consistently exceeding their theoretical guarantees,the approximation algorithms do not perform too well in practice due to their pigeonholechoice of too strictly separated subinstances. However, a simple greedy augmentation ofthe approximate solutions can boost the solution size significantly, and for some algorithmseven to almost that of the MIS algorithms. Of course, at the same time this increases theruntime of the algorithms. We want to point out g-line , the greedy-augmented version ofthe 2-approximation algorithm line , as it computes very good solutions, even comparable orbetter than
MIS-ORS and
MIS-graph for the real-world instances, and at 80% of the MISsolutions for the synthetic instances. At the same time, g-line is still significantly faster than
MIS-ORS and
MIS-graph and thus turns out to be a well-balanced compromise betweentime and quality. It would be our recommended method if
MIS-ORS or MIS-graph are tooslow for an application.
We investigated the
MIS and
Max-IS problems on dynamic sets of uniform rectanglesand uniform-height rectangles from an algorithm engineering perspective, providing boththeoretical results for maintaining a
MIS or an approximate
Max-IS and reporting insightsfrom an experimental study. Open problems for future work include (i) finding
Max-IS sublinear-update-time approximation algorithms for dynamic unit squares with approxi-mation ratio better than 2, (ii) studying similar questions for dynamic disk graphs, and(iii) implementing improvements such as a sub-logarithmic dynamic range searching datastructure to speed-up our algorithm
MIS-ORS . Moreover, it would be interesting to designdynamic approximation schemes for
Max-IS that maintain stability in a solution. . Bhore, G. Li, and M. Nöllenburg 25
References Amir Abboud, Raghavendra Addanki, Fabrizio Grandoni, Debmalya Panigrahi, and BarnaSaha. Dynamic set cover: improved algorithms and lower bounds. In
Symposium on Theoryof Computing (STOC’19) , pages 114–125. ACM, 2019. doi:10.1145/3313276.3316376 . Anna Adamaszek and Andreas Wiese. Approximation schemes for maximum weight indepen-dent set of rectangles. In
Foundations of Computer Science (FOCS’13) , pages 400–409. IEEE,2013. doi:10.1109/FOCS.2013.50 . Pankaj K Agarwal, Marc Van Kreveld, and Subhash Suri. Label placement by maximumindependent set in rectangles.
Computational Geometry , 11(3-4):209–218, 1998. doi:10.1016/S0925-7721(98)00028-5 . Sepehr Assadi, Krzysztof Onak, Baruch Schieber, and Shay Solomon. Fully dynamic maximalindependent set with sublinear update time. In
Symposium on Theory of Computing (STOC’18) ,pages 815–826, 2018. doi:10.1145/3188745.3188922 . Sepehr Assadi, Krzysztof Onak, Baruch Schieber, and Shay Solomon. Fully dynamic maximalindependent set with sublinear in n update time. In Symposium on Discrete Algorithms(SODA’19) , pages 1919–1936. SIAM, 2019. doi:10.1137/1.9781611975482.116 . Egon Balas and Chang Sung Yu. Finding a maximum clique in an arbitrary graph.
SIAMJournal on Computing , 15(4):1054–1068, 1986. doi:10.1137/0215075 . Ken Been, Martin Nöllenburg, Sheung-Hung Poon, and Alexander Wolff. Optimizing activeranges for consistent dynamic map labeling.
Comput. Geom. Theory Appl. , 43(3):312–328,2010. doi:10.1016/j.comgeo.2009.03.006 . Soheil Behnezhad, Mahsa Derakhshan, MohammadTaghi Hajiaghayi, Cliff Stein, and MadhuSudan. Fully dynamic maximal independent set with polylogarithmic update time. In
Foundations of Computer Science (FOCS’19) , pages 382–405. IEEE, 2019. doi:10.1109/FOCS.2019.00032 . Aaron Bernstein, Sebastian Forster, and Monika Henzinger. A deamortization approach fordynamic spanner and dynamic maximal matching. In
Symposium on Discrete Algorithms(SODA’19) , pages 1899–1918. SIAM, 2019. doi:10.1137/1.9781611975482.115 . Sayan Bhattacharya, Deeparnab Chakrabarty, and Monika Henzinger. Deterministic fullydynamic approximate vertex cover and fractional matching in o (1) amortized update time. In Integer Programming and Combinatorial Optimization (IPCO’17) , volume 10328 of
LNCS ,pages 86–98. Springer, 2017. doi:10.1007/978-3-319-59250-3_8 . Sayan Bhattacharya, Deeparnab Chakrabarty, Monika Henzinger, and Danupon Nanongkai.Dynamic algorithms for graph coloring. In
Symposium on Discrete Algorithms (SODA’18) ,pages 1–20. SIAM, 2018. doi:10.1137/1.9781611975031.1 . Parinya Chalermsook and Julia Chuzhoy. Maximum independent set of rectangles. In
Symposium on Discrete Algorithms (SODA’09) , pages 892–901. SIAM, 2009. doi:10.1137/1.9781611973068.97 . Timothy M Chan and Sariel Har-Peled. Approximation algorithms for maximum independentset of pseudo-disks.
Discrete & Computational Geometry , 48(2):373–392, 2012. doi:10.1007/s00454-012-9417-5 . Timothy M. Chan and Konstantinos Tsakalidis. Dynamic orthogonal range searching on theRAM, revisited. In Boris Aronov and Matthew J. Katz, editors,
Computational Geometry(SoCG’17) , volume 77 of
LIPIcs , pages 28:1–28:13. Schloss Dagstuhl – Leibniz-Zentrum fürInformatik, 2017. doi:10.4230/LIPIcs.SoCG.2017.28 . Shiri Chechik and Tianyi Zhang. Fully dynamic maximal independent set in expected poly-logupdate time. In
Foundations of Computer Science (FOCS’19) , pages 370–381. IEEE, 2019. doi:10.1109/FOCS.2019.00031 . Julia Chuzhoy and Alina Ene. On approximating maximum independent set of rectangles.In
Foundations of Computer Science (FOCS’16) , pages 820–829. IEEE, 2016. doi:10.1109/FOCS.2016.92 . Graham Cormode, Jacques Dark, and Christian Konrad. Independent sets in vertex-arrivalstreams. In
International Colloquium on Automata, Languages, and Programming (ICALP’19) ,volume 132 of
LIPIcs , pages 45:1–45:14. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik,2019. doi:10.4230/LIPIcs.ICALP.2019.45 . David Eppstein, Zvi Galil, and Giuseppe F. Italiano. Dynamic graph algorithms. In Mikhail J.Atallah, editor,
Algorithms and Theory of Computation Handbook , chapter 8. CRC Press, 1999. doi:10.1.1.43.8372 . Thomas Erlebach, Klaus Jansen, and Eike Seidel. Polynomial-time approximation schemesfor geometric intersection graphs.
SIAM Journal on Computing , 34(6):1302–1323, 2005. doi:10.1137/s0097539702402676 . Michael Formann and Frank Wagner. A packing problem with applications to lettering ofmaps. In
Symposium on Computational Geometry (SoCG’91) , pages 281–288. ACM, 1991. doi:10.1145/109648.109680 . Robert J. Fowler, Mike Paterson, and Steven L. Tanimoto. Optimal packing and covering inthe plane are NP -complete. Inf. Process. Lett. , 12(3):133–137, 1981. URL: https://doi.org/10.1016/0020-0190(81)90111-3 , doi:10.1016/0020-0190(81)90111-3 . Edith Gabriel. Spatio-temporal point pattern analysis and modeling. In Shashi Shekhar,Hui Xiong, and Xun Zhou, editors,
Encyclopedia of GIS , pages 1–8. Springer, 2015. doi:10.1007/978-3-319-23519-6_1646-1 . Buddhima Gamlath, Michael Kapralov, Andreas Maggiori, Ola Svensson, and David Wajc.Online matching with general arrivals. In
Foundations of Computer Science (FOCS’19) , pages26–37, 2019. doi:10.1109/FOCS.2019.00011 . Alexander Gavruskin, Bakhadyr Khoussainov, Mikhail Kokho, and Jiamou Liu. Dynamicalgorithms for monotonic interval scheduling problem.
Theoretical Computer Science , 562:227–242, 2015. doi:10.1016/j.tcs.2014.09.046 . Andreas Gemsa, Martin Nöllenburg, and Ignaz Rutter. Consistent labeling of rotating maps.
J. Computational Geometry , 7(1):308–331, 2016. doi:10.20382/jocg.v7i1a15 . U. I. Gupta, D. T. Lee, and Joseph Y.-T. Leung. Efficient algorithms for interval graphs andcircular-arc graphs.
Networks , 12(4):459–467, 1982. doi:10.1002/net.3230120410 . Johan Håstad. Clique is hard to approximate within n − (cid:15) . Acta Mathematica , 182(1):105–142,1999. doi:10.1007/BF02392825 . Monika Henzinger, Stefan Neumann, and Andreas Wiese. Dynamic approximate maximumindependent set of intervals, hypercubes and hyperrectangles. In Sergio Cabello and Danny Z.Chen, editors,
Symposium on Computational Geometry (SoCG 2020) , volume 164 of
LIPIcs ,pages 51:1–51:14. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.SoCG.2020.51 . Dorit S. Hochbaum and Wolfgang Maass. Approximation schemes for covering and packingproblems in image processing and vlsi.
J. ACM , 32(1):130–136, 1985. doi:10.1145/2455.214106 . John E Hopcroft and Richard M Karp. An n / algorithm for maximum matchings in bipartitegraphs. SIAM Journal on Computing , 2(4):225–231, 1973. doi:10.1137/0202019 . Richard M. Karp. Reducibility among combinatorial problems. In R. E. Miller, J. W. Thatcher,and J. D. Bohlinger, editors,
Complexity of Computer Computations , pages 85–103, 1972. doi:10.1007/978-1-4684-2001-2_9 . Fabian Klute, Guangping Li, Raphael Löffler, Martin Nöllenburg, and Manuela Schmidt.Exploring semi-automatic map labeling. In
Advances in Geographic Information Systems(SIGSPATIAL’19) , pages 13–22. ACM, 2019. doi:10.1145/3347146.3359359 . Nathan Linial. Distributive graph algorithms global solutions from local data. In
Foundationsof Computer Science (SFCS’87) , pages 331–335. IEEE, 1987. doi:10.1109/SFCS.1987.20 . Kurt Mehlhorn and Stefan Näher. Dynamic fractional cascading.
Algorithmica , 5(1–4):215–241,1990. doi:10.1007/BF01840386 . . Bhore, G. Li, and M. Nöllenburg 27 Kurt Mehlhorn and Stefan Näher.
The LEDA Platform of Combinatorial and GeometricComputing . Cambridge University Press, 1999. doi:10.1145/204865.204889 . Huy N Nguyen and Krzysztof Onak. Constant-time approximation algorithms via localimprovements. In
Foundations of Computer Science (FOCS’08) , pages 327–336. IEEE, 2008. doi:10.1109/FOCS.2008.81 . Panos M Pardalos and Jue Xue. The maximum clique problem.
Journal of Global Optimization ,4(3):301–328, 1994. doi:10.1007/BF01098364 . René van Bevern, Matthias Mnich, Rolf Niedermeier, and Mathias Weller. Interval schedulingand colorful independent sets.
Journal of Scheduling , 18(5):449–469, 2015. doi:10.1007/s10951-014-0398-5 . Marc J. van Kreveld, Tycho Strijk, and Alexander Wolff. Point set labeling with sliding labels.In Ravi Janardan, editor,
Proceedings of the Fourteenth Annual Symposium on ComputationalGeometry, Minneapolis, Minnesota, USA, June 7-10, 1998 , pages 337–346. ACM, 1998. URL: https://doi.org/10.1145/276884.276922 , doi:10.1145/276884.276922 . Frank Wagner and Alexander Wolff. A practical map labeling algorithm.
Comput. Geom.Theory Appl. , 7:387–404, 1997. doi:10.1016/S0925-7721(96)00007-7doi:10.1016/S0925-7721(96)00007-7