Recent Advances in Fully Dynamic Graph Algorithms
aa r X i v : . [ c s . D S ] F e b Recent Advances in Fully Dynamic Graph Algorithms
KATHRIN HANAUER,
University of Vienna, Faculty of Computer Science, Austria
MONIKA HENZINGER,
University of Vienna, Faculty of Computer Science, Austria
CHRISTIAN SCHULZ,
Heidelberg University, GermanyIn recent years, significant advances have been made in the design and analysis of fully dynamic algorithms.However, these theoretical results have received very little attention from the practical perspective. Few of thealgorithms are implemented and tested on real datasets, and their practical potential is far from understood.Here, we survey recent engineering and theory results in the area of fully dynamic graph algorithms.
A (fully) dynamic graph algorithm is a data structure that supports edge insertions, edge deletions,and answers certain queries that are specific to the problem under consideration. There has beena lot of research on dynamic algorithms for graph problems that are solvable in polynomial timeby a static algorithm. The most studied dynamic problems are graph problems such as connec-tivity, reachability, shortest paths, or matching (see [115]). Typically, any dynamic algorithm thatcan handle edge insertions can be used as a static algorithm by starting with an empty graph andinserting all 𝑚 edges of the static input graph step-by-step. A fundamental question that arises iswhich problems can be fully dynamized , which boils down to the question whether they admit adynamic algorithm that supports updates in O( 𝑇 ( 𝑚 )/ 𝑚 ) time, where 𝑇 ( 𝑚 ) is the static runningtime. Thus, for static problems that can be solved in near-linear time, the research communityis interested in near-constant time updates. By now, such results have been achieved for a widerange of problems [115], which resulted in a rich algorithmic toolbox spanning a wide range oftechniques. However, while there is a large body of theoretical work on efficient dynamic graphalgorithms, until recently there has been very little on their empirical evaluation. For some clas-sical dynamic algorithms, experimental studies have been performed, such as for fully dynamicgraph clustering [79] and fully dynamic approximation of betweenness centrality [29]. However,for other fundamental dynamic graph problems, the theoretical algorithmic ideas have receivedvery little attention from the practical perspective. In particular, very little work has been devotedto engineering such algorithms and providing efficient implementations in practice. Previous sur-veys on the topic [7, 250] are more than twenty years old and do not capture the state-of-the-fieldanymore. In this work, we aim to survey recent progress in theory as well as in the empirical eval-uation of fully dynamic graph algorithms and summarize methodologies used to evaluate suchalgorithms. Moreover, we point to theoretical results that we think have a good potential for prac-tical implementations. Lastly, there currently is a lack of fully dynamic real-world graphs availableonline – most of the instances that can be found to date are insertions-only. Hence, together withthis survey we will also start a new open-access graph repository that provides fully dynamicgraph instances . If you have access to fully dynamic instances, we are happy to provide them in our repository. https://DynGraphLab.github.ioAuthors’ addresses: Kathrin Hanauer, [email protected], University of Vienna, Faculty of Computer Science,Währinger Str. 29, Vienna, Vienna, Austria, 1090; Monika Henzinger, [email protected], University of Vi-enna, Faculty of Computer Science, Währinger Str. 29, Vienna, Vienna, Austria, 1090; Christian Schulz, [email protected], Heidelberg University, Im Neuenheimer Feld 205, Heidelberg, Baden-Württemberg, Ger-many, 69120. Kathrin Hanauer, Monika Henzinger, and Christian Schulz
We want to point out that there are also various dynamic graph models which we cannot dis-cuss in any depth for space limitations. These are insertions-only algorithms, deletions-only algo-rithms, offline dynamic algorithms [82], algorithms with vertex insertions and deletions, kineticalgorithms [104], temporal algorithms [133, 134, 234], algorithms with a limit on the number ofallowed queries [256], algorithms for the sliding-windows model [64], and algorithms for sensi-tivity problems (also called emergency planning or fault-tolerant algorithms) [117, 190]. We alsoexclude dynamic algorithms in other models of computation such as distributed algorithms [201]and algorithms in the massively parallel computation (MPC) model. If the full graph is knownat preprocessing time and vertices are “switched on and off”, this is called the subgraph model ,whereas algorithms under failures deal with the case that vertices or edges are only “switched off”.Note that fully dynamic graph algorithms (according to our definition) are also sometimes called algorithms for evolving graphs or for incremental graphs or sometimes even maintaining a graphonline . Let 𝐺 = ( 𝑉 , 𝐸 ) be a (un)directed graph with vertex set 𝑉 and edge set 𝐸 . Throughout this paper, let 𝑛 = | 𝑉 | and 𝑚 = | 𝐸 | . The density of 𝐺 is 𝑑 = 𝑚𝑛 . In the directed case, an edge ( 𝑢, 𝑣 ) ∈ 𝐸 has tail 𝑢 and head 𝑣 and 𝑢 and 𝑣 are said to be adjacent . ( 𝑢, 𝑣 ) is said to be an outgoing edge or out-edge of 𝑢 andan incoming edge or in-edge of 𝑣 . The outdegree deg + ( 𝑣 ) / indegree deg − ( 𝑣 ) / degree deg ( 𝑣 ) of a vertex 𝑣 is its number of (out-/in-) edges. The out-neighborhood ( in-neighborhood ) of a vertex 𝑢 is the setof all vertices 𝑣 such that ( 𝑢, 𝑣 ) ∈ 𝐸 ( ( 𝑣, 𝑢 ) ∈ 𝐸 ). In the undirected case, 𝑁 ( 𝑣 ) : = { 𝑢 : { 𝑣, 𝑢 } ∈ 𝐸 } denotes the neighbors of 𝑣 . The degree of a vertex 𝑣 is deg ( 𝑣 ) : = | 𝑁 ( 𝑣 )| here. In the following, Δ denotes the maximum degree that can be found in any state of the dynamic graph. Our focus inthis paper are fully dynamic graphs , where the number of vertices is fixed, but edges can be addedand removed. There are lower bounds for fully dynamic graph algorithms based on various popular conjecturesinitiated by [4, 116, 188]. These lower bounds usually involve three parameters: the preprocess-ing time 𝑝 ( 𝑚, 𝑛 ) , the update time 𝑢 ( 𝑚, 𝑛 ) , and the query time 𝑞 ( 𝑚, 𝑛 ) . We will use the notation ( 𝑝 ( 𝑚, 𝑛 ) , 𝑢 ( 𝑚, 𝑛 ) , 𝑞 ( 𝑚, 𝑛 )) below to indicate that no algorithm with preprocessing time at most 𝑝 ( 𝑚, 𝑛 ) exists that requires at most update time 𝑢 ( 𝑚, 𝑛 ) and query time 𝑞 ( 𝑚, 𝑛 ) . Note that if thepreprocessing time is larger than 𝑝 ( 𝑚, 𝑛 ) or if the query time is larger than 𝑞 ( 𝑚, 𝑛 ) , then it mightbe possible to achieve an update time better than 𝑢 ( 𝑚, 𝑛 ) . In the same vein, if the preprocessingtime is larger than 𝑝 ( 𝑚, 𝑛 ) or if the update time is larger than 𝑢 ( 𝑚, 𝑛 ) , then it might be possibleto achieve a query time better than 𝑞 ( 𝑚, 𝑛 ) . We will write poly to denote any running time that is polynomial in the size of the input.Any conditional lower bound that is based on the OMv (Online Boolean Matrix-Vector Multi-plication) conjecture [116] applies to both the (amortized or worst-case) running time of any fullydynamic algorithm and also to the worst-case running time of insertions-only and deletions-onlyalgorithms. We will not mention this for each problem below and only state the lower bound,except in cases where as a result of the lower bound only algorithms for the insertions-only ordeletions-only setting have been studied. In this section, we describe recent efforts in fully dynamic graph algorithms. We start by describingfundamental problems that we think belong to a basic toolbox of fully dynamic graph algorithms:strongly connected components, minimum spanning trees, cycle detection/topological ordering, ecent Advances in Fully Dynamic Graph Algorithms 3 matching, core decomposition, subgraph detection, diameter, as well as independent sets. Later on,we discuss problems that are closer to the application side. To this end we include fully dynamicalgorithms for shortest paths, maximum flows, graph clustering, centrality measures, and graphpartitioning.
One of the most fundamental questions on graphs is whether two given vertices are connectedby a path. In the undirected case, a path connecting two vertices 𝑢 and 𝑤 is a sequence of edges P = ({ 𝑢, 𝑣 } , { 𝑣 , 𝑣 } , . . . , { 𝑣 𝑘 , 𝑤 }) . A connected component is a maximal set of vertices that arepairwise connected by a path. A graph is connected if there is exactly one connected component,which is 𝑉 . In a directed graph, we say that a vertex 𝑢 can reach a vertex 𝑤 if there is a directedpath from 𝑢 to 𝑤 , i.e., a sequence of directed edges P = (( 𝑢, 𝑣 ) , ( 𝑣 , 𝑣 ) , . . . , ( 𝑣 𝑘 , 𝑤 )) . A stronglyconnected component (SCC) is a maximal set of vertices that can reach each other pairwise. Adirected graph is strongly connected if there is just one strongly connected component, which is 𝑉 .The transitive closure of a graph 𝐺 is a graph on the same vertex set with an edge ( 𝑢, 𝑤 ) ∈ 𝑉 × 𝑉 if and only if 𝑢 can reach 𝑤 in 𝐺 . Given an undirected graph, we can construct a directed graphfrom it by replacing each undirected edge { 𝑢, 𝑤 } by a pair of directed edges ( 𝑢, 𝑤 ) and ( 𝑤, 𝑢 ) andtranslate queries of connectedness into reachability queries on the directed graph. Undirected Graphs (Connectivity).
Patrascu and Demaine [189] gave an (unconditional) lowerbound of Ω ( log 𝑛 ) per operation for this problem, improving an earlier bound of Ω ( log 𝑛 / log log 𝑛 ) [122]. The first non-trivial dynamic algorithms for connectivity, and also for 2-edge connectiv-ity, and 2-vertex connectivity [83, 84, 88, 120, 121] took time ˜ 𝑂 (√ 𝑛 ) per operation. Henzingerand King [125] were the first to give a fully dynamic algorithm with polylogarithmic time peroperation for this problem. Their algorithm is, however, randomized. Holm et al. [127] gave thefirst deterministic fully dynamic algorithm with polylogarithmic time per operation. The currentlyfastest fully dynamic connectivity algorithm takes O( log 𝑛 ( log log 𝑛 ) ) amortized expected timeper operation [132].The fully dynamic connectivity problem can be reduced to the maintenance of a spanning for-est, using, e.g., dynamic trees [226] or Euler tour trees [124] (see also Section 3.2), for the compo-nents. If the graph is a forest, updates and queries can be processed in amortized O( log 𝑛 ) time,whereas the theoretically fastest algorithms [146] to date for general graphs have polylogarith-mic worst-case update time and O( log 𝑛 / log log 𝑛 ) worst-case query time, the latter matching thelower bound [122, 176]. The key challenge on general graphs is to determine whether the deletionof an edge of the spanning forest disconnects the component or whether a replacement edge canbe found. Observe that the purely incremental version of the problem can be solved by a union-find data structure in O( 𝛼 ( 𝑛 )) update and query time [231], where 𝛼 ( 𝑛 ) is the inverse Ackermannfunction. There are also dynamic algorithms for more refined notions of connectivity: Two-edgeconnectivity [125, 126] and two-vertex connectivity [126] can also be maintained in polylogarith-mic time per operation. See [139] for a survey on that topic.Building on an earlier study by Alberts et al. [7], Iyer et al. [142] experimentally comparedthe Euler tour tree-based algorithms by Henzinger and King [124] and Holm et al. [126] to eachother as well as several heuristics to achieve speedups in both candidates. The instances used in theevaluation were random graphs with random edge insertions and deletions, random graphs wherea fixed set of edges appear and disappear dynamically, graphs consisting of cliques of equal sizeplus a set of inter-clique edges, where only the latter are inserted and deleted, as well as speciallycrafted worst-case instances for the algorithms. The authors showed that the running time of bothalgorithms can be improved distinctly via heuristics; in particular a sampling approach to replace Kathrin Hanauer, Monika Henzinger, and Christian Schulz deleted tree edges has proven to be successful. The experimental running time of both algorithmswas comparable, but with the heuristics, the algorithm by Holm et al. [126] performed better.
Directed Graphs (Reachability, Strong Connectivity, Transitive Closure).
For directed graphs thatare and remain acyclic, the same algorithms can be employed for reachability as for (undirected)connectivity in forests (see above). On general graphs, there is a conditional lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) for any small constant 𝜖 > based on the OMv conjecture. This bound evenholds for the 𝑠 - 𝑡 reachability problem, where both 𝑠 and 𝑡 are fixed for all queries. The currentlyfastest algorithms for transitive closure are Sankowski’s three Monte Carlo algorithms with one-sided error [211] with O( ) , O( 𝑛 . ) , or O( 𝑛 . ) worst-case query time and O( 𝑛 ) , O( 𝑛 . ) ,or O( 𝑛 . ) worst-case update time, respectively, as well as two deterministic, combinatorial al-gorithms: Roditty’s algorithm with constant query time and O( 𝑛 ) amortized update time [204],as well as one by Roditty and Zwick [206] with an improved O( 𝑚 + 𝑛 log 𝑛 ) amortized updatetime at the expense of O( 𝑛 ) worst-case query time. Additionally, there is a large body of work oninsertions-only and deletions-only reachability and strong connectivity [21, 72, 74, 91, 123, 135,137, 138, 154–156, 163, 170, 204–206, 211, 235, 247].Frigioni et al. [91] and later Krommidas and Zaroliagis [161] empirically studied the performanceof an extensive number of algorithms for transitive closure, including those mentioned above. Theyalso developed various extensions and variations and compared them not only to each other, butalso to static, so-called “simple-minded” algorithms such as breadth-first and depth-first search.Their evaluation included random Erdős-Renyí graphs, specially constructed hard instances, aswell as two instances based on real-world graphs. It showed that the “simple-minded” algorithmscould outperform the dynamic ones distinctly and up to several factors, unless the query ratio wasmore than
65 % or the instances were dense random graphs.In recent experimental studies by Hanauer et al. [110, 111], two relatively straightforward al-gorithms for single-source reachability could outperform the “simple-minded” algorithms of theearlier studies in a single-source setting by several orders of magnitude in practice both on ran-dom graphs as well as on real-world instances: SI maintains an arbitrary reachability tree which isre-constructed via a combined forward and backward breadth-first search traversal on edge dele-tions if necessary and is especially fast if insertions predominate, which can be handled in O( 𝑛 + 𝑚 ) time. By contrast, it may take up to O( 𝑛𝑚 ) time for a single edge removal. SES is an extensionand simplification of Even-Shiloach trees [225], which originally only handle edge deletions. Itsstrength are hence instances with many deletions. As a plus, it is able to deliver not just any pathas a witness for reachability, but even the shortest path (with respect to the number of edges). Itsworst-case update time is O( 𝑛 + 𝑚 ) , and, like SI , it answers queries in constant time. One key ingre-dient for the superior performance of both algorithms in practice are carefully chosen criteria foran abortion of the re-construction of their data structures and their re-building from scratch [110].To query the transitive closure of a graph, a number of so-called “supportive vertices”, for whichboth in- and out-reachability trees are maintained explicitly, can be picked either once or period-ically anew and then be used to answer both positive and negative reachability queries betweena number of pairs of vertices decisively in constant time [111]. The fallback routine can be a sim-ple static graph traversal and therefore be relatively expensive: With a random initial choice ofsupportive vertices and no periodic renewals, this approach has been shown to answer a greatmajority of reachability queries on both random and real-world instances in constant time alreadyif the number of supportive vertices is very small, i.e., two or three.These experimental studies clearly show the limitations of worst-case analysis: All implementedalgorithms are fully dynamic with at least linear worst-case running time per operation and, thus, ecent Advances in Fully Dynamic Graph Algorithms 5 all perform “(very) poor” in the worst case. Still on all graphs used in the study the relatively simplenew algorithms clearly outperformed the algorithms used in previous studies. A minimum weight spanning tree (MST) of a connected graph is a subset of the edges such thatall nodes are connected via the edges in the subset, the induced subgraph has no cycles and, lastly,has the minimum total weight among all possible subsets fulfilling the first two properties.The lower bound of Ω ( log 𝑛 ) [189] on the time per operation for connectivity trivially extends tomaintaining the weight of a minimum spanning tree. Holm et al. [127] gave the first fully dynamicalgorithm with polylogarithmic time per operation for this problem. It was later slightly improvedto O( log 𝑛 )/ log log 𝑛 ) time per operation [128].Amato et al. [136] presented the first experimental study of dynamic minimum spanning tree al-gorithms. In particular, the authors implemented different versions of Frederickson’s algorithm [87]which uses partitions and topology trees. The algorithms have been adapted with sparsificationtechniques to improve their performance. The update running times of these algorithms rangefrom O( 𝑚 / ) to O( 𝑚 / ) . The authors further presented a variant of Frederickson’s algorithmthat is significantly faster than all other implementations of this algorithm. However, the authorsalso proposed a simple adaption of a partially dynamic data structure of Kruskal’s algorithm thatwas the fastest implementation on random inputs. Later, Cattaneo et al. [54, 55] presented anexperimental study on several algorithms for the problem. The authors presented an efficient im-plementation of the algorithm of Holm et al. [127], proposed new simple algorithms for dynamicMST that are not as asymptotically efficient as the algorithm by Holm et al. but seem to be fastin practice, and lastly compared their algorithms with the results of Amato et al. [136]. The al-gorithm by Holm et al. uses a clever refinement of a technique by Henzinger and King [119] fordeveloping fully dynamic algorithms starting from the deletions-only case. One outcome of theirexperiments is that simple algorithms outperform the theoretically more heavy algorithms on ran-dom and worst-case networks. On the other hand, on 𝑘 -clique inputs, i.e. graphs that contain 𝑘 cliques of size 𝑐 plus 𝑘 randomly chosen inter-clique edges, the implementation of the algorithmby Holm et al. outperformed the simpler algorithms.Tarjan and Werneck [232] performed experiments for several variants of dynamic trees datastructure. The evaluated data structures have been used by Ribero and Toso [202] who focusedon the case of changing weights, i.e. the edges of the graph are constant, but the edge weightscan change dynamically. The authors also proposed and used a new data structure for dynamictree representation called DRD-trees. In their algorithm the dynamic tree data structure is usedto speed up connectivity queries that checks whether two vertices belong to different subtrees.More generally, the authors compared different types of data structures to do this task. In par-ticular, the authors used the dynamic tree data structures that have been evaluated by Tarjan andWerneck [232]. The experimental evaluation demonstrated that the new structure reduces the com-putation time observed for the algorithm of Cattaneo et al. [54], and at the same time yielded thefastest algorithms in the experiments. A cycle in a (directed) graph 𝐺 = ( 𝑉 , 𝐸 ) is a non-empty path P = ( 𝑣 , . . . , 𝑣 𝑘 = 𝑣 ) such that ( 𝑣 𝑖 , 𝑣 𝑖 + ) ∈ 𝐸 . A topological ordering of a directed graph is a linear ordering of its vertices from 1to 𝑛 such that for every directed edge ( 𝑢, 𝑣 ) from vertex 𝑢 to vertex 𝑣 , 𝑢 is ordered before 𝑣 . In thestatic case, one can use a depth-first search (DFS) to compute a topological ordering of a DAG orto check if a (un)directed graph contains a cycle. Kathrin Hanauer, Monika Henzinger, and Christian Schulz
Let 𝜖 > be any small constant. Based on the OMv conjecture [116] it is straightforward toconstruct a lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) for the (amortized or worst-case) running time ofany fully dynamic algorithm that detects whether the graph contains any cycle. As any algorithmfor topological ordering can be used to decide whether a graph contains a cycle, this lower boundalso applies to any fully dynamic topological ordering algorithm. Note that this lower bound alsoapplies to the worst-case running time of insertions-only and deletions-only algorithms.To circumvent the lower bound and since the deletions-only case of topological ordering istrivial, all theoretical work has concentrated on developing insertions-only topological orderingalgorithms with small total running time , which is equivalent to achieving small amortized runningtime [28, 33, 61, 108, 151, 152]. Currently the fastest total time for cycle detection is ˜ 𝑂 ( min ( 𝑛 , 𝑚 √ 𝑛 )) :The algorithm by Bender et al. [28] takes deterministic time O( 𝑛 log 𝑛 ) , the algorithm by Bern-stein and Chechik [33] is a Las-Vegas randomized algorithm with expected total time ˜ 𝑂 ( 𝑚 √ 𝑛 ) .The former algorithm maintains a level 𝑙 for each vertex that forms a pseudo-topological ordering ,where different vertices can have the same level and levels can assume values larger than 𝑛 . Itmust, however, hold for every edge ( 𝑢, 𝑣 ) that 𝑙 ( 𝑢 ) ≤ 𝑙 ( 𝑣 ) . After an edge insertion a restrictedforward search is started. The latter algorithm randomly samples a set 𝑆 of vertices and defines anequivalence notion on the set of vertices based on which vertices in 𝑆 they can reach and they canbe reached from. Testing whether a cycle exists after the insertion of an edge ( 𝑢, 𝑣 ) correspondsto testing whether 𝑢 is an “ 𝑆 -equivalent” vertex of 𝑣 which can be reached by 𝑣 . This idea can beextended to also maintain a topological ordering. These theoretical algorithms have not yet beenimplemented but it should be fairly simple to do that and it would be worthwhile to compare theirperformance with the available experimental results that we mention now.Pearce and Kelly [193, 194] were the first to evaluate algorithms for topological ordering inthe presence of edge insertions and deletions. In their work, the authors compared three algo-rithms that can deal with the online topological ordering problem. More precisely, the authorsimplemented the algorithms by Marchetti-Spaccamela et al. [172] and Alpern et al. [9] as well asa newly developed algorithm. Their new algorithm is the one that performed best in their experi-ments. The algorithm maintains a node-to-index map, called 𝑛 𝑖 , that maps each vertex to a uniqueinteger in { . . . | 𝑉 |} and ensures that for any edge ( 𝑢, 𝑣 ) in 𝐺 , it holds 𝑛 𝑖 [ 𝑢 ] < 𝑛 𝑖 [ 𝑣 ] . When aninsertion ( 𝑢, 𝑣 ) invalidates the topological ordering, affected nodes are updated. The set of affectednodes are identified using a forward DFS from 𝑣 and backward DFS from 𝑢 . The two sets are thenseparately sorted into increasing topological order and afterwards a remapping to the availableindices is performed. The algorithm by Marchetti-Spaccamela et al. [172] is quite similar to thealgorithm by Pearce and Kelly. However, it only maintains the forward set of affected nodes andobtains a correct solution by shifting the affected nodes up in the ordering (putting them after 𝑢 ).Alpern et al. [9] used a data structure to create new priorities between existing ones in constantworst-case time. The result by Pearce and Kelly has later been applied to online cycle detectionand difference propagation in pointer analysis by Pearce et al. [195]. Furthermore, Pearce andKelly [192] later extended their algorithm to be able to provide more efficient batch updates. The matching problem is one of the most prominently studied combinatorial graph problems hav-ing a variety of practical applications. A matching M of a graph 𝐺 = ( 𝑉 , 𝐸 ) is a subset of edgessuch that no two elements of M have a common end point. Many applications require matchingswith certain properties, like being maximal (no edge can be added to M without violating thematching property) or having maximum cardinality. ecent Advances in Fully Dynamic Graph Algorithms 7 In the dynamic setting, there is a conditional lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) (for any smallconstant 𝜖 > ) for the size of the maximum cardinality matching based on the OMv conjec-ture [116]. Of course, maintaining an actual maximum matching is only harder than maintainingthe size of a maximum matching. Thus upper bounds have mostly focused on approximately max-imum matching. However, also here we have to distinguish (a) algorithms that maintain the size of an approximately maximum matching and (b) algorithms that maintain an approximately max-imum matching .(a) Sankowski [212] maintains the exact size of a maximum matching in O( 𝑛 . ) update timeusing fast matrix multiplication. To maintain the approximate size of the maximum matching,dynamic algorithms use the duality of maximum matching and vertex cover and maintain insteada ( + 𝜖 ) -approximate vertex cover. This line of work lead to a sequence of papers [37, 39, 41, 44, 140],resulting finally in a deterministic ( + 𝜖 ) -approximation algorithm that maintains a hierarchicalgraph decomposition with O( / 𝜖 ) amortized update time. The algorithm can be turned into analgorithm with worst-case O( log 𝑛 ) time per update [40].(b) One can trivially maintain a maximal matching in O( 𝑛 ) update time by resolving all triv-ial augmenting paths, i.e. cycle-free paths that start and end on a unmatched vertex and whereedges from M alternate with edges from 𝐸 \ M , of length one. As any maximal matching is a2-approximation of a maximum matching, this leads to a 2-approximation algorithm. Onak andRubinfeld [186] presented a randomized algorithm for maintaining an O( ) -approximate match-ing with O( log 𝑛 ) expected amortized time per edge update. Baswana, Gupta, and Sen [22] gavean elegant algorithm that maintains a maximal matching with amortized update time O( log 𝑛 ) .It is based on a hierarchical graph decomposition and was subsequently improved by Solomonto amortized constant expected update time [227]. For worst-case bounds, the best results are a ( + 𝜖 ) -approximation in O(√ 𝑚 / 𝜖 ) update time by Gupta and Peng [107] (see [183] for a 3/2-approximation in the same time), a ( / + 𝜖 ) -approximation in O( 𝑚 / / 𝜖 . ) time by Bernsteinand Stein [34], and a ( + 𝜖 ) -approximation in O( polylog 𝑛 ) time by Charikar and Solomon [57]and Arar et al. [13]. Recently, Grandoni et al. [100] gave an incremental matching algorithm thatachieves a ( + 𝜖 ) -approximate matching in constant deterministic amortized time. Finally, Bern-stein et al. [35] improved the maximal matching algorithm of Baswana et al. [22] to O( log 𝑛 ) worst-case time with high probability.Despite this variety of different algorithms, to the best of our knowledge, there have been onlylimited efforts so far to engineer and evaluate these algorithms on real-world instances. Henzingeret al. [118] initiated the empirical evaluation of algorithms for this problem in practice. To this end,the authors evaluated several dynamic maximal matching algorithms as well as an algorithm that isable to maintain the maximum matching. They implemented the algorithm by Baswana, Gupta andSen [22], which performs edge updates in O(√ 𝑛 ) time and maintains a 2-approximate maximummatching, the algorithm of Neiman and Solomon [183], which takes O(√ 𝑚 ) time to maintain a3/2-approximate maximum matching, as well as two novel dynamic algorithms, namely a randomwalk-based algorithm as well as a dynamic algorithm that searches for augmenting paths usinga (depth-bounded) blossom algorithm. Their experiments indicate that an optimum matching canbe maintained dynamically more than an order of magnitude faster than the naive algorithm thatrecomputes maximum matchings from scratch . Second, all non-optimum dynamic algorithmsthat have been considered in this work were able to maintain near-optimum matchings in practicewhile being multiple orders of magnitudes faster than the naive exact dynamic algorithm. Thestudy concludes that in practice an extended random walk-based algorithms is the method ofchoice. Kathrin Hanauer, Monika Henzinger, and Christian Schulz
For the weighted dynamic matching problem, Anand et al. [11] proposed an algorithm thatcan maintain an 4.911-approximate dynamic maximum weight matching that runs in amortized O( log 𝑛 log 𝐶 ) time where 𝐶 is the ratio of the weight of the highest weight edge to the weightof the smallest weight edge. Furthermore, a sequence [5, 42–45] of work on fully dynamic setcover resulted in 𝑓 ( + 𝜖 ) -approximate weighted dynamic matching algorithms for hypergraphs,where 𝑓 is the maximum number of nodes in an hyperedge with O( 𝑓 / 𝜖 + ( 𝑓 / 𝜖 ) log 𝐶 ) amor-tized and O(( 𝑓 / 𝜖 ) log ( 𝐶𝑛 )) worst-case time per operation based on various hierarchical hy-pergraph decompositions. Gupta and Peng [106] maintain a ( + 𝜖 ) -approximation under edgeinsertions/deletions that runs in time O(√ 𝑚𝜖 − − 𝑂 ( / 𝜖 ) log 𝑁 ) time per update, if edge weights arein between and 𝑁 . Their result is based on rerunning a static algorithm from time to time, atrimming routine that trims the graph to a smaller equivalent graph whenever possible and in theweighted case, a partition of the weights of the edges into intervals of geometrically increasingsize. Stubbs and Williams [229] presented metatheorems for dynamic weighted matching. Here,the authors reduced the dynamic maximum weight matching problem to the dynamic maximumcardinality matching problem in which the graph is unweighted. The authors proved that usingthis reduction, if there is an 𝛼 -approximation for maximum cardinality matching with update time 𝑇 in an unweighted graph, then there is also a ( + 𝜖 ) 𝛼 -approximation for maximum weight match-ing with update time O( 𝑇𝜖 log 𝑁 ) . Their basic idea is an extension of the algorithm of Crouchand Stubbs [63] who tackled the problem in the streaming model. Here, the reduction is to takematchings from weight-threshold based subgraphs of the dynamic graph, i.e. the algorithm main-tains maximal matchings in log 𝐶 subgraphs, where subgraph 𝑖 contains all edges having weightat least ( + 𝜖 ) 𝑖 . The resulting matchings are then greedily merged together by considering thematched edges in descending order of 𝑖 (heaviest edges first). None of these algorithms have beenimplemented. 𝑘 -Core Decomposition A 𝑘 -core of a graph is a maximal connected subgraph in which all vertices have degree at least 𝑘 . The 𝑘 -core decomposition problem is to compute the core number of every node in the graph.It is well-known that a 𝑘 -core decomposition can be computed in linear time for a static graph.The problem of maintaining the 𝑘 -core decomposition in a fully dynamic graph has not receivedmuch attention by the theoretical computer science community: Sun et al. [230] showed that theinsertion and deletion of a single edge can change the core value of all vertices. They also gave a ( + 𝜖 ) -approximate fully dynamic algorithm with polylogarithmic running time. More specifically,the algorithm takes time ˜ 𝑂 ( 𝑟 ) in a hypergraph where each hyperedge consists of at most 𝑟 vertices.The algorithm can be implemented in time O( log 𝑛 ) in graphs using the algorithm of [38]. Itdynamically maintains O( log ( + 𝜖 ) 𝑛 ) many ( 𝛼, 𝛽 ) -decompositions of the graph, one for each 𝛽 -value that is a power of ( + 𝜖 ) between and ( + 𝜖 ) 𝑛 . An ( 𝛼, 𝛽 ) - decomposition of a graph 𝐺 = ( 𝑉 , 𝐸 ) is a decomposition 𝑍 , . . . , 𝑍 𝐿 of 𝑉 into 𝐿 : = + ⌈( + 𝜖 ) log 𝑛 ⌉ levels such that 𝑍 𝑖 + ⊆ 𝑍 𝑖 for all ≤ 𝑖 < 𝐿 , 𝑍 = 𝑉 , and the following invariants are maintained: (1) All vertices 𝑣 on level 𝑍 𝑖 with 𝑑𝑒𝑔 𝑍 𝑖 ( 𝑣 ) > 𝛼𝛽 belong to 𝑍 𝑖 + and (2) all vertices 𝑣 on level 𝑍 𝑖 with 𝑑𝑒𝑔 𝑍 𝑖 ( 𝑣 ) < 𝛽 do not belongto 𝑍 𝑖 + . There are no further lower bounds, neither conditional nor unconditional, and no fasteralgorithms known for maintaining an approximate 𝑘 -core decomposition.Miorandi and De Pellegrini [177] proposed two methods to rank nodes according to their 𝑘 -core number in fully dynamic networks. The focus of their work is to identify the most influen-tial spreaders in complex dynamic networks. Li et al. [166] used a filtering method to only up-date nodes whose core number is affected by the network update. More precisely, the authorsshowed that nodes that need to be updated must be connected via a path to the endpoints of the ecent Advances in Fully Dynamic Graph Algorithms 9 inserted/removed edge and the core number must be equal to the smaller core number of the end-points. Moreover, the authors presented efficient algorithms to identify such nodes as well as addi-tional techniques to reduce the size of the nodes that need updates. Similarly, Sariyüce et al. [216]proposed the 𝑘 -core algorithm TRAVERSAL and gave additional rules to prune the size of the sub-graphs that are guaranteed to contain the vertices whose 𝑘 -core number can have changed. Notethat these algorithm can have a high variation in running time for the update operations depend-ing on the size of the affected subgraphs. Zhang et al. [251] noted that due to this reason it can beimpractical to process updates one by one and introduced the 𝑘 -order concept which can reducethe cost of the update operations. A 𝑘 -order is defined as follows: a node 𝑢 is ordered before 𝑣 inthe 𝑘 -order if 𝑢 has a smaller core number than 𝑣 or when the vertices have the same core num-ber, if the linear time algorithm to compute the core decomposition would remove 𝑢 before 𝑣 . Arecent result by Sun et al. [230] also contains experimental results. However, their main focus ison hypergraphs and there are no comparisons against the algorithms mentioned above.Aridhi et al. [14] gave a distributed 𝑘 -core decomposition algorithm in large dynamic graphs.The authors used a graph partitioning approach to distribute the workload and pruning techniquesto find nodes that are affected by the changes. Wang et al. [243] gave a parallel algorithm that ap-pears to significantly outperform the TRAVERSAL algorithm. Jin et al. [143] presented a parallelapproach based on matching to update core numbers in fully dynamic networks. Specifically, theauthors showed that if a batch of inserted/deleted edges forms a matching, then the core num-ber update step can be performed in parallel. However, the type of the edges has to be the same(i.e. only insertions, or only deletions) in each update. Hua et al. [130] noted that previous algo-rithms become inefficient for high superior degree vertices, i.e. , vertices that have many neighborsthat have a core number that is larger than its own core number. For example, the matching-basedapproach of Jin et al. [143] can only process one edge associated to a vertex in each iteration. Theirnew algorithm can handle multiple insertions/deletions per iteration.It would be interesting to evaluate the algorithm of Sun et al. [230] which maintains a ( + 𝜖 ) -approximate core number, on graphs to see how far from the exact core numbers these estimatesare and how its running time compares to the above approaches. Note that an ( 𝛼, 𝛽 ) -decompositionactually gives a ( 𝛼 + 𝜖 ) approximation and 𝛼 has to be chosen to be slightly larger than 2 only toguarantee polylogarithmic updates. Thus, it would be interesting to also experiment with smallervalues of 𝛼 . Two graphs are isomorphic if there is a bijection between the vertex sets of the graphs that pre-serves adjacency. Given a graph pattern 𝐻 (or multiple 𝐻 𝑖 ), motif counting counts the subgraphsof 𝐺 that are isomorphic to 𝐻 ( 𝐻 𝑖 respectively). In the work that is currently available there is asubset of work that focuses on the special case of counting triangles or wedges, i.e., paths of lengthtwo, in dynamic networks.There is a conditional lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) even for the most fundamental prob-lem of detecting whether a graph contains a triangle [116]. A fully dynamic algorithm with O(√ 𝑚 ) update time was recently given independently by Kara et al. [147, 148] for counting triangles. Thisresult was extended to general 𝑘 -clique counting by Dhulipala et al. [76]. This is currently an activearea of research.In our description of the empirical work for this problem we start with recent work that mainlyfocuses on triangle counting. Pavan et al. [191] introduced neighborhood sampling to count andsample triangles in a one-pass streaming algorithm. In neighborhood sampling, first a randomedge in the stream is sampled and in subsequent steps, edges that share an endpoint with thealready sampled edges are sampled. The algorithm outperformed their implementations of the previous best algorithms for the problem, namely the algorithms by Jowhari and Ghodsi [145] andby Buriol et al. [52]. Note that the method does not appear to be able to handle edge deletions. Bul-teau et al. [51] estimated the number of triangles in fully dynamic streamed graphs. Their methodadapts 2-path sampling to work for dynamic graphs. The main idea of 2-path sampling is to sam-ple a certain number of 2-paths and compute the ratio of 2-paths in the sample that are completetriangles. The total number of 2-paths in the graph is then multiplied with the ratio to obtain thetotal number of 2-paths in the graph. This approach fails, however, if one allows deletions. Thus,the contribution of the paper is a novel technique for sampling 2-paths. More precisely, the algo-rithm first streams the graph and sparsifies it. Afterwards, the sampling technique is applied on thesparsified graph. The core contribution of the authors is to show that the estimate obtained in thesparsified graph is similar to the number of triangles in the original graph. For graphs with constanttransitivity coefficient, the authors achieve constant processing time per edge. Makkar et al. [171]presented an exact and parallel approach using an inclusion-exclusion formulation for trianglecounting in dynamic graphs. The algorithm is implemented in cuSTINGER [86] and runs on GPUs.The algorithm computes updates for batches of edge updates and also updates the number of tri-angles each vertex belongs to. The TRIÈST algorithm [228] estimates local and global triangles. Aninput parameter of the algorithm is the amount of available memory. The algorithm maintains asample of the edges using reservoir sampling and random pairing to exploit the available mem-ory as much as possible. The algorithm reduces the average estimation error by up to
90 % w.r.t.to the previous state-of-the-art. Han and Sethu [109] proposed a new sampling approach, called edge-sample-and-discard , which generates an unbiased estimate of the total number of trianglesin a fully dynamic graph. The algorithm significantly reduces the estimation error compared to
TRIÈST . The
MASCOT algorithm [167, 168] focuses on local triangle counting, i.e. counting thetriangles adjacent to every node. In their work, the authors provide an unbiased estimation of thenumber of local triangles.We now report algorithms that can count more complex patterns. The neighborhood samplingmethod of Pavan et al. [191] can also be used for more complex patters, for example Pavan et al.also presented experiments for 4-cliques. Shiller et al. [217] presented the stream-based (inser-tions and deletions) algorithm
StreaM for counting undirected 4-vertex motifs in dynamic graphs.Ahmed et al. [6] presented a general purpose sampling framework for graph streams. The authorsproposed a martingale formulation for subgraph count estimation and showed how to computeunbiased estimate of subgraph counts from a sample at any point during the stream. The esti-mates for triangle and wedge counting obtained are less than away from the true number oftriangles/wedges. The algorithm outperformed their own implementation of
TRIÈST and
MAS-COT . Mukherjee et al. [178] gave an exact counting algorithm for a given set of motifs in dynamicnetworks. Their focus is on biological networks. The algorithm computes an initial embedding ofeach motif in the initial network. Then for each motif its embeddings are stored in a list. This listis then dynamically updated while the graph evolves. Liu et al. [169] estimated motifs in dynamicnetworks. The algorithm uses exact counting algorithms as a subroutine, and hence can speed upany exact algorithm at the expense of accuracy. The main idea of their algorithm is to partitionthe stream into time intervals and find exact motif counts in subsets of these intervals. Recently,Wang et al. [242] improved on the result of Liu et al.. The improvement stems from a generic edgesampling algorithm to estimate the number of instances of any 𝑘 -vertex ℓ -edge motif in a dynamicnetwork. The main idea of the algorithm is to first uniformly at random draw random edges fromthe dynamic network, then exactly count the number of local motifs and lastly estimate the globalcount from the local counts. The experimental evaluation showed that their algorithm is up to . times faster than the previous state-of-the-art while having lower estimation errors. ecent Advances in Fully Dynamic Graph Algorithms 11 Dhulipala et al. [76] recently gave parallel batch-dynamic algorithms for 𝑘 -clique counting.Their first algorithm is a batch-dynamic parallel algorithm for triangle counting that has amor-tized work O( Δ √ Δ + 𝑚 ) and O( log ∗ ( Δ + 𝑚 )) depth with high probability. The algorithm is basedon degree thresholding which divides the vertices into vertices with low- and high-degree. Giventhe classification of the vertex, different updates routines are used. A multicore implementation ofthe triangle counting algorithm is given. Experiments indicate that the algorithms achieve . to . -times parallel speedups on a machine with cores. Lastly, the authors developed a sim-ple batch-dynamic algorithm for 𝑘 -clique counting that has expected O( Δ ( 𝑚 + Δ ) 𝛼 𝑘 − ) work and O( log 𝑘 − 𝑛 ) depth with high probability, for graphs with arboricity 𝛼 .To summarize for this problem the empirical work is far ahead of the theoretical work and itwould be interesting to better understand the theoretical complexity of motif search and motifcounting. The eccentricity of a vertex is the greatest distance between the vertex and any other vertex in thegraph. Based on this definition, the diameter of a graph is defined as the maximum eccentricityover all vertices in the graph. The radius is the minimum eccentricity of all vertices. Throughrecomputation from scratch it is straightforward to compute a -approximation for diameter andradius and a ( + 𝜖 ) -approximation for radius in linear time.Anacona et al. [12] recently showed that under the strong exponential time hypothesis (SETH)there can be no ( − 𝜖 ) -approximate fully dynamic approximation algorithm for any of theseproblems with O( 𝑚 − 𝜖 ) update or query time for any 𝜖 > . We are not aware of any experimentalstudy for fully dynamic diameter. Given a graph 𝐺 = ( 𝑉 , 𝐸 ) , an independent set is a set 𝑆 ⊆ 𝑉 such that no vertices in 𝑆 are adja-cent to one another. The maximum independent set problem is to compute an independent set ofmaximum cardinality, called a maximum independent set (MIS). The minimum vertex cover prob-lem is equivalent to the maximum independent set problem: 𝑆 is a minimum vertex cover 𝐶 in 𝐺 iff 𝑉 \ 𝑆 is a maximum independent set 𝑉 \ 𝐶 in 𝐺 . Thus, an algorithm that solves one of theseproblems can be used to solve the other. Note, however, that this does not hold for approximationalgorithms: If 𝐶 ′ is an 𝛼 -approximation of a minimum vertex cover, then 𝑉 \ 𝐶 ′ is not necessarilyan 𝛼 -approximation of a maximum independent set. Another related problem is the maximal in-dependent set problem. A set 𝑆 is a maximal independent set if it is an independent set such thatfor any vertex 𝑣 ∈ 𝑉 \ 𝑆 , 𝑆 ∪ { 𝑣 } is not independent.As computing the size of an MIS is NP-hard, all dynamic algorithms of independent set study themaximal independent set problem. Note, however, that unlike for matching a maximal independentset does not give an approximate solution for the MIS problem, as shown by a star graph. In asequence of papers [15, 16, 26, 58, 105] the running time for the maximal independent set problemwas reduced to O( log 𝑛 ) expected worst-case update time.While quite a large amount of engineering work has been devoted to the computation of in-dependent sets/vertex covers in static graphs, the amount of engineering work for the dynamicindependent set problem is very limited. Zheng et al. [252] presented a heuristic fully dynamic al-gorithm and proposed a lazy search algorithm to improve the size of the maintained independentset. A year later, Zheng et al. [253] improved the result such that the algorithm is less sensitive tothe quality of the initial solution used for the evolving MIS. In their algorithm, the authors used two well known data reduction rules, degree one and degree two vertex reduction, that are fre-quently used in the static case. Moreover, the authors can handle batch updates. Bhore et al. [46]focused on the special case of MIS for independent rectangles which is frequently used in maplabelling applications. The authors presented a deterministic algorithm for maintaining a MIS ofa dynamic set of uniform rectangles with amortized sub-logarithmic update time. Moreover, theauthors evaluated their approach using extensive experiments. One of the most studied problems on weighted dynamic networks is the maintenance of shortestpath information between pairs of vertices. In the most general setting, given an undirected, dy-namic graph with dynamically changing edge weights representing distances, we are interestedin the shortest path between two arbitrary vertices 𝑠 and 𝑡 ( all-pairs shortest path problem ). Forthe single-source shortest path problem , the source vertex 𝑠 is fixed beforehand and the dynamicgraph algorithm is only required to answer distance queries between 𝑠 and an (arbitrary) vertex 𝑡 which is specified by the query operation. In the 𝑠 - 𝑡 shortest path problem both 𝑠 and 𝑡 are fixedbeforehand and the data structure is only required to return the distance between 𝑠 and 𝑡 as answerto a query. In all cases, the analogous problem can also be cast on a directed graph, asking for ashortest path from 𝑠 to 𝑡 instead.Let 𝜖 > be a small constant. There is a conditional lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) for anysmall constant 𝜖 > based on the OMv conjecture, even for 𝑠 - 𝑡 shortest paths [116]. This lowerbound applies also to any algorithm that gives a better than / -approximation. For planar graphsthe product of query and update time is Ω ( 𝑛 − 𝜖 ) based on the APSP conjecture [3].The first experimental study for fully dynamic single-source shortest paths on directed graphswith positive real edge weights was conducted by Frigioni et al. [90], who evaluated Dijkstra’sseminal static algorithm [78] against a fully dynamic algorithm by Ramalingam and Reps [200]( RR ) as well as one by Frigioni et al. [89] ( FMN ). RR is based on Dijkstra’s static algorithm andmaintains a spanning subgraph consisting of edges that belong to at least one shortest 𝑠 - 𝑡 path forsome vertex 𝑡 . After an edge insertion, the spanning subgraph is updated starting from the edge’shead until all affected vertices have been processed. In case of an edge deletion, the affected verticesare identified as a first step, followed by an update of their distances. The resulting worst-caseupdate time is O( 𝑥 𝛿 + 𝑛 𝛿 log 𝑛 𝛿 ) ⊆ O( 𝑚 + 𝑛 log 𝑛 ) , where 𝑛 𝛿 corresponds to the number of verticesaffected by the update, i.e., whose distance from 𝑠 changes and 𝑥 𝛿 equals 𝑛 𝛿 plus the number ofedges incident to an affected vertex. Similarly, Frigioni et al. [89] analyzed the update complexity oftheir algorithm FMN with respect to the change in the solution and showed a worst-case runningtime of
O(| 𝑈 𝛿 |√ 𝑚 log 𝑛 ) , where 𝑈 𝛿 is the set of vertices where either the distance from 𝑠 must beupdated or their parent in the shortest paths tree. The algorithm assigns each edge ( 𝑢, 𝑣 ) a forward(backward) level, which corresponds to the difference between the (sum of) 𝑣 ’s ( 𝑢 ’s) distance from 𝑠 and the edge weight, as well as an owner, which is either 𝑢 or 𝑣 , and used to bound the running time.Incident outgoing and incoming edges of a vertex that it does not own are kept in a priority queueeach, with the priority corresponding to the edge’s level. In case of a distance update at a vertex,only those edges are scanned that are either owned by the vertex or have a priority that indicatesa shorter path. Edge insertion and deletion routines are based on Dijkstra’s algorithm and handledsimilar as in RR , but using level and ownership information. The experiments were run on threetypes of input instances: randomly generated ones, instances crafted specifically for the testedalgorithms, and random updates on autonomous systems networks. The static Dijkstra algorithmis made dynamic in that it is re-run from scratch each time its shortest paths tree is affected by anupdate. The evaluation showed that the dynamic algorithms can speed up the update time by
95 % over the static algorithm. Furthermore, RR turned out to be faster in practice than FMN except on ecent Advances in Fully Dynamic Graph Algorithms 13 autonomous systems instances, where the spanning subgraph was large due to many alternativeshortest paths. In a follow-up work, Demetrescu et al. [69, 75] extended this study to dynamicgraphs with arbitrary edge weight, allowing in particular also for negative weights. In addition tothe above mentioned algorithm by Ramalingam and Reps [200] in a slightly lighter version (
RRL )and the one by Frigioni et al. [89] (
FMN ), their study also includes a simplified variant of the latterwhich waives edge ownership (
DFMN ), as well as a rather straightforward dynamic algorithm( DF ) that in case of a weight increase on an edge ( 𝑢, 𝑣 ) first marks all vertices in the shortestpaths subtree rooted at 𝑣 and then finds for each of these vertices an alternative path from 𝑠 usingonly unmarked vertices. The new weight of these vertices can be at most this distance or theold distance plus the amount of weight increase on ( 𝑢, 𝑣 ) . Therefore, the minimum is taken as adistance estimate for the second step, where the procedure is as in Dijkstra’s algorithm. In case of aweight decrease on an edge ( 𝑢, 𝑣 ) the first step is omitted. As Dijkstra’s algorithm is employed as asubroutine, the worst-case running time of DF for a weight change is O( 𝑚 + 𝑛 log 𝑛 ) . For updates, allalgorithms use a technique introduced by Edmonds and Karp [81] to transform the weight 𝑤 ( 𝑢, 𝑣 ) of each edge ( 𝑢, 𝑣 ) to a non-negative one by replacing it with the reduced weight 𝑤 ( 𝑢, 𝑣 ) − ( 𝑑 ( 𝑣 ) − 𝑑 ( 𝑢 )) , where 𝑑 (·) denotes the distance from 𝑠 . This preserves shortest paths and allows Dijkstra’salgorithm to be used during the update process. The authors compared these dynamic algorithmsto re-running the static algorithm by Bellman and Ford on each update from scratch on variousrandomly generated dynamic instances with mixed incremental and decremental updates on theedge weights, always avoiding negative-length cycles. Their study showed that DF is the fastest inpractice on most instances, however, in certain circumstances RR and DFMN are faster, whereas
FMN turned out to be too slow in practice due to its complicated data structures. The authorsobserved a runtime dependency on the interval size of the edge weights; RR was the fastest ifthis interval was small, except for very sparse graphs. DFMN on the other hand was shown toperform better than DF in presence of zero-length cycles, whereas RR is incapable of handlingsuch instances. It is interesting to note here that the differences in running time are only due tothe updates that increase distances, as all three candidates used the same routine for operationsthat decrease distances. The static algorithm was slower than the dynamic algorithms by severalorders of magnitude.The first fully dynamic algorithm for all-pairs shortest paths in graphs with positive integerweights less than a constant 𝐶 was presented by King [154], with an amortized update time of O( 𝑛 . p 𝐶 log 𝑛 ) . For each vertex 𝑣 , it maintains two shortest paths trees up to a distance 𝑑 : oneoutbound with 𝑣 as source and one inbound with 𝑣 as target. A so-called stitching algorithm isused to stitch together longer paths from shortest paths of distance at most 𝑑 . To achieve theabove mentioned running time, 𝑑 is set to p 𝑛𝐶 log 𝑛 . The space requirement is O( 𝑛 ) originally,but can be reduced to ˜ O( 𝑛 √ 𝑛𝐶 ) [156]. For non-negative, real-valued edge weights, Demetrescuand Italiano [71] proposed an algorithm with an amortized update time of O( 𝑛 log 𝑛 ) , which waslater improved to O( 𝑛 ( log 𝑛 + log (( 𝑛 + 𝑚 )/ 𝑛 ))) by Thorup [233]. There is no faster algorithmknown for the single-source or even the 𝑠 - 𝑡 setting. The algorithm uses the concept of locally short-est paths , which are paths such that each proper subpath is a shortest path, but not necessarily theentire path, and historical shortest paths , which are paths that have once been shortest paths andwhose edges have not received any weight updates since then. The combination of both yields so-called locally historical paths, which are maintained by the algorithm. To keep their number small,the original sequence of updates is transformed into an equivalent, but slightly longer smoothedsequence . In case of a weight update, the algorithm discards all maintained paths containing theupdated edge and then computes new locally historical paths using a routine similar to Dijkstra’salgorithm. Both algorithms have constant query time and were evaluated experimentally in a study by Demetrescu and Italiano [73] against RRL [75] on random instances, graphs with a single bot-tleneck edge, which serves as a bridge between two equally-sized complete bipartite graphs andonly its weight is subject to updates, as well as real-world instances obtained from the US roadnetworks and autonomous systems networks. Apart from
RRL , the study also comprises the Di-jkstra’s static algorithm. Both these algorithms are designed for single-source shortest paths andwere hence run once per vertex. All algorithms were implemented with small deviations fromtheir respective theoretical description to speed them up in practice. The study showed that
RRL and the algorithm based on locally historical paths (
LHP ) can outperform the static algorithm by afactor of up to
10 000 , whereas the algorithm by King only achieves a speedup factor of around . RRL turned out to be especially fast if the solution changes only slightly, but by contrast exhibitedthe worst performance on the bottleneck instances unless the graphs were sparse. In comparison,
LHP was slightly slower on sparse instances, but could beat
RRL as the density increased. The au-thors also point out differences in performance that depend mainly on the memory architecture ofthe machines used for benchmarking, where
RRL could better cope with small caches or memorybandwidth due to its reduced space requirements and better locality in the memory access pattern,whereas
LHP benefited from larger caches and more bandwidth.Buriol et al. [53] presented a technique that reduces the number of elements that need to beprocessed in a heap after an update for various dynamic shortest paths algorithms by excludingvertices whose distance changes by exactly the same amount as the weight change and handlingthem separately. They showed how this improvement can be incorporated into RR [200], a variantsimilar to RRL [200], the algorithm by King and Thorup [156] ( KT ), and DF [69] and achievesspeedups of up to . for random weight changes and up to . for unit weight changes.To speed up shortest paths computations experimentally, Wagner et al. [240] introduced a con-cept for pruning the search space by geometric containers . Here, each edge ( 𝑢, 𝑣 ) is associated witha set of vertices called container, which is a superset of all vertices 𝑤 whose shortest 𝑢 - 𝑤 pathstarts with ( 𝑢, 𝑣 ) . The authors assume that each vertex is mapped to a point in two-dimensionalEuclidean space and based on this, suggest different types of geometric objects as containers, suchas disks, ellipses, sectors or boxes. All types of container only require constant additional space peredge. The experimental evaluation on static instances obtained from road and railway networksshowed that using the bounding box as container reduces the query time the most in comparisonto running the Dijkstra algorithm without pruning, as the search space could be reduced to to
10 % . This could be preserved for dynamic instances obtained from railway networks if con-tainers were grown and shrunk in response to an update, with a speedup factor of to over arecomputation of the containers from scratch. For bidirectional search, reverse containers need tobe maintained additionally, which about doubled the absolute update time.Delling and Wagner [67] adapted the static ALT algorithm [92] to the dynamic setting.
ALT is avariant of bidirectional 𝐴 ∗ search that uses a small subset of vertices called landmarks , for whichdistances from and to all other vertices are precomputed, and the triangle inequality to direct thesearch for a shortest path towards the target more efficiently. The authors distinguish betweenan eager and a lazy dynamic version of ALT , where the eager one updates all shortest path treesof the landmarks immediately after an update. The lazy variant instead keeps the preprocessedinformation as long as it still guarantees correctness, which holds as long as the weight of an edgeis at least its initial weight, however at the expense of a potentially larger search space. The choiceof landmarks remains fixed. The experimental study on large road networks showed that queriesin the lazy version are almost as fast as in the eager version for short distances or if no edgesrepresenting motorways are affected, but slower by several factors for longer distances, largerchanges to the weight of motorway edges, or after many updates. ecent Advances in Fully Dynamic Graph Algorithms 15
Schultes and Sanders [221] combined and generalized different techniques that have been suc-cessfully used in the static setting, such as separators, highway hierarchies, and transit node rout-ing in a multi-level approach termed highway-node routing : For the set of vertices 𝑉 𝑖 on each level 𝑖 , 𝑉 𝑖 ⊆ 𝑉 𝑖 − , and the overlay graph 𝐺 𝑖 is defined on 𝑉 𝑖 with an edge ( 𝑠, 𝑡 ) ∈ 𝑉 𝑖 × 𝑉 𝑖 iff there is ashortest 𝑠 - 𝑡 path in 𝐺 𝑖 − that contains no vertices in 𝑉 𝑖 except for 𝑠 and 𝑡 . Queries are carried outby a modified Dijkstra search on this graph hierarchy. The authors extended this approach also tothe dynamic setting and consider two scenarios: a server scenario, where in case of edge weightchanges the sets of highway nodes 𝑉 𝑖 are kept and the graphs 𝐺 𝑖 are updated, and a mobile sce-nario, where only those vertices that are potentially affected are determined and the query routineneeds to be aware of possibly outdated information during a search. In an experimental evaluationon a very large road network with dynamically changing travel times as weights it is shown thatthe dynamic highway-node routing outperformed recomputation from scratch as well as dynamic ALT search with landmarks clearly with respect to preprocessing, update, and query time aswell as space overhead.Narváez et al. [179] proposed a framework to dynamize static shortest path algorithms such asDijkstra’s or Bellman-Ford [27]. In a follow-up work [180], they developed a new algorithm thatfits in this framework and is based on the linear programming formulation of shortest paths andits dual, which yields the problem in a so-called ball-and-string model . The authors experimentallyshowed that their algorithm needs fewer comparisons per vertex when processing an update thanthe algorithms from their earlier work, as it can reuse intact substructures of the old shortest pathtree. Chan and Yang [56] studied the problem of dynamically updating a single-source shortest pathtree under multiple concurrent edge weight updates. They amended the algorithm by Narváez etal. [180] ( MBS ), for which they showed that it may misbehave in certain circumstances and sug-gested two further algorithms:
MFP is an optimized version of an algorithm by Ramalingam andReps [199] (
DynamicSWSF-FP ), which can handle multiple updates at once. The second algorithmis a generalization of the dynamic Dijkstra algorithm proposed by Narváez et al. [179]. In a de-tailed evaluation, they showed that an algorithm obtained by combining the incremental phase of
MBS and the decremental phase of their dynamization of Dijkstra’s algorithm performed best onroad networks, whereas the dynamized Dijkstra’s algorithm was best on random networks. Anextensive experimental study on single-source shortest path algorithms was conducted by Bauerand Wagner [23]. They suggested several tuned variants of
DynamicSWSF-FP [199] and evaluatedthem against
FMN [89], different algorithms from the framework by Narváez et al. [179], as well as RR [200] on a diverse set of instances. The algorithms from the Narváez framework showed similarperformance in case of single-edge updates and were the fastest on road networks and generatedgrid-like graphs. By contrast, the tuned variants of DynamicSWSF-FP behaved less consistent. RR was superior on Internet networks, whereas FMN was the slowest, especially on sparse instances.Interestingly, the authors showed that for batch updates with a set of randomly chosen edges, thealgorithms behave similar as for single-edge updates, as there was almost no interference. Thepicture changed slightly for simulated node failures and strongly for simulated traffic jams. RR and a tuned variant of DynamicSWSF-FP showed the best performance for simulated node fail-ures, and two tuned variants of
DynamicSWSF-FP dominated in case of simulated traffic jams.Notably, the algorithms from the Narváez framework were faster here if instead of in batches, theupdates were processed one-by-one. In follow-up works, D’Andrea et al. [65] evaluated severalbatch-dynamic algorithms for single-source shortest paths, where the batches are homogeneous,i.e., all updates are either incremental or decremental. Their study contains RR [200], a tuned vari-ant of DynamicSWSF-FP [199] described by Bauer and Wagner [23] (
TSWSF ), as well as a newalgorithm
DDFLP , which is designed specifically to handle homogeneous batches and uses similar techniques as
FMN [89]. The instance set comprised road and Internet networks as well as ran-domly generated graphs according to the Erdős-Rényi model (uniform degree distribution) and theBarabási-Albert model (power-law degree distribution). Batch updates were obtained from simu-lated node failure and recovery, simulated traffic jam and recovery, as well as randomly selectededges for which the weights were either increased or decreased randomly. The evaluation con-firmed the results by Bauer and Wagner [23] and showed that
DDFLP and
TSWSF are best in caseof update scenarios like node failures or traffic jams and otherwise
TSWSF and RR , where RR ispreferable to TSWSF if the interference among the updates is low and vice versa.
DDFLP generallybenefited from dense instances.For real-time shortest path computations on networks with fixed topology, but varying met-ric, Delling et al. [68] suggested a three-stage approach: In the first, preprocessing step, a metric-independent, moderate amount of auxiliary data is obtained from the network’s topology. It isfollowed by a customization step, which is run for each metric and produces few additional data.Whereas the first phase is run only once and can therefore use more computation time, the secondphase must complete within seconds in real-life scenarios. Shortest path queries form the thirdphase and must be fast enough for actual applications. For the first, metric-independent stage, theauthors describe an approach based on graph partitioning, where the number of boundary edges ,i.e., edges between different partitions, is to be minimized. For the second stage, they compute anoverlay network consisting of shortest paths between all pairs of boundary nodes , i.e. nodes that areincident to at least one boundary edge. An 𝑠 - 𝑡 query is then answered by running a bidirectionalDijkstra algorithm on the graph obtained by combining the overlay graph with the subgraphsinduced by the partitions containing 𝑠 and 𝑡 , respectively. The authors also considered variousoptions for speedups, such as a sparsification of the overlay network, incorporating goal-directedsearch techniques, and multiple levels of overlays. An experimental evaluation on road networkswith travel distances and travel times as metrics showed that their approach allows for real-timequeries and needs only few seconds for the metric-dependent customization phase. Arc flags belong in the category of goal-directed techniques to speed up shortest path computa-tions and have been successfully used in the static setting [24]. To this end, the set of vertices ispartitioned into a number of regions. Each edge receives a label consisting of a flag for each region,which tells whether there is a shortest path starting with this edge and ending in the region. Thetechnique is related to geometric containers and uses the arc flags to prune a (bidirectional) Dijk-stra search. Berettini et al. [36] were the first to consider arc flags in a dynamic setting, howeveronly for the case of weight increases. Their main idea is to maintain a threshold for each edgeand region that gives the increase in weight required for the edge to lie on a shortest path. Ona weight increase, the thresholds are updated and used to determine when to change an arc flag.Although this potentially reduces the quality of the arc flags with each update, the experimentalevaluation showed that the increase in query time is very small as long as the update sequence isshort. With respect to the update time, a significant speedup could be achieved over recomputingarc flags from scratch. To refresh arc flags more exactly and in a fully dynamical setting, D’Angeloet al. [66] introduced a data structure called road signs . Road signs complement arc flags and storefor each edge 𝑒 and region 𝑅 the set of boundary nodes contained in any shortest path startingwith 𝑒 and ending in 𝑅 . In case of a weight increase, the algorithm first identifies all affected nodeswhose shortest path to a boundary node changed and then updates all road signs for all outgoingedges of an affected node. In case of a weight decrease on edge ( 𝑢, 𝑣 ) , the authors observed that allshortest paths containing ( 𝑢, 𝑣 ) remain unchanged. However, shortest paths starting with otheroutgoing or incoming edges of 𝑢 might require updates, as well as other paths containing an incom-ing edge of 𝑢 . In an experimental study on road networks, the authors compared their algorithmagainst one that recomputes arc flags from scratch as well as the algorithm by Berettini et al. [36] ecent Advances in Fully Dynamic Graph Algorithms 17 ( BDD ). To mimic traffic jams and similar occurrences, the weight of a randomly chosen edge in-creases and then decreases by the same amount, however not necessarily in subsequent updates.The evaluation showed that updating both road signs and arc flags is by several factors faster thanrecomputing arc flags from scratch. On instances with weight increases only, the authors showedthat their new algorithm outperforms
BDD distinctly both for updates and queries.
An instance of the maximum flow/minimum cut problem consists of an edge-weighted directedgraph 𝐺 = ( 𝑉 , 𝐸, 𝑐 ) along with two distinguished vertices 𝑠 and 𝑡 . The edge weights 𝑐 are positiveand commonly referred to as capacities . An ( 𝑠 - 𝑡 ) flow 𝑓 is a non-negative weight function on theedges such 𝑓 ( 𝑒 ) ≤ 𝑐 ( 𝑒 ) for all 𝑒 ∈ 𝐸 (capacity constraints) and except for 𝑠 and 𝑡 , the total flow onthe incoming edges of each vertex must equal the total flow on the outgoing edges (conservationconstraints). The excess of a vertex 𝑣 is the total flow on its incoming edges minus that on itsoutgoing edges, which must be zero for all vertices except 𝑠 and 𝑡 . The value of a flow 𝑓 thenis the excess of 𝑡 . The task is to find a flow of maximum value. An ( 𝑠 - 𝑡 ) cut is a subset of edges 𝐶 ⊆ 𝐸 whose removal makes 𝑡 unreachable from 𝑠 , and its value is the sum of the capacities of alledges in the cut. The well-known max-flow min-cut theorem states that the maximum value of aflow equals the minimum value of a cut. The fastest static algorithm whose running time does notdepend on the size of the largest edge weight computes an optimal solution in O( 𝑛𝑚 ) time [187].In the dynamic setting, there is a conditional lower bound of ( poly , 𝑚 / − 𝜖 , 𝑚 − 𝜖 ) (for anysmall constant 𝜖 > ) for the size of the maximum 𝑠 - 𝑡 flow even in unweighted, undirectedgraphs based on the OMv conjecture [116]. Recently Chen et al. [60] gave an O( log 𝑛 log log 𝑛 ) -approximate fully dynamic maximum flow algorithm in time ˜ 𝑂 ( 𝑛 / + 𝑜 ( ) ) per update and Goranciet al. [95] gave a 𝑛 𝑜 ( ) -approximate fully dynamic algorithm in time 𝑛 𝑜 ( ) worst-case update timeand O( log / 𝑛 ) query time. In the unweighted setting Jin and Sun [144] gave a datastructure thatcan be constructed for any fixed positive integer 𝑐 = ( 𝑙𝑜𝑔𝑛 ) 𝑜 ( ) and that answers 𝑐 -edge connec-tivity queries for any pair ( 𝑢, 𝑣 ) of vertices that are parameters of the query in time 𝑛 𝑜 ( ) .Kumar and Gupta [162] extended the preflow-push approach [93] to solve maximum flow instatic graphs to the dynamic setting. A preflow is a flow under a relaxed conservation constraintin that the excess of all vertices except 𝑠 must be non-negative. Vertices with positive excess arecalled active . Preflow-push algorithms, also called push-relabel algorithms, use this relaxed variantof a flow during the construction of a maximum flow along with distance labels on the vertices.Generally speaking, they push flow out of active vertices towards vertices with smaller distance(to 𝑡 ) and terminate with a valid flow (i.e., observing conservation constraints). In case of an edgeinsertion or deletion, Kumar and Gupta first identify affected vertices via forward and backwardbreadth-first search while observing and updating distance labels and then follow the schemeof a basic preflow-push algorithm, however restricted to the set of affected vertices. The authorsevaluated their algorithm only for the incremental setting on a set of randomly generated instancesagainst the static preflow-push algorithm in [93] and found that their algorithm is able to reducethe number of push and relabel operations significantly as long as the instances are sparse and thenumber of affected vertices remains small.Many important fields of application for the maximum flow/minimum cut problem stem fromcomputer vision. In this area, the static algorithm of Boykov and Kolmogorov [48] ( BK ) is widelyused due to its good performance in practice on computer vision instances and despite its pseudo-polynomial worst-case running time of O( 𝑛𝑚 · Opt ) , with Opt being the value of a maximum flow/minimum cut. Interestingly, however, a study by Verma and Batra [239] shows that its practi-cal superiority only holds for sparse instances. BK follows the Ford-Fulkerson method of augment-ing flow along 𝑠 - 𝑡 paths, but uses two search trees grown from 𝑠 and 𝑡 , respectively, to find suchpaths. Kohli and Torr [157, 158] extended BK to the fully dynamic setting by updating capacitiesand flow upon changes and discuss an optimization that tries to recycle the search trees. They ex-perimentally compared their algorithm to repeated executions of the static algorithm on dynamicinstances obtained from video sequences and achieve a substantial speedup. They also observedthat reusing the search trees leads to longer 𝑠 - 𝑡 paths, which affects the update time negatively asthe instances undergo many changes.Goldberg et al. [94] developed EIBFS , a generalization of their earlier algorithm
IBFS , that bycontrast also extends to the dynamic setting in a straightforward manner.
IBFS in turn is a modifi-cation of BK that ensures that the two trees grown from 𝑠 and 𝑡 are height-minimal (i.e., BFS trees)and is closely related to the concept of blocking flows. The running time of EIBFS in the staticsetting and thus the initialization in the dynamic setting, is O( 𝑚𝑛 log ( 𝑛 / 𝑚 )) with dynamic treesor O( 𝑚𝑛 ) without. The algorithm works with a so-called pseudoflow, which observes capacityconstraints, but may violate conservation constraints. It maintains two vertex-disjoint forests 𝑆 and 𝑇 , where the roots are exactly those vertices with a surplus of incoming flow and those witha surplus of outgoing flow, respectively, and originally only contain 𝑠 and 𝑡 . The steps of the algo-rithm consist in growth steps, where 𝑆 or 𝑇 are grown level-wise, augmentation steps, which occurif a link between the forests has been established and flow is pushed to a vertex in the other forestand further on to the root, and adoption steps, where vertices in 𝑇 with surplus incoming flow orvertices in 𝑆 with surplus outgoing flow are either adopted by a new parent in the same forest orbecome a root in the other forest. In case of an update in the dynamic setting, the invariants ofthe forests are restored and flow is pushed where possible, followed by alternating augmentationand adoption steps if necessary. The authors also mention that resetting the forests every O( 𝑚 ) work such that they contain only vertices with a surplus outgoing or incoming flow seemed to bebeneficial in practice. In their experimental evaluation of EIBFS against the algorithm by Kohli andTorr as well as an altered version thereof and a more naive dynamization of
IBFS , they showed fordifferent dynamic real-world instances from the field of computer vision that
EIBFS is the fasteston eight out of fourteen instances and relatively robust: In contrast to its competitors, it alwaystakes at most roughly twice the time of the fastest algorithm on an instance. Notably, no algorithmis dominated by another one across all instances.Zhu et al. [254] described a dynamic update strategy based on augmenting and de-augmentingpaths as well as cancelling cyclic flows. The latter serves as a preparatory step and only reroutesflow in the network without increasing or decreasing the total 𝑠 - 𝑡 flow and is only necessary in adecremental update operation. They experimentally evaluated the effectiveness of their algorithmfor online semi-supervised learning, where real-world big data is classified via minimum cuts,and showed that their algorithm outperforms state-of-the-art stream classification algorithms. Avery similar algorithm was proposed by Greco et al. [102]. The authors compared it experimen-tally against EIBFS and the dynamic BK algorithm by Kohli and Torr as well as a number of thecurrently fastest static algorithms. Their experiments were conducted on a set of instances fromcomputer vision where equally many edges are randomly chosen to be inserted and deleted, re-spectively. They showed that their algorithm is with one exception always the fastest on averagein performing edge insertions if compared to the average update time of the competitors, and onhalf of all instances also in case of edge deletions. On the remaining instances, the average updatetime of EIBFS dominated. ecent Advances in Fully Dynamic Graph Algorithms 19
Graph clustering is the problem of detecting tightly connected regions of a graph. More precisely,a clustering C is a partition of the set of vertices, i.e. a set of disjoint clusters of vertices 𝑉 ,. . . , 𝑉 𝑘 such that 𝑉 ∪· · ·∪ 𝑉 𝑘 = 𝑉 . However, 𝑘 is usually not given in advance and some objective functionthat models intra-cluster density versus inter-cluster sparsity, is optimized. It is common knowl-edge that there is neither a single best strategy nor objective function for graph clustering, whichjustifies a plethora of existing approaches. Moreover, most quality indices for graph clusteringshave turned out to be NP-hard to optimize and are rather resilient to effective approximations, see,e.g. [17, 49], allowing only heuristic approaches for optimization. There has been a wide-rangeof algorithms for static graph clustering, the majority are based on the paradigm of intra-clusterdensity versus inter-cluster sparsity. For dynamic graphs, there has been a recent survey on thetopic of community detection [208]. The survey covers features and challenges of dynamic com-munity detection and classifies published approaches. Here we focus on engineering results andextend their survey in that regard with additional references as well as results that appeared inthe meantime. Most algorithms in the area optimize for modularity. Modularity has recently beenproposed [184]. The core idea for modularity is to take coverage, i.e. the fraction of edges coveredby clusters, minus the expected value of the same quantity in a network with the same communitydivisions, but random connections between the vertices. The commonly used formula is as follows:mod (C) : = 𝑚 (C) 𝑚 − 𝑚 Í 𝐶 ∈C ( Í 𝑣 ∈ 𝐶 deg 𝑣 ) .Miller and Eliassi-Rad [175] adapted a dynamic extension of Latent Dirichlet Allocation for dy-namic graph clustering. Latent Dirichlet Allocation has been originally proposed for modelingtext documents, i.e. the algorithm assumes that a given set of documents can be classified into 𝑘 topics. This approach has been transferred to graphs [113] and was adapted by the authors for dy-namic networks. Aynaud and Guillaume [19] tracked communities between successive snapshotsof the input network. They first noted that using standard community detection algorithms resultsin stability issues, i.e. little modifications of the network can result in wildly different clusterings.Hence, the authors propose a modification of the Louvain method to obtain stable clusterings. Thisis done by modifying the initialization routine of the Louvain method. By default, the Louvainmethod starts with each node being in its own clustering. In the modified version of Aynaud andGuillaume, the algorithm keeps the clustering of the previous time step and uses this as a startingpoint for the Louvain method which results in much more stable clusterings. Bansal et al. [20] alsoreused the communities from previous time steps. However, their approach is based on greedy ag-glomeration where two communities are merged at each step to optimize the modularity objectivefunction. The authors improved the efficiency of dynamic graph clustering algorithms by limit-ing recomputation to regions of the network and merging processes that have been affected byinsertion and deletion operations. Görke et al. [97] showed that the structure of minimum 𝑠 - 𝑡 -cutsin a graph allows for efficient updates of clusterings. The algorithm builds on partially updatinga specific part of a minimum-cut tree and is able to maintain a clustering fulfilling a provablequality guarantee, i.e. the clusterings computed by the algorithm are guaranteed to yield a certainexpansion. To the best of our knowledge, this is the only dynamic graph clustering algorithm thatprovides such a guarantee. Later, Görke et al. [96, 99] formally introduced the concept of smooth-ness to compare consecutive clusterings and provided a portfolio of different update strategies fordifferent types of local and global algorithms. Moreover, their fastest algorithm is guaranteed torun in time Θ ( log 𝑛 ) per update. Their experimental evaluation indicates that dynamically main-taining a clustering of a dynamic random network saves time and at the same time also yieldshigher modularity than recomputation from scratch. Alvari et al. [10] proposed a dynamic gametheory method to tackle the community detection problem in dynamic social networks. Roughly speaking, the authors model the process of community detection as an iterative game performed ina dynamic multiagent environment where each node is an agent who wants to maximize its totalutility. In each iteration, an agent can decide to join, switch, leave, or stay in a community. The newutility is then computed by the best outcome of these operations. The authors use neighborhoodsimilarity to measure structural similarity and optimize for modularity. The experimental evalua-tion is limited to two graphs. Zakrzweska and Bader [249] presented two algorithms that updatecommunities. Their first algorithm is similar to the dynamic greedy agglomeration algorithm byGörke et al. [99]. The second algorithm is a modification of the first one that runs faster. This firstis achieved by more stringent backtracking of merges than Görke et al. [99], i.e. merges are onlyundone if the merge has significantly changed the modularity score of the clustering. Moreover,the authors used a faster agglomeration scheme during update operations that uses informationabout previous merges to speed up contractions. Recently, Zhuang et al. [255] proposed the Dy-naMo algorithm which also is a dynamic algorithm for modularity maximization, however thealgorithm processes network changes in batches.
We will describe three popular measures to find central nodes in networks in the fully dynamicsetting: Katz centrality, betweenness centrality and closeness centrality. Note that there are notheoretical results for these topics, neither upper nor lower bounds. This is an obvious area forfuture work.
Katz Centrality.
Katz centrality is a centrality metric that measure the relation between verticesby counting weighted walks between them. Nathan and Bader [181] were the first to look at theproblem in a dynamic setting. At that time, static algorithms mostly used linear algebra-based tech-niques to compute Katz scores. The dynamic version of their algorithm incrementally updates thescores by exploiting properties of iterative solvers, i.e. Jacobi iterations. Their algorithm achievedspeedups of over two orders of magnitude over the simple algorithms that perform static recompu-tation every time the graph changes. Later, they improved their algorithm [182] to handle updatesby using an alternative, agglomerative method of calculating Katz scores. While their static algo-rithm is already several orders of magnitude faster than typical linear algebra approaches, theirdynamic algorithm is also faster than pure static recomputation every time the graph changes. Adrawback of the algorithms by Nathan and Bader is that they are unable to reproduce the exactKatz ranking after dynamic updates. Van der Grinten et al. [236] fixed this problem by presentinga dynamic algorithm that iteratively improves upper and lower bounds on the centrality scores.The computed scores are approximate, but the bounds guarantee the correct ranking. The dynamicalgorithm improves over the static recomputation of the Katz rankings as long as the size of thebatches in the update sequence is smaller than 10 000.
Betweenness Centrality.
Given a graph and a vertex 𝑣 in the graph, the betweenness central-ity measure is defined to be 𝑐 ( 𝑣 ) = Í 𝑢,𝑤,𝑢 ≠ 𝑤 𝜎 𝑢,𝑤 ( 𝑣 ) 𝜎 𝑢,𝑤 , where 𝜎 𝑢,𝑤 is the number of shortest pathsbetween 𝑢 and 𝑤 and 𝜎 𝑢,𝑤 ( 𝑣 ) is the number of shortest paths between 𝑢 and 𝑤 that include 𝑣 .Statically computing betweenness centrality involves solving the all-pairs shortest path problem.Dynamically maintaining betweenness centrality is challenging as the insertion or deletion of asingle edge can lead to changes of many shortest paths in the graph. The QUBE algorithm [164]was the first to provide a non-trivial update routine. The key idea is to perform the betweennesscomputation on a reduced set of vertices, i.e. the algorithm first finds vertices whose centrality in-dex might have changed. Betweenness centrality is then only computed on the first set of vertices. ecent Advances in Fully Dynamic Graph Algorithms 21
However,
QUBE is limited to the insertion and deletion of non-bridge edges. Green et al. [103]presented an incremental algorithm and proposed to maintain additional information, such as pre-decessor lists, to limit the recomputations to the nodes whose betweenness has been affected.Later, Kas et al. [150] presented an incremental algorithm that additionally allows to decrease thecost of an edge. As their algorithm for computing betweenness centrality is based on the solu-tion to the all-pairs shortest path problem, the authors extended an existing incremental shortestpath algorithm [198] for their problem. Lee et al. [165] extended the
QUBE algorithm [164] to beable to insert and delete non-bridge edges. Moreover, the authors reduced the number of short-est paths that need to be recomputed and thus gained additional speedups over
QUBE . Kourtelliset al. [159, 160] contributed an algorithm that maintains both vertex and edge betweenness central-ity. Their algorithm needs less space than the algorithm by Green et al. [103] as it avoids storingpredecessor lists. Their method can be parallelized and runs on top of parallel data processingengines such as Hadoop. Bergamini et al. [31] presented an incremental approximation algorithmfor the problem. As a building block of their algorithm, the authors used an asymptotically fasteralgorithm for the dynamic single-source shortest path problem and additionally sample shortestpaths. Experiments indicate that the algorithm can be up to four orders of magnitude faster com-pared to restarting the static approximation algorithm by Riondato and Kornaropoulos [203]. Inthe same year, the authors extended their algorithm to become a fully dynamic approximation al-gorithm for the problem [29, 30]. In addition to dynamic single-source shortest paths, the authorsalso employed an approximation of the vertex diameter that is needed to compute the numberof shortest paths that need to be sampled as a function of a given error guarantee that shouldbe achieved. Hayashi et al. [112] provided a fully dynamic approximation algorithm that is alsobased on sampling. In contrast to Bergamini et al. [29–31], which selects between each pair of sam-pled vertices, the authors save all the paths between each sampled pair of vertices. Moreover, theshortest paths are represented in a data structure called hypergraph sketch. To further reduce therunning time when handling unreachable pairs, the authors maintain a reachability index. Later,Bergamini et al. [32] presented an updated version of their incremental algorithm for the problem.The algorithm is based on a new dynamic algorithm for the augmented all-pairs shortest pathproblem as well as a new approach for updating the betweenness scores. Gil-Pons [196] focusedon exact betweenness in incremental graphs. The author presented a space-efficient algorithmwith linear space complexity. Lastly, Chehreghani et al. [59] focused on the special case in whichthe betweenness of a single node has to be maintained under updates.
Closeness Centrality:
Given a graph and a vertex 𝑣 , the harmonic closeness centrality measure isdefined as clo ( 𝑣 ) = Í 𝑢 ∈ 𝑉 ,𝑢 ≠ 𝑣 𝑑 ( 𝑢,𝑣 ) where 𝑑 ( 𝑢, 𝑣 ) is the distance between 𝑢 and 𝑣 . Roughly speak-ing, it is the sum of the reciprocal length of the shortest path between the node and all other nodesin the graph. Baevla’s definition of closeness centrality is similarly | 𝑉 |− Í 𝑣 ∈ 𝑉 𝑑 ( 𝑢,𝑣 ) . Kas et al. [149] werethe first to give an fully dynamic algorithm for the problem. As computing closeness centrality de-pends on the all-pairs shortest path problem, the authors extended an existing dynamic all-pairsshortest path algorithm [198] for their problem (similar to the algorithm by Kas et al. [150] for be-tweenness centrality). As the algorithm stores pairwise distances between nodes it has quadraticmemory requirement. Sariyuce et al. [213] provided an algorithm that can handle insertions anddeletions. In contrast to Kas et al. [149], the authors used static single-source shortest paths fromeach vertex. The algorithm does not need to store pairwise distances and hence requires only alinear amount of memory. Moreover, the authors observed that in scale-free networks the diame-ter grows proportional to the logarithm of the number of nodes, i.e. the diameter is typically small.When the graph is modified with minor updates, the diameter also tends to stay small. This can beused to limit the number of vertices that need to updated. In particular, the authors showed that recomputation of closeness can be skipped for vertices 𝑠 such that | 𝑑 ( 𝑠, 𝑢 ) − 𝑑 ( 𝑠, 𝑣 )| = where 𝑢 , 𝑣 are the endpoints of the newly inserted edge. Lastly, the authors used data reduction rules to filtervertices, i.e. real-life networks can contain nodes that have the same or similar neighborhood struc-ture that can be merged. Later, Sariyuce et al. [214, 215] proposed a distributed memory-parallelalgorithm for the problem. Yen et al. [248] proposed the fully dynamic algorithm CENDY whichcan reduce the number of internal updates to a few single-source shortest path computations nec-essary by using breadth-first searches. The main idea is that given an augmented rooted BFS treeof an unweighted network, edges that are inserted or deleted within the same level of the tree donot change the distances from the root to all other vertices. Putman et al. [197] provided a fasteralgorithm for fully dynamic harmonic closeness. The authors also used a filtering method to heav-ily reduce the number of computations for each incremental update. The filtering method is anextension of level-based filtering to directed and weighted networks. The dynamic algorithm byShao et al. [224] maintains closeness centrality by efficiently detecting all affected shortest pathsbased on articulation points. The main observation is that a graph can be divided into a seriesof biconnected components which are connected by articulation points – the distances betweentwo arbitrary vertices in the graph can be expressed as multiple distances between different bicon-nected components.Bisenius et al. [47] contributed an algorithm to maintain top- 𝑘 harmonic closeness in fully dy-namic graphs. The algorithm is not required to compute closeness centrality for the initial graphand the memory footprint of their algorithm is linear. Their algorithm also tries to skip recom-putations of vertices that are unaffected by the modifications of the graph by running breadth-first searches. Crescenzi et al. [62] gave a fully dynamic approximation algorithm for top- 𝑘 har-monic closeness. The algorithm is based on sampling paths and a backward dynamic breadth-firstsearch algorithm. Typically the graph partitioning problem asks for a partition of a graph into 𝑘 blocks of aboutequal size such that there are few edges between them. More formally, given a graph 𝐺 = ( 𝑉 , 𝐸 ) ,we are looking for disjoint blocks of vertices 𝑉 ,. . . , 𝑉 𝑘 that partition 𝑉 , i.e., 𝑉 ∪ · · · ∪ 𝑉 𝑘 = 𝑉 . A balancing constraint demands that all blocks have weight 𝑐 ( 𝑉 𝑖 ) ≤ ( + 𝜖 ) ⌈ 𝑐 ( 𝑉 ) 𝑘 ⌉ for some imbalanceparameter 𝜖 . The most used objective is to minimize the total cut 𝜔 ( 𝐸 ∩ Ð 𝑖 < 𝑗 𝑉 𝑖 × 𝑉 𝑗 ) . The problemis known to be NP-hard and no constant-factor approximation algorithms exist. Thus heuristicalgorithms are mostly used in practice. Dynamic graph partitioning algorithms are also known inthe community as repartitioning algorithms. As the problem is typically not solved to optimality inpractice, repartitioning involves a tradeoff between the quality , i.e. the number of edges in differentsets of the partitioning, and the amount of vertices that need to change their block as they causecommunication when physically moved between the processors as the partition is adopted. Thelatter is especially important when graph partitioning is used in adaptive numerical simulations.In these simulations, the main goal is to partition a model of computation and communicationin which nodes model computation and edges model communication. The blocks of the partitionare then fixed to a specific processing element. When the dynamic graph partitioning algorithmdecides to change the blocks due to changes in the graph topology, nodes that are moved to adifferent block create communication in the simulation system as the underlying data needs to bemoved between the corresponding processors.Hendrikson et al. [114] tackled the repartitioning problem by introducing 𝑘 virtual vertices. Eachof the virtual vertices is connected to all nodes of its corresponding block. The edges get a weight 𝛼 which is proportional to the migration cost of a vertex and the vertex weights of the virtual ecent Advances in Fully Dynamic Graph Algorithms 23 vertices are set to zero. Then an updated partition can be computed using a static partitioningalgorithm since the model accounts for migration costs and edge cut size at the same time.Schloegel et al. [218] presented heuristics to control the tradeoff between edge-cut size andvertex migration costs. The most simple algorithm is to compute a completely new partition andthen determine a mapping between the blocks of the old and the new partition that minimizesmigration. The more sophisticated algorithm of [218] is a multilevel algorithm based on a simpleprocess, i.e. nodes are moved from blocks that contain too many vertices to blocks that contain notenough vertices. However, this approach often yields partitions that cut a large number of edges.The result has been improved later by combining the two approaches in the parallel partitioningtool ParMetis [219]. Schloegel et al. [220] later extended their algorithm to be able to handle mul-tiple balance constraints. Hu and Blake [129] noted that diffusion processes can suffer from slowconvergence and improved the performance of diffusion through the use of Chebyshev polyno-mials. More precisely, the diffusion process in their paper is a directed diffusion that computesa diffusion solution by solving a so-called head conduction equation while minimizing the datamovement. Walshaw et al. [241] integrated a repartitioning algorithm into their parallel (mean-while uncontinued) tool
Jostle . The algorithm is a directed diffusion process based on the solverproposed by Hu and Blake [129]. Rotaru and Nägeli [209] extended previous diffusion-based al-gorithms to be able to handle heterogeneous systems. These approaches, however, have certainweaknesses: For example, in numerical applications the maximum number of boundary nodes of ablock is often a better estimate of the occurring communication in the simulation than the numberof edges cut. Meyerhenke and Gehweiler [173, 174] explored a disturbed diffusion process that isable to overcome some of the issues of the previous approaches. To do so, Meyerhenke adapted
DIBAP , a previously developed algorithm that aims at computing well-shaped partitions. A diffu-sion process is called disturbed if its convergence state does not result in a balanced distribution.These processes can be helpful to find densely connected regions in the graph.There has been also work that tackles slightly different problem formulations. Kiefer et al. [153]noted that performance in applications usually does not scale linearly with the amount of workper block due to contention on different compute components. Their algorithm uses a simplifiedpenalized resource consumption model. Roughly speaking, the authors introduced a penalizedblock weight and modified the graph partitioning problem accordingly. More precisely, a positive,monotonically increasing penalty function 𝑝 is used to penalize the weight of a block based on thepartition cardinality. Vaquero et al. [238] looked at the problem for distributed graph processingsystems. Their approach is based on iterative vertex migration based on label propagation. Moreprecisely, a vertex has a list of candidate blocks where the highest number of its neighbors arelocated. However, initial partitions are computed using hashing which does not yield high qualitypartitions since it completely ignores the structure of the graph. The authors did not compare theirwork against other state-of-the art repartitioning algorithms, so it is unclear how well the algo-rithm performs compared to other algorithms. Xuet al. [246] and Nicoara et al. [185] also presenteddynamic algorithms specifically designed for graph processing systems. Other approaches have fo-cused on the edge partitioning problem [85, 131, 210] or the special case of road networks [50]. The methodology of the previous two sections is to engineer algorithms for specific dynamic graphproblems. In contrast to this, there are also approaches that try to engineer dynamic graph systemsthat can be applied to a wide range of dynamic graph problems. Alberts et al. [8] started this effortand presented a software library of dynamic graph algorithms. The library is written in C++ andis an extension of the well known
LEDA library of efficient data types and algorithms. The librarycontains algorithms for connectivity, spanning trees, single-source shortest paths and transitive closure.A decade later Weigert et al. [244] presented a system that is able to deal with dynamic distributedgraphs, i.e. in settings in which a graph is too large for the memory of a single machine and,thus, needs to be distributed over multiple machines. A user can implement a query function toimplement graph queries. Based on their experiments, the system appears to scale well to largedistributed graphs. Ediger et al. [80] engineered
STINGER which is short for Spatio-TemporalInteraction Networks and Graphs Extensible Representation.
STINGER provides fast insertions,deletions, and updates on semantic graphs that have a skewed degree distribution. The authorsshowed in their experiments that the system can handle 3 million updates per second on a scale-free graph with 537 million edges on a Cray XMT machine. The authors already implemented avariety of algorithms on
STINGER including community detection, 𝑘 -core extraction, and manymore. Later, Feng et al. [86] presented DISTINGER which has the same goals as
STINGER , but fo-cuses on the distributed memory case, i.e. the authors presented a distributed graph representation.Vaquero et al. [237] presented a dynamic graph processing system that uses adaptive partitioningto update the graph distribution over the processors over time. This speeds up queries as a bettergraph distribution significantly reduces communication overhead. Experiments showed that therepartitioning heuristic (also explained in Section 3.13) improves computation performance in theirsystem up to
50 % for an algorithm that computes the estimated diameter in a graph. Senguptaet al. [222] introduced a dynamic graph analytics framework called
GraphIn . Part of
GraphIn isa new programming model based on the gather-apply-scatter programming paradigm that allowsusers to implement a wide range of graph algorithms that run in parallel. Compared to
STINGER ,the authors reported a . -fold speedup. Iwabuchi et al. [141] presented an even larger speedupover STINGER . Their dynamic graph data store is, like
STINGER , designed for scale-free networks.The system uses compact hash tables with high data locality. In their experiments, their systemcalled
DegAwareRHH , is a factor . faster than STINGER .Another line of research focuses on graph analytic frameworks and data structures for GPUs.Green and Bader [86] presented cuSTINGER , which is a GPU extension of STINGER and targetsNVIDIA’s CUDA supported GPUs. One drawback of cuSTINGER is that the system has to performrestarts after a large number of edge updates. Busato et al. fixed this issue in their system, called
Hornet , and, thus, outperform cuSTINGER . Moreover,
Hornet uses a factor of 5 to 10 less memorythan cuSTINGER . In contrast to previous approaches, faimGraph due to Winter et al. [245] isable to deal with a changing number of vertices. Awad et al. [18] noted that the experimentsperformed by Busato et al. are missing true dynamism that is expected in real world scenarios andproposed a dynamic graph structure that uses one hash table per vertex to store adjacency lists.The system achieves speedups between . to . compared to Hornet and . to . compared to faimGraph for batched edge insertions (and slightly smaller speedups for batched edge deletions).The algorithm also supports vertex deletions, as does faimGraph . Currently there is a limited amount of real-world fully dynamic networks publicly available. Thereare repositories that feature a lot of real-world insertions only instances such as SNAP andKONECT . However, since the fully dynamic instances are rarely available at the moment, westart a new graph repository that provides fully dynamic graph instances . Currently, there isalso very limited work on dynamic graph generators. A generator for clustered dynamic random https://snap.stanford.edu/ http://konect.cc/ https://DynGraphLab.github.io ecent Advances in Fully Dynamic Graph Algorithms 25 networks has been proposed by Görke et al. [98]. Another approach is due to Sengupta [223] togenerate networks for dynamic overlapping communities in networks. A generative model fordynamic networks with community structure can be found in [25]. This is a widely open topicfor future work, both in terms of oblivious adversaries as well as adaptive adversaries. To stillbe able to evaluate fully dynamic algorithms in practice, research uses a wide range of models atthe moment to turn static networks into dynamic ones. We give a brief overview over the mostimportant ones. In undo-based approaches, edges of a static network are inserted in some orderuntil all edges are inserted. In the end, x % of the last insertions are undone. The intuition hereis that one wants undo changes that happened to a network and to recreate a previous state ofthe data structure. In window-based approaches, edges are inserted and have a predefined lifetime.That means an edge is deleted after a given number 𝑑 of new edges have been inserted. In removeand add based approaches, a small fraction of random edges from a static network is removed andlater on reinserted. In practice, researchers use a single edge as well as whole batches of edges.In morphing-based approaches, one takes two related networks and creates a sequence of edgeupdates such that the second network obtained after the update sequence has been applied tothe first network. ACKNOWLEDGEMENTS
We acknowledge the Austrian Science Fund (FWF) and netIDEE SCIENCE project P 33775-N. More-over, we have been partially supported by DFG grant SCHU 2567/1-2.
REFERENCES [1] , 2010. IEEE. ISBN 978-1-4244-7523-0. URLhttps://ieeexplore.ieee.org/xpl/conhome/5509122/proceeding.[2]
Proc. of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, Califor-nia, USA, January 6-9, 2019 , 2019. SIAM. ISBN 978-1-61197-548-2. doi: 10.1137/1.9781611975482. URLhttps://doi.org/10.1137/1.9781611975482.[3] Amir Abboud and Søren Dahlgaard. Popular conjectures as a barrier for dynamic planar graph algorithms. In , pages 477–486. IEEE, 2016.[4] Amir Abboud and Virginia Vassilevska Williams. Popular conjectures imply strong lower bounds for dynamicproblems. In
Foundations of Computer Science (FOCS), 2014 IEEE 55th Annual Symposium on , pages 434–443. IEEE,2014. doi: 10.1109/FOCS.2014.53. URL https://doi.org/10.1109/FOCS.2014.53.[5] Amir Abboud, Raghavendra Addanki, Fabrizio Grandoni, Debmalya Panigrahi, and Barna Saha. Dynamic set cover:improved algorithms and lower bounds. In Moses Charikar and Edith Cohen, editors,
Proc. of the 51st Annual ACMSIGACT Symposium on Theory of Computing, STOC 2019, Phoenix, AZ, USA, June 23-26, 2019 , pages 114–125. ACM,2019. doi: 10.1145/3313276.3316376. URL https://doi.org/10.1145/3313276.3316376.[6] Nesreen K. Ahmed, Nick G. Duffield, Theodore L. Willke, and Ryan A. Rossi. On sampling from mas-sive graph streams.
Proc. VLDB Endow.
ACMJ. Exp. Algorithmics , 2:5, 1997. doi: 10.1145/264216.264223. URL https://doi.org/10.1145/264216.264223.[8] David Alberts, Giuseppe Cattaneo, Giuseppe F Italiano, Umberto Nanni, and Christos Zaroliagis. A software libraryof dynamic graph algorithms. In
Proc. Workshop on Algorithms and Experiments , pages 129–136. Citeseer, 1998.[9] Bowen Alpern, Roger Hoover, Barry K. Rosen, Peter F. Sweeney, and F. Kenneth Zadeck. Incremental eval-uation of computational circuits. In David S. Johnson, editor,
Proc. of the First Annual ACM-SIAM Sympo-sium on Discrete Algorithms, 22-24 January 1990, San Francisco, California, USA , pages 32–42. SIAM, 1990. URLhttp://dl.acm.org/citation.cfm?id=320176.320180.[10] Hamidreza Alvari, Alireza Hajibagheri, and Gita Reese Sukthankar. Community detection in dynamic social net-works: A game-theoretic approach. In Xindong Wu, Martin Ester, and Guandong Xu, editors, , pages 101–107. IEEE Computer Society, 2014. ISBN 978-1-4799-5877-1. doi: 10.1109/ASONAM.2014.6921567.URL https://doi.org/10.1109/ASONAM.2014.6921567. [11] Abhash Anand, Surender Baswana, Manoj Gupta, and Sandeep Sen. Maintaining approximate maximumweighted matching in fully dynamic graphs. In Deepak D’Souza, Telikepalli Kavitha, and Jaikumar Radhakr-ishnan, editors,
IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Sci-ence, FSTTCS 2012, December 15-17, 2012, Hyderabad, India , volume 18 of
LIPIcs , pages 257–266. Schloss Dagstuhl- Leibniz-Zentrum für Informatik, 2012. ISBN 978-3-939897-47-7. doi: 10.4230/LIPIcs.FSTTCS.2012.257. URLhttps://doi.org/10.4230/LIPIcs.FSTTCS.2012.257.[12] Bertie Ancona, Monika Henzinger, Liam Roditty, Virginia Vassilevska Williams, and Nicole Wein. Algorithms andhardness for diameter in dynamic graphs. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and StefanoLeonardi, editors, , volume 132 of
LIPIcs , pages 13:1–13:14. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.doi: 10.4230/LIPIcs.ICALP.2019.13. URL https://doi.org/10.4230/LIPIcs.ICALP.2019.13.[13] Moab Arar, Shiri Chechik, Sarel Cohen, Cliff Stein, and David Wajc. Dynamic matching: Reducing inte-gral algorithms to approximately-maximal fractional algorithms. In , pages 7:1–7:16, 2018. doi: 10.4230/LIPIcs.ICALP.2018.7. URLhttps://doi.org/10.4230/LIPIcs.ICALP.2018.7.[14] Sabeur Aridhi, Martin Brugnara, Alberto Montresor, and Yannis Velegrakis. Distributed k-core decomposition andmaintenance in large dynamic graphs. In
Proc. of the 10th ACM International Conference on Distributed and Event-based Systems , pages 161–168, 2016. doi: 10.1145/2933267.2933299. URL https://doi.org/10.1145/2933267.2933299.[15] Sepehr Assadi, Krzysztof Onak, Baruch Schieber, and Shay Solomon. Fully dynamic maximal independent set withsublinear update time. In Ilias Diakonikolas, David Kempe, and Monika Henzinger, editors,
Proc. of the 50th AnnualACM SIGACT Symposium on Theory of Computing, STOC 2018, Los Angeles, CA, USA, June 25-29, 2018 , pages 815–826.ACM, 2018. doi: 10.1145/3188745.3188922. URL https://doi.org/10.1145/3188745.3188922.[16] Sepehr Assadi, Krzysztof Onak, Baruch Schieber, and Shay Solomon. Fully dynamic maximal independent set withsublinear in n update time. In
Proc. of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA2019, San Diego, California, USA, January 6-9, 2019
DBL [2], pages 1919–1936. ISBN 978-1-61197-548-2. doi: 10.1137/1.9781611975482.116. URL https://doi.org/10.1137/1.9781611975482.116.[17] G. Ausiello, P. Crescenzi, G. Gambosi, V. Kann, A. Marchetti-Spaccamela, and M. Protasi.
Complexity and Approxima-tion: Combinatorial Optimization Problems and their Approximability Properties . Springer Science & Business Media,2012.[18] Muhammad A. Awad, Saman Ashkiani, Serban D. Porumbescu, and John D. Owens. Dynamic graphson the GPU. In , pages 739–748. IEEE, 2020. doi: 10.1109/IPDPS47924.2020.00081. URLhttps://doi.org/10.1109/IPDPS47924.2020.00081.[19] Thomas Aynaud and Jean-Loup Guillaume. Static community detection algorithms for evolving networks. In
DBL [1], pages 513–519. ISBN 978-1-4244-7523-0. URLhttp://ieeexplore.ieee.org/document/5520221/.[20] Shweta Bansal, Sanjukta Bhowmick, and Prashant Paymal. Fast community detection for dynamic complex networks.In Luciano da F. Costa, Alexandre G. Evsukoff, Giuseppe Mangioni, and Ronaldo Menezes, editors,
Complex Networks- Second International Workshop, CompleNet 2010, Rio de Janeiro, Brazil, October 13-15, 2010, Revised Selected Papers ,volume 116 of
Communications in Computer and Information Science , pages 196–207. Springer, 2010. ISBN 978-3-642-25500-7. doi: 10.1007/978-3-642-25501-4\_20. URL https://doi.org/10.1007/978-3-642-25501-4_20.[21] Surender Baswana, Ramesh Hariharan, and Sandeep Sen. Improved decremental algorithms for maintaining tran-sitive closure and all-pairs shortest paths.
J. Algorithms , 62(2):74–92, 2007. doi: 10.1016/j.jalgor.2004.08.004. URLhttps://doi.org/10.1016/j.jalgor.2004.08.004.[22] Surender Baswana, Manoj Gupta, and Sandeep Sen. Fully dynamic maximal matching in 𝑂 ( log 𝑛 ) update time. SIAM J. Comput. , 44(1):88–113, 2015. doi: 10.1137/16M1106158. URL https://doi.org/10.1137/16M1106158.[23] Reinhard Bauer and Dorothea Wagner. Batch dynamic single-source shortest-path algorithms: An experimentalstudy. In Jan Vahrenhold, editor,
Experimental Algorithms, 8th International Symposium, SEA 2009, Dortmund, Ger-many, June 4-6, 2009. Proc. , volume 5526 of
Lecture Notes in Computer Science , pages 51–62. Springer, 2009. ISBN978-3-642-02010-0. doi: 10.1007/978-3-642-02011-7\_7. URL https://doi.org/10.1007/978-3-642-02011-7_7.[24] Reinhard Bauer, Daniel Delling, Peter Sanders, Dennis Schieferdecker, Dominik Schultes, and Dorothea Wagner.Combining hierarchical and goal-directed speed-up techniques for dijkstra’s algorithm.
ACM J. Exp. Algorithmics ,15, 2010. doi: 10.1145/1671970.1671976. URL https://doi.org/10.1145/1671970.1671976.[25] F. Becker. Generative Model for Dynamic Networks with Community Structures. Master’s Thesis, HeidelbergUniversity, 2020. ecent Advances in Fully Dynamic Graph Algorithms 27 [26] Soheil Behnezhad, Mahsa Derakhshan, MohammadTaghi Hajiaghayi, Cliff Stein, and Madhu Sudan. Fully dynamicmaximal independent set with polylogarithmic update time. In Zuckerman [257], pages 382–405. ISBN 978-1-7281-4952-3. doi: 10.1109/FOCS.2019.00032. URL https://doi.org/10.1109/FOCS.2019.00032.[27] Richard Bellman. On a routing problem.
Quarterly of applied mathematics , 16(1):87–90, 1958.[28] Michael A. Bender, Jeremy T. Fineman, Seth Gilbert, and Robert E. Tarjan. A new approach to incremental cy-cle detection and related problems.
ACM Trans. Algorithms , 12(2):14:1–14:22, 2016. doi: 10.1145/2756553. URLhttps://doi.org/10.1145/2756553.[29] Elisabetta Bergamini and Henning Meyerhenke. Fully-dynamic approximation of betweenness centrality. In NikhilBansal and Irene Finocchi, editors,
Algorithms - ESA 2015 - 23rd Annual European Symposium, Patras, Greece, Sep-tember 14-16, 2015, Proc. , volume 9294 of
Lecture Notes in Computer Science , pages 155–166. Springer, 2015. ISBN978-3-662-48349-7. doi: 10.1007/978-3-662-48350-3\_14. URL https://doi.org/10.1007/978-3-662-48350-3_14.[30] Elisabetta Bergamini and Henning Meyerhenke. Approximating betweenness centrality in fully dy-namic networks.
Internet Math. , 12(5):281–314, 2016. doi: 10.1080/15427951.2016.1177802. URLhttps://doi.org/10.1080/15427951.2016.1177802.[31] Elisabetta Bergamini, Henning Meyerhenke, and Christian Staudt. Approximating betweenness centrality in largeevolving networks. In Ulrik Brandes and David Eppstein, editors,
Proc. of the Seventeenth Workshop on AlgorithmEngineering and Experiments, ALENEX 2015, San Diego, CA, USA, January 5, 2015 , pages 133–146. SIAM, 2015. ISBN978-1-61197-375-4. doi: 10.1137/1.9781611973754.12. URL https://doi.org/10.1137/1.9781611973754.12.[32] Elisabetta Bergamini, Henning Meyerhenke, Mark Ortmann, and Arie Slobbe. Faster betweenness centrality updatesin evolving networks. In Costas S. Iliopoulos, Solon P. Pissis, Simon J. Puglisi, and Rajeev Raman, editors, , volume 75 of
LIPIcs ,pages 23:1–23:16. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2017. ISBN 978-3-95977-036-1. doi: 10.4230/LIPIcs.SEA.2017.23. URL https://doi.org/10.4230/LIPIcs.SEA.2017.23.[33] Aaron Bernstein and Shiri Chechik. Incremental topological sort and cycle detection in expected total time.In Artur Czumaj, editor,
Proc. of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA2018, New Orleans, LA, USA, January 7-10, 2018 , pages 21–34. SIAM, 2018. doi: 10.1137/1.9781611975031.2. URLhttps://doi.org/10.1137/1.9781611975031.2.[34] Aaron Bernstein and Cliff Stein. Faster fully dynamic matchings with small approximation ratios. In
Proc. of the27th Symposium on Discrete Algorithms SODA , pages 692–711. SIAM, 2016. doi: 10.1137/1.9781611974331.ch50. URLhttps://doi.org/10.1137/1.9781611974331.ch50.[35] Aaron Bernstein, Sebastian Forster, and Monika Henzinger. A deamortization approach for dynamic spanner anddynamic maximal matching. In Timothy M. Chan, editor,
Proc. of the Thirtieth Annual ACM-SIAM Symposium onDiscrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019 , pages 1899–1918. SIAM, 2019. doi:10.1137/1.9781611975482.115. URL https://doi.org/10.1137/1.9781611975482.115.[36] Emanuele Berrettini, Gianlorenzo D’Angelo, and Daniel Delling. Arc-flags in dynamic graphs. In Jens Clausen andGabriele Di Stefano, editors,
ATMOS 2009 - 9th Workshop on Algorithmic Approaches for Transportation Modeling,Optimization, and Systems, IT University of Copenhagen, Denmark, September 10, 2009 , volume 12 of
OASICS . SchlossDagstuhl - Leibniz-Zentrum fuer Informatik, Germany, 2009. URL http://drops.dagstuhl.de/opus/volltexte/2009/2149.[37] Sayan Bhattacharya and Janardhan Kulkarni. Deterministically maintaining a ( + 𝜀 )-approximate minimum vertexcover in 𝑜 ( / 𝜀 ) amortized update time. In Timothy M. Chan, editor, Proc. of the Thirtieth Annual ACM-SIAMSymposium on Discrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019 , pages 1872–1885. SIAM,2019. doi: 10.1137/1.9781611975482.113. URL https://doi.org/10.1137/1.9781611975482.113.[38] Sayan Bhattacharya, Monika Henzinger, Danupon Nanongkai, and Charalampos E. Tsourakakis. Space- andtime-efficient algorithm for maintaining dense subgraphs on one-pass dynamic streams. In Rocco A. Servedioand Ronitt Rubinfeld, editors,
Proc. of the Forty-Seventh Annual ACM on Symposium on Theory of Computing,STOC 2015, Portland, OR, USA, June 14-17, 2015 , pages 173–182. ACM, 2015. doi: 10.1145/2746539.2746592. URLhttps://doi.org/10.1145/2746539.2746592.[39] Sayan Bhattacharya, Monika Henzinger, and Danupon Nanongkai. New deterministic approximation algorithms forfully dynamic matching. In
Proc. of the 48th Annual Symposium on Theory of Computing , pages 398–411. ACM, 2016.doi: 10.1145/2897518.2897568. URL https://doi.org/10.1145/2897518.2897568.[40] Sayan Bhattacharya, Monika Henzinger, and Danupon Nanongkai. Fully dynamic approximate maximum matchingand minimum vertex cover in O (log3 n ) worst case update time. In Philip N. Klein, editor, Proc. of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms SODA , pages 470–489. SIAM, 2017. doi: 10.1137/1.9781611973730.54. URL https://doi.org/10.1137/1.9781611973730.54.[41] Sayan Bhattacharya, Monika Henzinger, and Giuseppe F. Italiano. Deterministic fully dynamic data struc-tures for vertex cover and matching.
SIAM J. Comput. , 47(3):859–887, 2018. doi: 10.1137/140998925. URLhttps://doi.org/10.1137/140998925. [42] Sayan Bhattacharya, Monika Henzinger, and Giuseppe F. Italiano. Dynamic algorithms via the primal-dual method.
Inf. Comput. , 261:219–239, 2018. doi: 10.1016/j.ic.2018.02.005. URL https://doi.org/10.1016/j.ic.2018.02.005.[43] Sayan Bhattacharya, Monika Henzinger, and Danupon Nanongkai. A new deterministic algorithm for dynamic setcover. In David Zuckerman, editor, , pages 406–423. IEEE Computer Society, 2019. doi: 10.1109/FOCS.2019.00033. URL https://doi.org/10.1109/FOCS.2019.00033.[44] Sayan Bhattacharya, Deeparnab Chakrabarty, and Monika Henzinger. Deterministic dynamic matchingin O(1) update time.
Algorithmica , 82(4):1057–1080, 2020. doi: 10.1007/s00453-019-00630-4. URLhttps://doi.org/10.1007/s00453-019-00630-4.[45] Sayan Bhattacharya, Monika Henzinger, Danupon Nanongkai, and Xiaowei Wu. An improved algorithm for dynamicset cover.
CoRR , abs/2002.11171, 2020. URL https://arxiv.org/abs/2002.11171.[46] Sujoy Bhore, Guangping Li, and Martin Nöllenburg. An algorithmic study of fully dynamic independent sets formap labeling. In Grandoni et al. [101], pages 19:1–19:24. ISBN 978-3-95977-162-7. doi: 10.4230/LIPIcs.ESA.2020.19.URL https://doi.org/10.4230/LIPIcs.ESA.2020.19.[47] Patrick Bisenius, Elisabetta Bergamini, Eugenio Angriman, and Henning Meyerhenke. Computing top- k close-ness centrality in fully-dynamic graphs. In Rasmus Pagh and Suresh Venkatasubramanian, editors, Proc. ofthe Twentieth Workshop on Algorithm Engineering and Experiments, ALENEX 2018, New Orleans, LA, USA, Jan-uary 7-8, 2018 , pages 21–35. SIAM, 2018. ISBN 978-1-61197-505-5. doi: 10.1137/1.9781611975055.3. URLhttps://doi.org/10.1137/1.9781611975055.3.[48] Yuri Boykov and Vladimir Kolmogorov. An experimental comparison of min-cut/max-flow algorithms for energyminimization in vision.
IEEE Trans. Pattern Anal. Mach. Intell. , 26(9):1124–1137, 2004. doi: 10.1109/TPAMI.2004.60.URL https://doi.org/10.1109/TPAMI.2004.60.[49] U. Brandes, D. Delling, M. Gaertler, R. Gorke, M. Hoefer, Z. Nikoloski, and D. Wagner. On Modularity Clustering.
IEEE Transactions on Knowledge and Data Engineering , 20(2):172–188, 2008. doi: 10.1109/TKDE.2007.190689. URLhttps://doi.org/10.1109/TKDE.2007.190689.[50] Valentin Buchhold, Daniel Delling, Dennis Schieferdecker, and Michael Wegner. Fast and stable repartitioningof road networks. In , volume 160 of
LIPIcs ,pages 26:1–26:15. Schloss Dagstuhl-Leibniz-Zentrum für Informatik, 2020. doi: 10.4230/LIPIcs.SEA.2020.26. URLhttps://doi.org/10.4230/LIPIcs.SEA.2020.26.[51] Laurent Bulteau, Vincent Froese, Konstantin Kutzkov, and Rasmus Pagh. Triangle counting in dy-namic graph streams.
Algorithmica , 76(1):259–278, 2016. doi: 10.1007/s00453-015-0036-4. URLhttps://doi.org/10.1007/s00453-015-0036-4.[52] Luciana S. Buriol, Gereon Frahling, Stefano Leonardi, Alberto Marchetti-Spaccamela, and Christian Sohler. Countingtriangles in data streams. In Stijn Vansummeren, editor,
Proc. of the Twenty-Fifth ACM SIGACT-SIGMOD-SIGARTSymposium on Principles of Database Systems, June 26-28, 2006, Chicago, Illinois, USA , pages 253–262. ACM, 2006.ISBN 1-59593-318-2. doi: 10.1145/1142351.1142388. URL https://doi.org/10.1145/1142351.1142388.[53] Luciana S. Buriol, Mauricio G. C. Resende, and Mikkel Thorup. Speeding up dynamic shortest-path algorithms.
INFORMS J. Comput. , 20(2):191–204, 2008. doi: 10.1287/ijoc.1070.0231. URL https://doi.org/10.1287/ijoc.1070.0231.[54] Giuseppe Cattaneo, Pompeo Faruolo, Umberto Ferraro Petrillo, and Giuseppe F. Italiano. Maintaining dynamic min-imum spanning trees: An experimental study. In David M. Mount and Clifford Stein, editors,
Algorithm Engineeringand Experiments, 4th International Workshop, ALENEX 2002, San Francisco, CA, USA, January 4-5, 2002, Revised Pa-pers , volume 2409 of
Lecture Notes in Computer Science , pages 111–125. Springer, 2002. ISBN 3-540-43977-3. doi:10.1007/3-540-45643-0\_9. URL https://doi.org/10.1007/3-540-45643-0_9.[55] Giuseppe Cattaneo, Pompeo Faruolo, Umberto Ferraro Petrillo, and Giuseppe F. Italiano. Maintaining dynamicminimum spanning trees: An experimental study.
Discret. Appl. Math. , 158(5):404–425, 2010. doi: 10.1016/j.dam.2009.10.005. URL https://doi.org/10.1016/j.dam.2009.10.005.[56] Edward P. F. Chan and Yaya Yang. Shortest path tree computation in dynamic graphs.
IEEE Trans. Computers , 58(4):541–557, 2009. doi: 10.1109/TC.2008.198. URL https://doi.org/10.1109/TC.2008.198.[57] Moses Charikar and Shay Solomon. Fully dynamic almost-maximal matching: Breaking the polynomial worst-case time barrier. In Ioannis Chatzigiannakis, Christos Kaklamanis, Dániel Marx, and Donald Sannella, editors, , volume 107 of
LIPIcs , pages33:1–33:14. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018. doi: 10.4230/LIPIcs.ICALP.2018.33. URLhttps://doi.org/10.4230/LIPIcs.ICALP.2018.33.[58] Shiri Chechik and Tianyi Zhang. Fully dynamic maximal independent set in expected poly-log updatetime. In Zuckerman [257], pages 370–381. ISBN 978-1-7281-4952-3. doi: 10.1109/FOCS.2019.00031. URLhttps://doi.org/10.1109/FOCS.2019.00031. ecent Advances in Fully Dynamic Graph Algorithms 29 [59] Mostafa Haghir Chehreghani, Albert Bifet, and Talel Abdessalem. Dybed: An efficient algorithm for updating be-tweenness centrality in directed dynamic graphs. In Naoki Abe, Huan Liu, Calton Pu, Xiaohua Hu, Nesreen K. Ahmed,Mu Qiao, Yang Song, Donald Kossmann, Bing Liu, Kisung Lee, Jiliang Tang, Jingrui He, and Jeffrey S. Saltz, editors,
IEEE International Conference on Big Data, Big Data 2018, Seattle, WA, USA, December 10-13, 2018 , pages 2114–2123.IEEE, 2018. doi: 10.1109/BigData.2018.8622452. URL https://doi.org/10.1109/BigData.2018.8622452.[60] Li Chen, Gramoz Goranci, Monika Henzinger, Richard Peng, and Thatchaphol Saranurak. Fast dynamic cuts, dis-tances and effective resistances via vertex sparsifiers. pages 1135–1146, 2020. doi: 10.1109/FOCS46700.2020.00109.URL https://doi.org/10.1109/FOCS46700.2020.00109.[61] Edith Cohen, Amos Fiat, Haim Kaplan, and Liam Roditty. A labeling approach to incremental cycle detection.
CoRR ,abs/1310.8381, 2013. URL http://arxiv.org/abs/1310.8381.[62] Pierluigi Crescenzi, Clémence Magnien, and Andrea Marino. Finding top-k nodes for temporal closeness in largetemporal graphs.
Algorithms , 13(9):211, 2020. doi: 10.3390/a13090211. URL https://doi.org/10.3390/a13090211.[63] Michael Crouch and Daniel S. Stubbs. Improved streaming algorithms for weighted matching, via un-weighted matching. In Klaus Jansen, José D. P. Rolim, Nikhil R. Devanur, and Cristopher Moore, editors,
Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM2014, September 4-6, 2014, Barcelona, Spain , volume 28 of
LIPIcs , pages 96–104. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2014. ISBN 978-3-939897-74-3. doi: 10.4230/LIPIcs.APPROX-RANDOM.2014.96. URLhttps://doi.org/10.4230/LIPIcs.APPROX-RANDOM.2014.96.[64] Michael S Crouch, Andrew McGregor, and Daniel Stubbs. Dynamic graphs in the sliding-window model. In
EuropeanSymposium on Algorithms , pages 337–348. Springer, 2013.[65] Annalisa D’Andrea, Mattia D’Emidio, Daniele Frigioni, Stefano Leucci, and Guido Proietti. Dynamic maintenance ofa shortest-path tree on homogeneous batches of updates: New algorithms and experiments.
ACM J. Exp. Algorithmics ,20:1.5:1.1–1.5:1.33, 2015. doi: 10.1145/2786022. URL https://doi.org/10.1145/2786022.[66] Gianlorenzo D’Angelo, Mattia D’Emidio, and Daniele Frigioni. Fully dynamic update of arc-flags.
Networks , 63(3):243–259, 2014. doi: 10.1002/net.21542. URL https://doi.org/10.1002/net.21542.[67] Daniel Delling and Dorothea Wagner. Landmark-based routing in dynamic graphs. In Demetrescu [70], pages 52–65.ISBN 978-3-540-72844-3. doi: 10.1007/978-3-540-72845-0\_5. URL https://doi.org/10.1007/978-3-540-72845-0_5.[68] Daniel Delling, Andrew V. Goldberg, Thomas Pajor, and Renato Fonseca F. Werneck. Customizable route plan-ning. In Panos M. Pardalos and Steffen Rebennack, editors,
Experimental Algorithms - 10th International Sym-posium, SEA 2011, Kolimpari, Chania, Crete, Greece, May 5-7, 2011. Proc. , volume 6630 of
Lecture Notes in Com-puter Science , pages 376–387. Springer, 2011. ISBN 978-3-642-20661-0. doi: 10.1007/978-3-642-20662-7\_32. URLhttps://doi.org/10.1007/978-3-642-20662-7_32.[69] Camil Demetrescu.
Fully Dynamic Algorithms for Path Problems on Directed Graphs . PhD thesis, 2001. URLhttp://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.21.8921.[70] Camil Demetrescu, editor.
Experimental Algorithms, 6th International Workshop, WEA 2007, Rome, Italy, June 6-8, 2007,Proc. , volume 4525 of
Lecture Notes in Computer Science , 2007. Springer. ISBN 978-3-540-72844-3. doi: 10.1007/978-3-540-72845-0. URL https://doi.org/10.1007/978-3-540-72845-0.[71] Camil Demetrescu and Giuseppe F. Italiano. A new approach to dynamic all pairs shortest paths.
J. ACM , 51(6):968–992, 2004. doi: 10.1145/1039488.1039492. URL https://doi.org/10.1145/1039488.1039492.[72] Camil Demetrescu and Giuseppe F. Italiano. Trade-offs for fully dynamic transitive closure on dags: break-ing through the o(n2 barrier.
Journal of the ACM , 52(2):147–156, 2005. doi: 10.1145/1059513.1059514. URLhttps://doi.org/10.1145/1059513.1059514.[73] Camil Demetrescu and Giuseppe F. Italiano. Experimental analysis of dynamic all pairs shortestpath algorithms.
ACM Trans. Algorithms , 2(4):578–601, 2006. doi: 10.1145/1198513.1198519. URLhttps://doi.org/10.1145/1198513.1198519.[74] Camil Demetrescu and Giuseppe F. Italiano. Mantaining dynamic matrices for fully dynamic transitive closure.
Algorithmica , 51(4):387–427, 2008. doi: 10.1007/s00453-007-9051-4. URL https://doi.org/10.1007/s00453-007-9051-4.[75] Camil Demetrescu, Daniele Frigioni, Alberto Marchetti-Spaccamela, and Umberto Nanni. Maintaining shortestpaths in digraphs with arbitrary arc weights: An experimental study. In Stefan Näher and Dorothea Wagner,editors,
Algorithm Engineering, 4th International Workshop, WAE 2000, Saarbrücken, Germany, September 5-8, 2000,Proc. , volume 1982 of
Lecture Notes in Computer Science , pages 218–229. Springer, 2000. ISBN 3-540-42512-8. doi:10.1007/3-540-44691-5\_19. URL https://doi.org/10.1007/3-540-44691-5_19.[76] Laxman Dhulipala, Quanquan C. Liu, and Julian Shun. Parallel batch-dynamic k-clique counting.
CoRR ,abs/2003.13585, 2020. URL https://arxiv.org/abs/2003.13585.[77] Jana Diesner, Elena Ferrari, and Guandong Xu, editors.
Proc. of the 2017 IEEE/ACM International Conference onAdvances in Social Networks Analysis and Mining 2017, Sydney, Australia, July 31 - August 03, 2017 , 2017. ACM. ISBN978-1-4503-4993-2. doi: 10.1145/3110025. URL https://doi.org/10.1145/3110025. [78] Edsger W. Dijkstra. A note on two problems in connexion with graphs.
Numerische Mathematik , 1:269–271, 1959.doi: 10.1007/BF01386390. URL https://doi.org/10.1007/BF01386390.[79] Christof Doll, Tanja Hartmann, and Dorothea Wagner. Fully-dynamic hierarchical graph clustering using cut trees.In , volume 6844 of
LNCS , pages 338–349, 2011. doi:10.1007/978-3-642-22300-6\_29. URL https://doi.org/10.1007/978-3-642-22300-6_29.[80] David Ediger, Robert McColl, E. Jason Riedy, and David A. Bader. STINGER: high performance data structure forstreaming graphs. In
IEEE Conference on High Performance Extreme Computing, HPEC 2012, Waltham, MA, USA,September 10-12, 2012 , pages 1–5. IEEE, 2012. ISBN 978-1-4673-1577-7. doi: 10.1109/HPEC.2012.6408680. URLhttps://doi.org/10.1109/HPEC.2012.6408680.[81] Jack R. Edmonds and Richard M. Karp. Theoretical improvements in algorithmic efficiency for network flow prob-lems.
J. ACM , 19(2):248–264, 1972. doi: 10.1145/321694.321699. URL https://doi.org/10.1145/321694.321699.[82] David Eppstein. Offline algorithms for dynamic minimum spanning tree problems.
Journal of Algorithms , 17(2):237–250, 1994.[83] David Eppstein, Zvi Galil, Giuseppe F. Italiano, and Thomas H. Spencer. Separator based sparsification. i. planarytesting and minimum spanning trees.
J. Comput. Syst. Sci. , 52(1):3–27, 1996. doi: 10.1006/jcss.1996.0002. URLhttps://doi.org/10.1006/jcss.1996.0002.[84] David Eppstein, Zvi Galil, Giuseppe F. Italiano, and Thomas H. Spencer. Separator-based sparsification II:edge and vertex connectivity.
SIAM J. Comput. , 28(1):341–381, 1998. doi: 10.1137/S0097539794269072. URLhttps://doi.org/10.1137/S0097539794269072.[85] Wenfei Fan, Muyang Liu, Chao Tian, Ruiqi Xu, and Jingren Zhou. Incrementalization of graph parti-tioning algorithms.
Proc. VLDB Endow. , 13(8):1261–1274, 2020. doi: 10.14778/3389133.3389142. URLhttps://doi.org/10.14778/3389133.3389142.[86] Guoyao Feng, Xiao Meng, and Khaled Ammar. Distinger: A distributed graph data structure for massive dynamicgraph processing. In , pages 1814–1822. IEEE, 2015. doi:10.1109/BigData.2015.7363954. URL https://doi.org/10.1109/BigData.2015.7363954.[87] Greg N. Frederickson. Data structures for on-line updating of minimum spanning trees, with applications.
SIAM J.Comput. , 14(4):781–798, 1985. doi: 10.1137/0214055. URL https://doi.org/10.1137/0214055.[88] Greg N. Frederickson. Ambivalent data structures for dynamic 2-edge-connectivity and k small-est spanning trees.
SIAM J. Comput. , 26(2):484–538, 1997. doi: 10.1137/S0097539792226825. URLhttps://doi.org/10.1137/S0097539792226825.[89] Daniele Frigioni, Alberto Marchetti-Spaccamela, and Umberto Nanni. Fully dynamic output bounded single sourceshortest path problem (extended abstract). In Éva Tardos, editor,
Proc. of the Seventh Annual ACM-SIAM Symposiumon Discrete Algorithms, 28-30 January 1996, Atlanta, Georgia, USA , pages 212–221. ACM/SIAM, 1996. ISBN 0-89871-366-8. URL http://dl.acm.org/citation.cfm?id=313852.313926.[90] Daniele Frigioni, Mario Ioffreda, Umberto Nanni, and Giulio Pasqualone. Experimental analysis of dynamic algo-rithms for the single-source shortest-path problem.
ACM J. Exp. Algorithmics , 3:5, 1998. doi: 10.1145/297096.297147.URL https://doi.org/10.1145/297096.297147.[91] Daniele Frigioni, Tobias Miller, Umberto Nanni, and Christos D. Zaroliagis. An experimental study of dy-namic algorithms for transitive closure.
ACM J. Exp. Algorithmics , 6:9, 2001. doi: 10.1145/945394.945403. URLhttps://doi.org/10.1145/945394.945403.[92] Andrew V. Goldberg and Chris Harrelson. Computing the shortest path: A search meets graph theory. In Proc. of theSixteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2005, Vancouver, British Columbia, Canada,January 23-25, 2005 , pages 156–165. SIAM, 2005. URL http://dl.acm.org/citation.cfm?id=1070432.1070455.[93] Andrew V. Goldberg and Robert Endre Tarjan. A new approach to the maximum-flow problem.
J. ACM , 35(4):921–940, 1988. doi: 10.1145/48014.61051. URL https://doi.org/10.1145/48014.61051.[94] Andrew V. Goldberg, Sagi Hed, Haim Kaplan, Pushmeet Kohli, Robert Endre Tarjan, and Renato F. Werneck. Fasterand more dynamic maximum flow by incremental breadth-first search. In Nikhil Bansal and Irene Finocchi, edi-tors,
Algorithms - ESA 2015 - 23rd Annual European Symposium, Patras, Greece, September 14-16, 2015, Proc. , volume9294 of
Lecture Notes in Computer Science , pages 619–630. Springer, 2015. doi: 10.1007/978-3-662-48350-3\_52. URLhttps://doi.org/10.1007/978-3-662-48350-3_52.[95] Gramoz Goranci, Harald Räcke, Thatchaphol Saranurak, and Zihan Tan. The expander hierarchy and its applicationsto dynamic graph algorithms.
CoRR , abs/2005.02369, 2020. URL https://arxiv.org/abs/2005.02369.[96] Robert Görke, Pascal Maillard, Christian Staudt, and Dorothea Wagner. Modularity-driven clustering of dynamicgraphs. In Paola Festa, editor,
Experimental Algorithms, 9th International Symposium, SEA 2010, Ischia Island, Naples,Italy, May 20-22, 2010. Proc. , volume 6049 of
Lecture Notes in Computer Science , pages 436–448. Springer, 2010. ISBN978-3-642-13192-9. doi: 10.1007/978-3-642-13193-6\_37. URL https://doi.org/10.1007/978-3-642-13193-6_37. ecent Advances in Fully Dynamic Graph Algorithms 31 [97] Robert Görke, Tanja Hartmann, and Dorothea Wagner. Dynamic graph clustering using minimum-cut trees.
J. GraphAlgorithms Appl. , 16(2):411–446, 2012. doi: 10.7155/jgaa.00269. URL https://doi.org/10.7155/jgaa.00269.[98] Robert Görke, Roland Kluge, Andrea Schumm, Christian Staudt, and Dorothea Wagner. An efficient generator forclustered dynamic random networks. In Guy Even and Dror Rawitz, editors,
Design and Analysis of Algorithms - FirstMediterranean Conference on Algorithms, MedAlg 2012, Kibbutz Ein Gedi, Israel, December 3-5, 2012. Proc. , volume7659 of
Lecture Notes in Computer Science , pages 219–233. Springer, 2012. doi: 10.1007/978-3-642-34862-4\_16. URLhttps://doi.org/10.1007/978-3-642-34862-4_16.[99] Robert Görke, Pascal Maillard, Andrea Schumm, Christian Staudt, and Dorothea Wagner. Dynamic graph clusteringcombining modularity and smoothness.
ACM J. Exp. Algorithmics , 18, 2013. doi: 10.1145/2444016.2444021. URLhttps://doi.org/10.1145/2444016.2444021.[100] Fabrizio Grandoni, Stefano Leonardi, Piotr Sankowski, Chris Schwiegelshohn, and Shay Solomon. (1 + 𝜖 )-approximate incremental matching in constant deterministic amortized time. In Proc. of the 20th Symposium onDiscrete Algorithms
DBL [2], pages 1886–1898. ISBN 978-1-61197-548-2. doi: 10.1137/1.9781611975482.114. URLhttps://doi.org/10.1137/1.9781611975482.114.[101] Fabrizio Grandoni, Grzegorz Herman, and Peter Sanders, editors. , volume 173 of
LIPIcs , 2020. Schloss Dagstuhl - Leibniz-Zentrum für Informatik. ISBN 978-3-95977-162-7.[102] Sergio Greco, Cristian Molinaro, Chiara Pulice, and Ximena Quintana. Incremental maximum flow computationon evolving networks. In Ahmed Seffah, Birgit Penzenstadler, Carina Alves, and Xin Peng, editors,
Proc. of theSymposium on Applied Computing, SAC 2017, Marrakech, Morocco, April 3-7, 2017 , pages 1061–1067. ACM, 2017. doi:10.1145/3019612.3019816. URL https://doi.org/10.1145/3019612.3019816.[103] Oded Green, Robert McColl, and David A. Bader. A fast algorithm for streaming betweenness central-ity. In , pages 11–20. IEEE Computer Society, 2012. ISBN 978-1-4673-5638-1. doi: 10.1109/SocialCom-PASSAT.2012.37. URLhttps://doi.org/10.1109/SocialCom-PASSAT.2012.37.[104] Leonidas J. Guibas. Kinetic data structures. In Dinesh P. Mehta and Sartaj Sahni, editors,
Handbook ofData Structures and Applications . Chapman and Hall/CRC, 2004. doi: 10.1201/9781420035179.ch23. URLhttps://doi.org/10.1201/9781420035179.ch23.[105] Manoj Gupta and Shahbaz Khan. Simple dynamic algorithms for maximal independent set and other problems. In , to appear, 2021. URL http://arxiv.org/abs/1804.01823.[106] Manoj Gupta and Richard Peng. Fully dynamic (1+ e)-approximate matchings. In , pages 548–557. IEEE ComputerSociety, 2013. doi: 10.1109/FOCS.2013.65. URL https://doi.org/10.1109/FOCS.2013.65.[107] Manoj Gupta and Richard Peng. Fully dynamic (1+ e)-approximate matchings. In , pages 548–557. IEEE Computer Society, 2013. ISBN 978-0-7695-5135-7. doi: 10.1109/FOCS.2013.65. URL https://doi.org/10.1109/FOCS.2013.65.[108] Bernhard Haeupler, Telikepalli Kavitha, Rogers Mathew, Siddhartha Sen, and Robert Endre Tarjan. Incremental cycledetection, topological ordering, and strong component maintenance.
ACM Trans. Algorithms , 8(1):3:1–3:33, 2012. doi:10.1145/2071379.2071382. URL https://doi.org/10.1145/2071379.2071382.[109] Guyue Han and Harish Sethu. Edge sample and discard: A new algorithm for counting triangles in large dy-namic graphs. In Diesner et al. [77], pages 44–49. ISBN 978-1-4503-4993-2. doi: 10.1145/3110025.3110061. URLhttps://doi.org/10.1145/3110025.3110061.[110] Kathrin Hanauer, Monika Henzinger, and Christian Schulz. Fully dynamic single-source reachability in practice: Anexperimental study. In Guy E. Blelloch and Irene Finocchi, editors,
Proc. of the Symposium on Algorithm Engineeringand Experiments, ALENEX 2020, Salt Lake City, UT, USA, January 5-6, 2020 , pages 106–119. SIAM, 2020. doi: 10.1137/1.9781611976007.9. URL https://doi.org/10.1137/1.9781611976007.9.[111] Kathrin Hanauer, Monika Henzinger, and Christian Schulz. Faster fully dynamic transitive closure in practice. InSimone Faro and Domenico Cantone, editors, , volume 160 of
LIPIcs , pages 14:1–14:14. Schloss Dagstuhl - Leibniz-Zentrum fürInformatik, 2020. doi: 10.4230/LIPIcs.SEA.2020.14. URL https://doi.org/10.4230/LIPIcs.SEA.2020.14.[112] Takanori Hayashi, Takuya Akiba, and Yuichi Yoshida. Fully dynamic betweenness centrality mainte-nance on massive networks.
Proc. VLDB Endow.
Proc. of the 2009 ACM Symposium on Applied Computing (SAC), Honolulu,Hawaii, USA, March 9-12, 2009 , pages 1456–1461. ACM, 2009. ISBN 978-1-60558-166-8. doi: 10.1145/1529282.1529607.
URL https://doi.org/10.1145/1529282.1529607.[114] Bruce Hendrickson, Robert W. Leland, and Rafael Van Driessche. Enhancing data locality by using terminal prop-agation. In , pages 565–574. IEEE Computer Society, 1996. ISBN 0-8186-7324-9. doi: 10.1109/HICSS.1996.495507.URL https://doi.org/10.1109/HICSS.1996.495507.[115] Monika Henzinger. The state of the art in dynamic graph algorithms. In , volume 10706 of
LNCS , pages 40–44. Springer, 2018. doi: 10.1007/978-3-319-73117-9\_3. URL https://doi.org/10.1007/978-3-319-73117-9_3.[116] Monika Henzinger, Sebastian Krinninger, Danupon Nanongkai, and Thatchaphol Saranurak. Unifying and strength-ening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In
Proc. of the forty-seventh annual ACM symposium on Theory of computing , pages 21–30, 2015. doi: 10.1145/2746539.2746609. URLhttps://doi.org/10.1145/2746539.2746609.[117] Monika Henzinger, Andrea Lincoln, Stefan Neumann, and Virginia Vassilevska Williams. Conditional hardness forsensitivity problems. In Christos H. Papadimitriou, editor, , volume 67 of
LIPIcs , pages 26:1–26:31. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2017. doi: 10.4230/LIPIcs.ITCS.2017.26. URL https://doi.org/10.4230/LIPIcs.ITCS.2017.26.[118] Monika Henzinger, Shahbaz Khan, Richard Paul, and Christian Schulz. Dynamic matching algorithms in prac-tice. In Grandoni et al. [101], pages 58:1–58:20. ISBN 978-3-95977-162-7. doi: 10.4230/LIPIcs.ESA.2020.58. URLhttps://doi.org/10.4230/LIPIcs.ESA.2020.58.[119] Monika R Henzinger and Valerie King. Maintaining minimum spanning trees in dynamic graphs. In
InternationalColloquium on Automata, Languages, and Programming , pages 594–604. Springer, 1997.[120] Monika Rauch Henzinger. Fully dynamic biconnectivity in graphs.
Algorithmica , 13(6):503–538, 1995. doi: 10.1007/BF01189067. URL https://doi.org/10.1007/BF01189067.[121] Monika Rauch Henzinger. Improved data structures for fully dynamic biconnectivity.
SIAM J. Comput. , 29(6):1761–1815, 2000. doi: 10.1137/S0097539794263907. URL https://doi.org/10.1137/S0097539794263907.[122] Monika Rauch Henzinger and Michael L. Fredman. Lower bounds for fully dynamic connectivity problems in graphs.
Algorithmica , 22(3):351–362, 1998. doi: 10.1007/PL00009228. URL https://doi.org/10.1007/PL00009228.[123] Monika Rauch Henzinger and Valerie King. Fully dynamic biconnectivity and transitive closure. In , pages 664–672. IEEEComputer Society, 1995. doi: 10.1109/SFCS.1995.492668. URL https://doi.org/10.1109/SFCS.1995.492668.[124] Monika Rauch Henzinger and Valerie King. Randomized dynamic graph algorithms with polylogarithmic timeper operation. In Frank Thomson Leighton and Allan Borodin, editors,
Proc. of the Twenty-Seventh Annual ACMSymposium on Theory of Computing, 29 May-1 June 1995, Las Vegas, Nevada, USA , pages 519–527. ACM, 1995. doi:10.1145/225058.225269. URL https://doi.org/10.1145/225058.225269.[125] Monika Rauch Henzinger and Valerie King. Randomized fully dynamic graph algorithms with polylogarithmic timeper operation.
J. ACM , 46(4):502–516, 1999. doi: 10.1145/320211.320215. URL https://doi.org/10.1145/320211.320215.[126] Jacob Holm, Kristian de Lichtenberg, and Mikkel Thorup. Poly-logarithmic deterministic fully-dynamic algorithmsfor connectivity, minimum spanning tree, 2-edge, and biconnectivity. In Jeffrey Scott Vitter, editor,
Proc. of theThirtieth Annual ACM Symposium on the Theory of Computing, Dallas, Texas, USA, May 23-26, 1998 , pages 79–89.ACM, 1998. doi: 10.1145/276698.276715. URL https://doi.org/10.1145/276698.276715.[127] Jacob Holm, Kristian de Lichtenberg, and Mikkel Thorup. Poly-logarithmic deterministic fully-dynamic algorithmsfor connectivity, minimum spanning tree, 2-edge, and biconnectivity.
J. ACM , 48(4):723–760, 2001. doi: 10.1145/502090.502095. URL https://doi.org/10.1145/502090.502095.[128] Jacob Holm, Eva Rotenberg, and Christian Wulff-Nilsen. Faster fully-dynamic minimum spanning forest. In NikhilBansal and Irene Finocchi, editors,
Algorithms - ESA 2015 - 23rd Annual European Symposium, Patras, Greece, Sep-tember 14-16, 2015, Proc. , volume 9294 of
Lecture Notes in Computer Science , pages 742–753. Springer, 2015. doi:10.1007/978-3-662-48350-3\_62. URL https://doi.org/10.1007/978-3-662-48350-3_62.[129] Y.F. Hu and R.J. Blake. An improved diffusion algorithm for dynamic load balancing.
Parallel Com-puting
IEEE Trans. Parallel Distributed Syst. , 31(6):1287–1300, 2020. doi: 10.1109/TPDS.2019.2960226. URL https://doi.org/10.1109/TPDS.2019.2960226.[131] Jiewen Huang and Daniel Abadi. LEOPARD: lightweight edge-oriented partitioning and replicationfor dynamic graphs.
Proc. VLDB Endow. ecent Advances in Fully Dynamic Graph Algorithms 33 [132] Shang-En Huang, Dawei Huang, Tsvi Kopelowitz, and Seth Pettie. Fully dynamic connectivity in O (log n (log log n )2) amortized expected time. In Philip N. Klein, editor, Proc. of the Twenty-Eighth Annual ACM-SIAM Symposiumon Discrete Algorithms, SODA 2017, Barcelona, Spain, Hotel Porta Fira, January 16-19 , pages 510–520. SIAM, 2017. doi:10.1137/1.9781611974782.32. URL https://doi.org/10.1137/1.9781611974782.32.[133] Wenyu Huo.
Query Processing on Temporally Evolving Social Data
Conference on Scientific andStatistical Database Management, SSDBM ’14, Aalborg, Denmark, June 30 - July 02, 2014 , pages 38:1–38:4. ACM, 2014.ISBN 978-1-4503-2722-0. doi: 10.1145/2618243.2618282. URL https://doi.org/10.1145/2618243.2618282.[135] T. Ibaraki and N. Katoh. On-line computation of transitive closures of graphs.
Information Process-ing Letters
Proc. of the Eighth Annual ACM-SIAM Symposiumon Discrete Algorithms, 5-7 January 1997, New Orleans, Louisiana, USA , pages 314–323. ACM/SIAM, 1997. ISBN 0-89871-390-0. URL http://dl.acm.org/citation.cfm?id=314161.314314.[137] Giuseppe F. Italiano. Amortized efficiency of a path retrieval data structure.
Theor. Comput. Sci. , 48(3):273–281, 1986.doi: 10.1016/0304-3975(86)90098-8. URL https://doi.org/10.1016/0304-3975(86)90098-8.[138] Giuseppe F. Italiano. Finding paths and deleting edges in directed acyclic graphs.
Information Processing Letters , 28(1):5–11, 1988. doi: 10.1016/0020-0190(88)90136-6. URL https://doi.org/10.1016/0020-0190(88)90136-6.[139] Giuseppe F. Italiano. Fully dynamic higher connectivity. In
Encyclopedia of Algorithms , pages 797–800. 2016. doi:10.1007/978-1-4939-2864-4\_154. URL https://doi.org/10.1007/978-1-4939-2864-4_154.[140] Zoran Ivkovic and Errol L. Lloyd. Fully dynamic maintenance of vertex cover. In , volume 790 of
LNCS , pages 99–111, 1993.[141] Keita Iwabuchi, Scott Sallinen, Roger Pearce, Brian Van Essen, Maya Gokhale, and Satoshi Matsuoka. To-wards a distributed large-scale dynamic graph data store. In , pages 892–901. IEEE, 2016. doi: 10.1109/IPDPSW.2016.189. URLhttps://doi.org/10.1109/IPDPSW.2016.189.[142] Raj Iyer, David R. Karger, Hariharan Rahul, and Mikkel Thorup. An experimental study of polylogarithmic,fully dynamic, connectivity algorithms.
ACM J. Exp. Algorithmics , 6:4, 2001. doi: 10.1145/945394.945398. URLhttps://doi.org/10.1145/945394.945398.[143] Hai Jin, Na Wang, Dongxiao Yu, Qiang-Sheng Hua, Xuanhua Shi, and Xia Xie. Core maintenance in dynamic graphs:A parallel approach based on matching.
IEEE Trans. Parallel Distributed Syst. , 29(11):2416–2428, 2018. doi: 10.1109/TPDS.2018.2835441. URL https://doi.org/10.1109/TPDS.2018.2835441.[144] Wenyu Jin and Xiaorui Sun. Fully dynamic c-edge connectivity in subpolynomial time.
CoRR , abs/2004.07650, 2020.URL https://arxiv.org/abs/2004.07650.[145] Hossein Jowhari and Mohammad Ghodsi. New streaming algorithms for counting triangles in graphs. In LushengWang, editor,
Computing and Combinatorics, 11th Annual International Conference, COCOON 2005, Kunming, China,August 16-29, 2005, Proc. , volume 3595 of
Lecture Notes in Computer Science , pages 710–716. Springer, 2005. ISBN3-540-28061-8. doi: 10.1007/11533719\_72. URL https://doi.org/10.1007/11533719_72.[146] Bruce M. Kapron, Valerie King, and Ben Mountjoy. Dynamic graph connectivity in polylogarithmic worst case time.In Sanjeev Khanna, editor,
Proc. of the Twenty-Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA2013, New Orleans, Louisiana, USA, January 6-8, 2013 , pages 1131–1142. SIAM, 2013. doi: 10.1137/1.9781611973105.81.URL https://doi.org/10.1137/1.9781611973105.81.[147] Ahmet Kara, Hung Q. Ngo, Milos Nikolic, Dan Olteanu, and Haozhe Zhang. Counting triangles under updates inworst-case optimal time. In Pablo Barceló and Marco Calautti, editors, , volume 127 of
LIPIcs , pages 4:1–4:18. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019. doi: 10.4230/LIPIcs.ICDT.2019.4. URL https://doi.org/10.4230/LIPIcs.ICDT.2019.4.[148] Ahmet Kara, Hung Q. Ngo, Milos Nikolic, Dan Olteanu, and Haozhe Zhang. Maintaining triangle queries under up-dates.
ACM Trans. Database Syst. , 45(3):11:1–11:46, 2020. doi: 10.1145/3396375. URL https://doi.org/10.1145/3396375.[149] Miray Kas, Kathleen M. Carley, and L. Richard Carley. Incremental closeness centrality for dynamically changingsocial networks. In Rokne and Faloutsos [207], pages 1250–1258. ISBN 978-1-4503-2240-9. doi: 10.1145/2492517.2500270. URL https://doi.org/10.1145/2492517.2500270.[150] Miray Kas, Matthew Wachs, Kathleen M. Carley, and L. Richard Carley. Incremental algorithm for updating between-ness centrality in dynamically growing networks. In Rokne and Faloutsos [207], pages 33–40. ISBN 978-1-4503-2240-9. doi: 10.1145/2492517.2492533. URL https://doi.org/10.1145/2492517.2492533. [151] Irit Katriel and Hans L. Bodlaender. Online topological ordering.
ACM Trans. Algorithms , 2(3):364–379, 2006. doi:10.1145/1159892.1159896. URL https://doi.org/10.1145/1159892.1159896.[152] Telikepalli Kavitha and Rogers Mathew. Faster algorithms for online topological ordering.
CoRR , abs/0711.0251,2007. URL http://arxiv.org/abs/0711.0251.[153] Tim Kiefer, Dirk Habich, and Wolfgang Lehner. Penalized graph partitioning for static and dynamic load balancing. InPierre-François Dutot and Denis Trystram, editors,
Euro-Par 2016: Parallel Processing - 22nd International Conferenceon Parallel and Distributed Computing, Grenoble, France, August 24-26, 2016, Proc. , volume 9833 of
Lecture Notes inComputer Science , pages 146–158. Springer, 2016. ISBN 978-3-319-43658-6. doi: 10.1007/978-3-319-43659-3\_11. URLhttps://doi.org/10.1007/978-3-319-43659-3_11.[154] Valerie King. Fully dynamic algorithms for maintaining all-pairs shortest paths and transitive closure in di-graphs. In , pages 81–91. IEEE Computer Society, 1999. ISBN 0-7695-0409-4. doi: 10.1109/SFFCS.1999.814580. URLhttps://doi.org/10.1109/SFFCS.1999.814580.[155] Valerie King and Garry Sagert. A fully dynamic algorithm for maintaining the transitive closure.
J. Comput. Syst.Sci. , 65(1):150–167, 2002. doi: 10.1006/jcss.2002.1883. URL https://doi.org/10.1006/jcss.2002.1883.[156] Valerie King and Mikkel Thorup. A space saving trick for directed dynamic transitive closure and shortest pathalgorithms. In Jie Wang, editor,
Computing and Combinatorics, 7th Annual International Conference, COCOON 2001,Guilin, China, August 20-23, 2001, Proc. , volume 2108 of
Lecture Notes in Computer Science , pages 268–277. Springer,2001. doi: 10.1007/3-540-44679-6\_30. URL https://doi.org/10.1007/3-540-44679-6_30.[157] Pushmeet Kohli and Philip H. S. Torr. Dynamic graph cuts for efficient inference in markov randomfields.
IEEE Trans. Pattern Anal. Mach. Intell. , 29(12):2079–2088, 2007. doi: 10.1109/TPAMI.2007.1128. URLhttps://doi.org/10.1109/TPAMI.2007.1128.[158] Pushmeet Kohli and Philip H. S. Torr. Dynamic graph cuts and their applications in computer vision. In RobertoCipolla, Sebastiano Battiato, and Giovanni Maria Farinella, editors,
Computer Vision: Detection, Recognition and Re-construction , volume 285 of
Studies in Computational Intelligence , pages 51–108. Springer, 2010. doi: 10.1007/978-3-642-12848-6\_3. URL https://doi.org/10.1007/978-3-642-12848-6_3.[159] Nicolas Kourtellis, Gianmarco De Francisci Morales, and Francesco Bonchi. Scalable online betweenness centralityin evolving graphs.
IEEE Trans. Knowl. Data Eng. , 27(9):2494–2506, 2015. doi: 10.1109/TKDE.2015.2419666. URLhttps://doi.org/10.1109/TKDE.2015.2419666.[160] Nicolas Kourtellis, Gianmarco De Francisci Morales, and Francesco Bonchi. Scalable online betweenness centralityin evolving graphs. In , pages 1580–1581. IEEE Computer Society, 2016. ISBN 978-1-5090-2020-1. doi: 10.1109/ICDE.2016.7498421.URL https://doi.org/10.1109/ICDE.2016.7498421.[161] Ioannis Krommidas and Christos D. Zaroliagis. An experimental study of algorithms for fully dynamictransitive closure.
ACM J. Exp. Algorithmics , 12:1.6:1–1.6:22, 2008. doi: 10.1145/1227161.1370597. URLhttps://doi.org/10.1145/1227161.1370597.[162] S. Kumar and P. Gupta. An incremental algorithm for the maximum flow problem.
J. Math. Model. Algorithms , 2(1):1–16, 2003. doi: 10.1023/A:1023607406540. URL https://doi.org/10.1023/A:1023607406540.[163] J. A. La Poutré and J. van Leeuwen. Maintenance of transitive closures and transitive reductions of graphs. InHerbert Göttler and Hana-Jürgen Schneider, editors,
Graph-Theoretic Concepts in Computer Science , pages 106–120,Berlin, Heidelberg, 1988. Springer Berlin Heidelberg. ISBN 978-3-540-39264-4.[164] Min-Joong Lee, Jungmin Lee, Jaimie Yejean Park, Ryan Hyun Choi, and Chin-Wan Chung. QUBE: a quick al-gorithm for updating betweenness centrality. In Alain Mille, Fabien L. Gandon, Jacques Misselis, Michael Rabi-novich, and Steffen Staab, editors,
Proc. of the 21st World Wide Web Conference 2012, WWW 2012, Lyon, France,April 16-20, 2012 , pages 351–360. ACM, 2012. ISBN 978-1-4503-1229-5. doi: 10.1145/2187836.2187884. URLhttps://doi.org/10.1145/2187836.2187884.[165] Min-Joong Lee, Sunghee Choi, and Chin-Wan Chung. Efficient algorithms for updating betweennesscentrality in fully dynamic graphs.
Inf. Sci. , 326:278–296, 2016. doi: 10.1016/j.ins.2015.07.053. URLhttps://doi.org/10.1016/j.ins.2015.07.053.[166] Rong-Hua Li, Jeffrey Xu Yu, and Rui Mao. Efficient core maintenance in large dynamic graphs.
IEEE Trans. Knowl.Data Eng. , 26(10):2453–2465, 2014. doi: 10.1109/TKDE.2013.158. URL https://doi.org/10.1109/TKDE.2013.158.[167] Yongsub Lim and U Kang. MASCOT: memory-efficient and accurate sampling for counting local triangles in graphstreams. In Longbing Cao, Chengqi Zhang, Thorsten Joachims, Geoffrey I. Webb, Dragos D. Margineantu, andGraham Williams, editors,
Proc. of the 21th ACM SIGKDD International Conference on Knowledge Discovery and DataMining, Sydney, NSW, Australia, August 10-13, 2015 , pages 685–694. ACM, 2015. ISBN 978-1-4503-3664-2. doi: 10.1145/2783258.2783285. URL https://doi.org/10.1145/2783258.2783285. ecent Advances in Fully Dynamic Graph Algorithms 35 [168] Yongsub Lim, Minsoo Jung, and U Kang. Memory-efficient and accurate sampling for counting local triangles ingraph streams: From simple to multigraphs.
ACM Trans. Knowl. Discov. Data , 12(1):4:1–4:28, 2018. doi: 10.1145/3022186. URL https://doi.org/10.1145/3022186.[169] Paul Liu, Austin R. Benson, and Moses Charikar. Sampling methods for counting temporal motifs. In J. Shane Culpep-per, Alistair Moffat, Paul N. Bennett, and Kristina Lerman, editors,
Proc. of the Twelfth ACM International Conferenceon Web Search and Data Mining, WSDM 2019, Melbourne, VIC, Australia, February 11-15, 2019 , pages 294–302. ACM,2019. ISBN 978-1-4503-5940-5. doi: 10.1145/3289600.3290988. URL https://doi.org/10.1145/3289600.3290988.[170] Jakub Łącki. Improved deterministic algorithms for decremental transitive closure and strongly connected com-ponents. In Dana Randall, editor,
Proc. of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Al-gorithms, SODA 2011, San Francisco, California, USA, January 23-25, 2011 , pages 1438–1445. SIAM, 2011. doi:10.1137/1.9781611973082.111. URL https://doi.org/10.1137/1.9781611973082.111.[171] Devavret Makkar, David A. Bader, and Oded Green. Exact and parallel triangle counting in dynamic graphs. In , pages2–12. IEEE Computer Society, 2017. doi: 10.1109/HiPC.2017.00011. URL https://doi.org/10.1109/HiPC.2017.00011.[172] Alberto Marchetti-Spaccamela, Umberto Nanni, and Hans Rohnert. Maintaining a topological order un-der edge insertions.
Inf. Process. Lett. , 59(1):53–58, 1996. doi: 10.1016/0020-0190(96)00075-0. URLhttps://doi.org/10.1016/0020-0190(96)00075-0.[173] Henning Meyerhenke. Dynamic load balancing for parallel numerical simulations based on repartitioning withdisturbed diffusion. In , pages 150–157. IEEE, 2009.doi: 10.1109/ICPADS.2009.114. URL https://doi.org/10.1109/ICPADS.2009.114.[174] Henning Meyerhenke and Joachim Gehweiler. On dynamic graph partitioning and graph clustering using diffusion.In Giuseppe F. Italiano, David S. Johnson, Petra Mutzel, and Peter Sanders, editors,
Algorithm Engineering, 27.06. -02.07.2010 , volume 10261 of
Dagstuhl Seminar Proc.
Schloss Dagstuhl - Leibniz-Zentrum für Informatik, Germany,2010. URL http://drops.dagstuhl.de/opus/volltexte/2010/2798/.[175] Kurt T Miller and Tina Eliassi-Rad. Continuous time group discovery in dynamic graphs. In
Notes of the 2009 NIPSWorkshop on Analyzing Networks and Learning with Graphs, Whistler, BC, Canada , 2009.[176] Peter Bro Miltersen, Sairam Subramanian, Jeffrey Scott Vitter, and Roberto Tamassia. Complexity models forincremental computation.
Theor. Comput. Sci. , 130(1):203–236, 1994. doi: 10.1016/0304-3975(94)90159-7. URLhttps://doi.org/10.1016/0304-3975(94)90159-7.[177] Daniele Miorandi and Francesco De Pellegrini. K-shell decomposition for dynamic complex networks. In
DBL [1], pages 488–496. ISBN 978-1-4244-7523-0. URLhttp://ieeexplore.ieee.org/document/5520231/.[178] Kingshuk Mukherjee, Md Mahmudul Hasan, Christina Boucher, and Tamer Kahveci. Counting mo-tifs in dynamic networks.
BMC Syst. Biol. , 12(1):1–12, 2018. doi: 10.1186/s12918-018-0533-6. URLhttps://doi.org/10.1186/s12918-018-0533-6.[179] Paolo Narváez, Kai-Yeung Siu, and Hong-Yi Tzeng. New dynamic algorithms for shortest path tree computation.
IEEE/ACM Trans. Netw. , 8(6):734–746, 2000. doi: 10.1109/90.893870. URL https://doi.org/10.1109/90.893870.[180] Paolo Narváez, Kai-Yeung Siu, and Hong-Yi Tzeng. New dynamic SPT algorithm based on a ball-and-string model.
IEEE/ACM Trans. Netw. , 9(6):706–718, 2001. doi: 10.1109/90.974525. URL https://doi.org/10.1109/90.974525.[181] Eisha Nathan and David A. Bader. A dynamic algorithm for updating katz centrality in graphs. In Diesner et al. [77],pages 149–154. ISBN 978-1-4503-4993-2. doi: 10.1145/3110025.3110034. URL https://doi.org/10.1145/3110025.3110034.[182] Eisha Nathan and David A. Bader. Approximating personalized katz centrality in dynamic graphs. In RomanWyrzykowski, Jack J. Dongarra, Ewa Deelman, and Konrad Karczewski, editors,
Parallel Processing and Applied Math-ematics - 12th International Conference, PPAM 2017, Lublin, Poland, September 10-13, 2017, Revised Selected Papers, PartI , volume 10777 of
Lecture Notes in Computer Science , pages 290–302. Springer, 2017. ISBN 978-3-319-78023-8. doi:10.1007/978-3-319-78024-5\_26. URL https://doi.org/10.1007/978-3-319-78024-5_26.[183] Ofer Neiman and Shay Solomon. Simple deterministic algorithms for fully dynamic maximal matching.
ACM Trans.Algorithms , 12(1):7:1–7:15, 2016. doi: 10.1145/2700206. URL https://doi.org/10.1145/2700206.[184] M. EJ Newman and M. Girvan. Finding and Evaluating Community Structure in Networks.
Physical review E , 69(2):026113, 2004. doi: 10.1103/PhysRevE.69.026113. URL https://doi.org/10.1103/PhysRevE.69.026113.[185] Daniel Nicoara, Shahin Kamali, Khuzaima Daudjee, and Lei Chen. Hermes: Dynamic partitioning for dis-tributed social network graph databases. In
EDBT , pages 25–36, 2015. doi: 10.5441/002/edbt.2015.04. URLhttps://doi.org/10.5441/002/edbt.2015.04.[186] Krzysztof Onak and Ronitt Rubinfeld. Maintaining a large matching and a small vertex cover. In
STOC , pages457–464, 2010. doi: 10.1145/1806689.1806753. URL https://doi.org/10.1145/1806689.1806753. [187] James B. Orlin. Max flows in o(nm) time, or better. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors,
Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013 , pages 765–774. ACM,2013. doi: 10.1145/2488608.2488705. URL https://doi.org/10.1145/2488608.2488705.[188] Mihai Patrascu. Towards polynomial lower bounds for dynamic problems. In
Proc. of the 42nd ACM Sym-posium on Theory of Computing, STOC , pages 603–610. ACM, 2010. doi: 10.1145/1806689.1806772. URLhttps://doi.org/10.1145/1806689.1806772.[189] Mihai Patrascu and Erik D. Demaine. Logarithmic lower bounds in the cell-probe model.
SIAM J. Comput. , 35(4):932–963, 2006. doi: 10.1137/S0097539705447256. URL https://doi.org/10.1137/S0097539705447256.[190] Mihai Patrascu and Mikkel Thorup. Planning for fast connectivity updates. In , pages 263–271. IEEE, 2007.[191] A. Pavan, Kanat Tangwongsan, Srikanta Tirthapura, and Kun-Lung Wu. Counting and sampling trianglesfrom a graph stream.
Proc. VLDB Endow.
ACSC , 2010. doi: 10.5555/1862199.1862208. URL https://dl.acm.org/doi/pdf/10.5555/1862199.1862208.[193] David J. Pearce and Paul H. J. Kelly. A dynamic algorithm for topologically sorting directed acyclic graphs.In Celso C. Ribeiro and Simone L. Martins, editors,
Experimental and Efficient Algorithms, Third InternationalWorkshop, WEA 2004, Angra dos Reis, Brazil, May 25-28, 2004, Proc. , volume 3059 of
Lecture Notes in Com-puter Science , pages 383–398. Springer, 2004. ISBN 3-540-22067-4. doi: 10.1007/978-3-540-24838-5\_29. URLhttps://doi.org/10.1007/978-3-540-24838-5_29.[194] David J. Pearce and Paul H. J. Kelly. A dynamic topological sort algorithm for directed acyclic graphs.
ACM J. Exp.Algorithmics , 11, 2006. doi: 10.1145/1187436.1210590. URL https://doi.org/10.1145/1187436.1210590.[195] David J. Pearce, Paul H. J. Kelly, and Chris Hankin. Online cycle detection and difference propagation: Appli-cations to pointer analysis.
Softw. Qual. J. , 12(4):311–337, 2004. doi: 10.1023/B:SQJO.0000039791.93071.a2. URLhttps://doi.org/10.1023/B:SQJO.0000039791.93071.a2.[196] Reynaldo Gil Pons. Space efficient incremental betweenness algorithm for directed graphs. In Rubén Vera-Rodríguez,Julian Fiérrez, and Aythami Morales, editors,
Progress in Pattern Recognition, Image Analysis, Computer Vision, andApplications - 23rd Iberoamerican Congress, CIARP 2018, Madrid, Spain, November 19-22, 2018, Proc. , volume 11401 of
Lecture Notes in Computer Science , pages 262–270. Springer, 2018. ISBN 978-3-030-13468-6. doi: 10.1007/978-3-030-13469-3\_31. URL https://doi.org/10.1007/978-3-030-13469-3_31.[197] K. (Lynn) Putman, Hanjo D. Boekhout, and Frank W. Takes. Fast incremental computation of harmonic closenesscentrality in directed weighted networks. In Francesca Spezzano, Wei Chen, and Xiaokui Xiao, editors,
ASONAM ’19:International Conference on Advances in Social Networks Analysis and Mining, Vancouver, British Columbia, Canada,27-30 August, 2019 , pages 1018–1025. ACM, 2019. ISBN 978-1-4503-6868-1. doi: 10.1145/3341161.3344829. URLhttps://doi.org/10.1145/3341161.3344829.[198] G Ramalingam and Thomas Reps. On the computational complexity of incremental algorithms. Technical report,University of Wisconsin-Madison Department of Computer Sciences, 1991.[199] G. Ramalingam and Thomas W. Reps. An incremental algorithm for a generalization of the shortest-path problem.
J. Algorithms , 21(2):267–305, 1996. doi: 10.1006/jagm.1996.0046. URL https://doi.org/10.1006/jagm.1996.0046.[200] G. Ramalingam and Thomas W. Reps. On the computational complexity of dynamic graph problems.
Theor. Comput.Sci. , 158(1&2):233–277, 1996. doi: 10.1016/0304-3975(95)00079-8. URL https://doi.org/10.1016/0304-3975(95)00079-8.[201] Sara Riazi, Sriram Srinivasan, Sajal K. Das, Sanjukta Bhowmick, and Boyana Norris. Single-source shortest path treefor big dynamic graphs. In Naoki Abe, Huan Liu, Calton Pu, Xiaohua Hu, Nesreen K. Ahmed, Mu Qiao, Yang Song,Donald Kossmann, Bing Liu, Kisung Lee, Jiliang Tang, Jingrui He, and Jeffrey S. Saltz, editors,
IEEE InternationalConference on Big Data, Big Data 2018, Seattle, WA, USA, December 10-13, 2018 , pages 4054–4062. IEEE, 2018. doi:10.1109/BigData.2018.8622042. URL https://doi.org/10.1109/BigData.2018.8622042.[202] Celso C. Ribeiro and Rodrigo F. Toso. Experimental analysis of algorithms for updating minimum spanning treeson graphs subject to changes on edge weights. In Demetrescu [70], pages 393–405. ISBN 978-3-540-72844-3. doi:10.1007/978-3-540-72845-0\_30. URL https://doi.org/10.1007/978-3-540-72845-0_30.[203] Matteo Riondato and Evgenios M. Kornaropoulos. Fast approximation of betweenness centrality through sampling.In Ben Carterette, Fernando Diaz, Carlos Castillo, and Donald Metzler, editors,
Seventh ACM International Conferenceon Web Search and Data Mining, WSDM 2014, New York, NY, USA, February 24-28, 2014 , pages 413–422. ACM, 2014.doi: 10.1145/2556195.2556224. URL https://doi.org/10.1145/2556195.2556224.[204] Liam Roditty. A faster and simpler fully dynamic transitive closure.
ACM Trans. Algorithms , 4(1):6:1–6:16, 2008. doi:10.1145/1328911.1328917. URL https://doi.org/10.1145/1328911.1328917.[205] Liam Roditty and Uri Zwick. Improved dynamic reachability algorithms for directed graphs.
SIAM J. Comput. , 37(5):1455–1471, 2008. doi: 10.1137/060650271. URL https://doi.org/10.1137/060650271. ecent Advances in Fully Dynamic Graph Algorithms 37 [206] Liam Roditty and Uri Zwick. A fully dynamic reachability algorithm for directed graphs with an almostlinear update time.
SIAM Journal on Computing , 45(3):712–733, 2016. doi: 10.1137/13093618X. URLhttps://doi.org/10.1137/13093618X.[207] Jon G. Rokne and Christos Faloutsos, editors.
Advances in Social Networks Analysis and Mining 2013,ASONAM ’13, Niagara, ON, Canada - August 25 - 29, 2013 , 2013. ACM. ISBN 978-1-4503-2240-9. URLhttp://dl.acm.org/citation.cfm?id=2492517.[208] Giulio Rossetti and Rémy Cazabet. Community discovery in dynamic networks: A survey.
ACM Comput. Surv. , 51(2):35:1–35:37, 2018. doi: 10.1145/3172867. URL https://doi.org/10.1145/3172867.[209] Tiberiu Rotaru and Hans-Heinrich Nägeli. Dynamic load balancing by diffusion in heterogeneous systems.
Journal of Parallel and Distributed Computing , 64(4):481–497, 2004. doi: 10.1016/j.jpdc.2004.02.001. URLhttps://doi.org/10.1016/j.jpdc.2004.02.001.[210] Chayma Sakouhi, Sabeur Aridhi, Alessio Guerrieri, Salma Sassi, and Alberto Montresor. Dynamicdfep: A distributededge partitioning approach for large dynamic graphs. In Evan Desai, Bipin C. Desai, Motomichi Toyama, and JorgeBernardino, editors,
Proc. of the 20th International Database Engineering & Applications Symposium, IDEAS 2016, Mon-treal, QC, Canada, July 11-13, 2016 , pages 142–147. ACM, 2016. ISBN 978-1-4503-4118-9. doi: 10.1145/2938503.2938506.URL https://doi.org/10.1145/2938503.2938506.[211] Piotr Sankowski. Dynamic transitive closure via dynamic matrix inverse (extended abstract). In , pages 509–517. IEEE ComputerSociety, 2004. doi: 10.1109/FOCS.2004.25. URL https://doi.org/10.1109/FOCS.2004.25.[212] Piotr Sankowski. Faster dynamic matchings and vertex connectivity. In
SODA , pages 118–126, 2007. doi: 10.1145/1283383.1283397. URL http://doi.acm.org/10.1145/1283383.1283397.[213] Ahmet Erdem Sariyüce, Kamer Kaya, Erik Saule, and Ümit V. Çatalyürek. Incremental algorithms for closenesscentrality. In Xiaohua Hu, Tsau Young Lin, Vijay V. Raghavan, Benjamin W. Wah, Ricardo Baeza-Yates, Geof-frey C. Fox, Cyrus Shahabi, Matthew Smith, Qiang Yang, Rayid Ghani, Wei Fan, Ronny Lempel, and RaghunathNambiar, editors,
Proc. of the 2013 IEEE International Conference on Big Data, 6-9 October 2013, Santa Clara, CA, USA ,pages 487–492. IEEE Computer Society, 2013. ISBN 978-1-4799-1292-6. doi: 10.1109/BigData.2013.6691611. URLhttps://doi.org/10.1109/BigData.2013.6691611.[214] Ahmet Erdem Sariyüce, Erik Saule, Kamer Kaya, and Ümit V. Çatalyürek. STREAMER: A distributed framework forincremental closeness centrality computation. In , pages 1–8. IEEE Computer Society, 2013. ISBN 978-1-4799-0898-1.doi: 10.1109/CLUSTER.2013.6702680. URL https://doi.org/10.1109/CLUSTER.2013.6702680.[215] Ahmet Erdem Sariyüce, Erik Saule, Kamer Kaya, and Ümit V. Çatalyürek. Incremental closeness cen-trality in distributed memory.
Parallel Comput. , 47:3–18, 2015. doi: 10.1016/j.parco.2015.01.003. URLhttps://doi.org/10.1016/j.parco.2015.01.003.[216] Ahmet Erdem Sariyüce, Bugra Gedik, Gabriela Jacques-Silva, Kun-Lung Wu, and Ümit V. Çatalyürek. Incrementalk-core decomposition: algorithms and evaluation.
VLDB J. , 25(3):425–447, 2016. doi: 10.1007/s00778-016-0423-8.URL https://doi.org/10.1007/s00778-016-0423-8.[217] Benjamin Schiller, Sven Jager, Kay Hamacher, and Thorsten Strufe. Stream - A stream-based algorithm for countingmotifs in dynamic graphs. In Adrian-Horia Dediu, Francisco Hernández Quiroz, Carlos Martín-Vide, and David A.Rosenblueth, editors,
Algorithms for Computational Biology - Second International Conference, AlCoB 2015, MexicoCity, Mexico, August 4-5, 2015, Proc. , volume 9199 of
Lecture Notes in Computer Science , pages 53–67. Springer, 2015.ISBN 978-3-319-21232-6. doi: 10.1007/978-3-319-21233-3\_5. URL https://doi.org/10.1007/978-3-319-21233-3_5.[218] Kirk Schloegel, George Karypis, and Vipin Kumar. Multilevel diffusion schemes for repartitioning of adap-tive meshes.
J. Parallel Distributed Comput. , 47(2):109–124, 1997. doi: 10.1006/jpdc.1997.1410. URLhttps://doi.org/10.1006/jpdc.1997.1410.[219] Kirk Schloegel, George Karypis, and Vipin Kumar. A unified algorithm for load-balancing adaptive scientific simu-lations. In Jed Donnelley, editor,
Proc. Supercomputing 2000, November 4-10, 2000, Dallas, Texas, USA. IEEE ComputerSociety, CD-ROM , page 59. IEEE Computer Society, 2000. ISBN 0-7803-9802-5. doi: 10.1109/SC.2000.10035. URLhttps://doi.org/10.1109/SC.2000.10035.[220] Kirk Schloegel, George Karypis, and Vipin Kumar. Parallel static and dynamic multi-constraint graph partitioning.
Concurr. Comput. Pract. Exp. , 14(3):219–240, 2002. doi: 10.1002/cpe.605. URL https://doi.org/10.1002/cpe.605.[221] Dominik Schultes and Peter Sanders. Dynamic highway-node routing. In Demetrescu [70], pages 66–79. ISBN978-3-540-72844-3. doi: 10.1007/978-3-540-72845-0\_6. URL https://doi.org/10.1007/978-3-540-72845-0_6.[222] Dipanjan Sengupta, Narayanan Sundaram, Xia Zhu, Theodore L Willke, Jeffrey Young, Matthew Wolf, andKarsten Schwan. Graphin: An online high performance incremental graph processing framework. In
Euro-pean Conference on Parallel Processing , pages 319–333. Springer, 2016. doi: 10.1007/978-3-319-43659-3\_24. URLhttps://doi.org/10.1007/978-3-319-43659-3_24. [223] Neha Sengupta, Michael Hamann, and Dorothea Wagner. Benchmark generator for dynamic overlapping commu-nities in networks. In Vijay Raghavan, Srinivas Aluru, George Karypis, Lucio Miele, and Xindong Wu, editors, , pages 415–424. IEEE Computer Society, 2017. doi: 10.1109/ICDM.2017.51. URL https://doi.org/10.1109/ICDM.2017.51.[224] Zhenzhen Shao, Na Guo, Yu Gu, Zhigang Wang, Fangfang Li, and Ge Yu. Efficient closeness centrality com-putation for dynamic graphs. In Yunmook Nah, Bin Cui, Sang-Won Lee, Jeffrey Xu Yu, Yang-Sae Moon, andSteven Euijong Whang, editors,
Database Systems for Advanced Applications - 25th International Conference, DAS-FAA 2020, Jeju, South Korea, September 24-27, 2020, Proc., Part II , volume 12113 of
Lecture Notes in ComputerScience , pages 534–550. Springer, 2020. ISBN 978-3-030-59415-2. doi: 10.1007/978-3-030-59416-9\_32. URLhttps://doi.org/10.1007/978-3-030-59416-9_32.[225] Y. Shiloach and S. Even. An on-line edge-deletion problem.
Journal of the ACM , 28(1):1–4, 1981. ISSN 0004-5411.doi: 10.1145/322234.322235. URL https://doi.org/10.1145/322234.322235.[226] Daniel Dominic Sleator and Robert Endre Tarjan. A data structure for dynamic trees. In
Proc. of the 13th AnnualACM Symposium on Theory of Computing, May 11-13, 1981, Milwaukee, Wisconsin, USA , pages 114–122. ACM, 1981.doi: 10.1145/800076.802464. URL https://doi.org/10.1145/800076.802464.[227] Shay Solomon. Fully dynamic maximal matching in constant update time. In , pages 325–334, 2016. doi: 10.1109/FOCS.2016.43. URL https://doi.org/10.1109/FOCS.2016.43.[228] Lorenzo De Stefani, Alessandro Epasto, Matteo Riondato, and Eli Upfal. Trièst: Counting local and global trianglesin fully dynamic streams with fixed memory size.
ACM Trans. Knowl. Discov. Data , 11(4):43:1–43:50, 2017. doi:10.1145/3059194. URL https://doi.org/10.1145/3059194.[229] Daniel Stubbs and Virginia Vassilevska Williams. Metatheorems for dynamic weighted matching. In Christos H. Pa-padimitriou, editor, , volume 67 of
LIPIcs , pages 58:1–58:14. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2017. ISBN978-3-95977-029-3. doi: 10.4230/LIPIcs.ITCS.2017.58. URL https://doi.org/10.4230/LIPIcs.ITCS.2017.58.[230] Bintao Sun, T.-H. Hubert Chan, and Mauro Sozio. Fully dynamic approximate k-core decomposition in hy-pergraphs.
ACM Trans. Knowl. Discov. Data , 14(4), May 2020. ISSN 1556-4681. doi: 10.1145/3385416. URLhttps://doi.org/10.1145/3385416.[231] Robert Endre Tarjan. Efficiency of a good but not linear set union algorithm.
J. ACM , 22(2):215–225, 1975. doi:10.1145/321879.321884. URL https://doi.org/10.1145/321879.321884.[232] Robert Endre Tarjan and Renato Fonseca F. Werneck. Dynamic trees in practice.
ACM J. Exp. Algorithmics , 14, 2009.doi: 10.1145/1498698.1594231. URL https://doi.org/10.1145/1498698.1594231.[233] Mikkel Thorup. Fully-dynamic all-pairs shortest paths: Faster and allowing negative cycles. In Torben Hagerup andJyrki Katajainen, editors,
Algorithm Theory - SWAT 2004, 9th Scandinavian Workshop on Algorithm Theory, Humlebaek,Denmark, July 8-10, 2004, Proc. , volume 3111 of
Lecture Notes in Computer Science , pages 384–396. Springer, 2004. doi:10.1007/978-3-540-27810-8\_33. URL https://doi.org/10.1007/978-3-540-27810-8_33.[234] Nicolas Tremblay and Michael Florian. Temporal shortest paths: Parallel computing implemen-tations.
Parallel Comput. , 27(12):1569–1609, 2001. doi: 10.1016/S0167-8191(01)00107-7. URLhttps://doi.org/10.1016/S0167-8191(01)00107-7.[235] Jan van den Brand, Danupon Nanongkai, and Thatchaphol Saranurak. Dynamic matrix inverse: Improved algorithmsand matching conditional lower bounds. In David Zuckerman, editor, , pages 456–480. IEEE Computer Society,2019. doi: 10.1109/FOCS.2019.00036. URL https://doi.org/10.1109/FOCS.2019.00036.[236] Alexander van der Grinten, Elisabetta Bergamini, Oded Green, David A. Bader, and Henning Meyerhenke. Scalablekatz ranking computation in large static and dynamic graphs. In Yossi Azar, Hannah Bast, and Grzegorz Herman,editors, , volume 112of
LIPIcs , pages 42:1–42:14. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018. ISBN 978-3-95977-081-1. doi:10.4230/LIPIcs.ESA.2018.42. URL https://doi.org/10.4230/LIPIcs.ESA.2018.42.[237] Luis M. Vaquero, Félix Cuadrado, Dionysios Logothetis, and Claudio Martella. xdgp: A dynamic graph processingsystem with adaptive partitioning.
CoRR , abs/1309.1049, 2013. URL http://arxiv.org/abs/1309.1049.[238] Luis M. Vaquero, Félix Cuadrado, Dionysios Logothetis, and Claudio Martella. Adaptive partitioning for large-scaledynamic graphs. In
IEEE 34th International Conference on Distributed Computing Systems, ICDCS 2014, Madrid, Spain,June 30 - July 3, 2014 , pages 144–153. IEEE Computer Society, 2014. ISBN 978-1-4799-5168-0. doi: 10.1109/ICDCS.2014.23. URL https://doi.org/10.1109/ICDCS.2014.23.[239] Tanmay Verma and Dhruv Batra. Maxflow revisited: An empirical comparison of maxflow algorithms for densevision problems. In Richard Bowden, John P. Collomosse, and Krystian Mikolajczyk, editors,
British Machine VisionConference, BMVC 2012, Surrey, UK, September 3-7, 2012 , pages 1–12. BMVA Press, 2012. doi: 10.5244/C.26.61. URLhttps://doi.org/10.5244/C.26.61. ecent Advances in Fully Dynamic Graph Algorithms 39 [240] Dorothea Wagner, Thomas Willhalm, and Christos D. Zaroliagis. Geometric containers for efficientshortest-path computation.
ACM J. Exp. Algorithmics , 10, 2005. doi: 10.1145/1064546.1103378. URLhttps://doi.org/10.1145/1064546.1103378.[241] Chris Walshaw, Mark Cross, and Martin G. Everett. Parallel dynamic graph partitioning for adaptive un-structured meshes.
J. Parallel Distributed Comput. , 47(2):102–108, 1997. doi: 10.1006/jpdc.1997.1407. URLhttps://doi.org/10.1006/jpdc.1997.1407.[242] Jingjing Wang, Yanhao Wang, Wenjun Jiang, Yuchen Li, and Kian-Lee Tan. Efficient sampling algorithms for ap-proximate temporal motif counting. In Mathieu d’Aquin, Stefan Dietze, Claudia Hauff, Edward Curry, and PhilippeCudré-Mauroux, editors,
CIKM ’20: The 29th ACM International Conference on Information and Knowledge Man-agement, Virtual Event, Ireland, October 19-23, 2020 , pages 1505–1514. ACM, 2020. ISBN 978-1-4503-6859-9. doi:10.1145/3340531.3411862. URL https://doi.org/10.1145/3340531.3411862.[243] Na Wang, Dongxiao Yu, Hai Jin, Chen Qian, Xia Xie, and Qiang-Sheng Hua. Parallel algorithm for core maintenancein dynamic graphs. In Kisung Lee and Ling Liu, editors, , pages 2366–2371. IEEE Computer Society, 2017. ISBN 978-1-5386-1792-2. doi: 10.1109/ICDCS.2017.288. URL https://doi.org/10.1109/ICDCS.2017.288.[244] Stefan Weigert, Matti Hiltunen, and Christof Fetzer. Mining large distributed log data in near real time. In
ManagingLarge-scale Systems via the Analysis of System Logs and the Application of Machine Learning Techniques , pages 1–8.2011. doi: 10.1145/2038633.2038638. URL https://doi.org/10.1145/2038633.2038638.[245] Martin Winter, Daniel Mlakar, Rhaleb Zayer, Hans-Peter Seidel, and Markus Steinberger. faimgraph: high perfor-mance management of fully-dynamic graphs under tight memory constraints on the GPU. In
Proc. of the InternationalConference for High Performance Computing, Networking, Storage, and Analysis, SC 2018, Dallas, TX, USA, November11-16, 2018 , pages 60:1–60:13. IEEE / ACM, 2018. URL http://dl.acm.org/citation.cfm?id=3291736.[246] Ning Xu, Lei Chen, and Bin Cui. Loggp: a log-based dynamic graph partitioning method.
Proc. of the VLDB Endow-ment , 7(14):1917–1928, 2014. doi: 10.14778/2733085.2733097. URL https://doi.org/10.14778/2733085.2733097.[247] Daniel M. Yellin. Speeding up dynamic transitive closure for bounded degree graphs.
Acta Informatica , 30(4):369–384,1993. doi: 10.1007/BF01209711. URL https://doi.org/10.1007/BF01209711.[248] Chia-Chen Yen, Mi-Yen Yeh, and Ming-Syan Chen. An efficient approach to updating closeness centrality andaverage path length in dynamic networks. In Hui Xiong, George Karypis, Bhavani M. Thuraisingham, Diane J.Cook, and Xindong Wu, editors, , pages 867–876. IEEE Computer Society, 2013. ISBN 978-0-7695-5108-1. doi: 10.1109/ICDM.2013.135. URLhttps://doi.org/10.1109/ICDM.2013.135.[249] Anita Zakrzewska and David A. Bader. Fast incremental community detection on dynamic graphs. In RomanWyrzykowski, Ewa Deelman, Jack Dongarra, Konrad Karczewski, Jacek Kitowski, and Kazimierz Wiatr, editors,
Par-allel Processing and Applied Mathematics , pages 207–217, Cham, 2016. Springer International Publishing. ISBN 978-3-319-32149-3. doi: 10.1007/978-3-319-32149-3\_20. URL https://doi.org/10.1007/978-3-319-32149-3_20.[250] Christos D Zaroliagis. Implementations and experimental studies of dynamic graph algorithms. In
Experimental algorithmics , pages 229–278. Springer, 2002. doi: 10.1007/3-540-36383-1\_11. URLhttps://doi.org/10.1007/3-540-36383-1_11.[251] Yikai Zhang, Jeffrey Xu Yu, Ying Zhang, and Lu Qin. A fast order-based approach for core maintenance.In ,pages 337–348. IEEE Computer Society, 2017. ISBN 978-1-5090-6543-1. doi: 10.1109/ICDE.2017.93. URLhttps://doi.org/10.1109/ICDE.2017.93.[252] Weiguo Zheng, Qichen Wang, Jeffrey Xu Yu, Hong Cheng, and Lei Zou. Efficient computation of a near-maximumindependent set over evolving graphs. In , pages 869–880. IEEE Computer Society, 2018. ISBN 978-1-5386-5520-7. doi: 10.1109/ICDE.2018.00083. URL https://doi.org/10.1109/ICDE.2018.00083.[253] Weiguo Zheng, Chengzhi Piao, Hong Cheng, and Jeffrey Xu Yu. Computing a near-maximum independentset in dynamic graphs. In , pages 76–87. IEEE, 2019. ISBN 978-1-5386-7474-1. doi: 10.1109/ICDE.2019.00016. URLhttps://doi.org/10.1109/ICDE.2019.00016.[254] Lei Zhu, Shaoning Pang, Abdolhossein Sarrafzadeh, Tao Ban, and Daisuke Inoue. Incremental and decremental max-flow for online semi-supervised learning.
IEEE Trans. Knowl. Data Eng. , 28(8):2115–2127, 2016. doi: 10.1109/TKDE.2016.2550042. URL https://doi.org/10.1109/TKDE.2016.2550042.[255] Di Zhuang, Morris J Chang, and Mingchen Li. Dynamo: Dynamic community detection by incrementally maximizingmodularity.
IEEE Transactions on Knowledge and Data Engineering , 2019. doi: 10.1109/TKDE.2019.2951419. URLhttps://doi.org/10.1109/TKDE.2019.2951419. [256] Yiming Zou, Gang Zeng, Yuyi Wang, Xingwu Liu, Xiaoming Sun, Jialin Zhang, and Qiang Li. Shortest paths onevolving graphs. In Hien T. Nguyen and Václav Snásel, editors,
Computational Social Networks - 5th InternationalConference, CSoNet , volume 9795 of
Lecture Notes in Computer Science , pages 1–13. Springer, 2016. ISBN 978-3-319-42344-9. doi: 10.1007/978-3-319-42345-6\_1. URL https://doi.org/10.1007/978-3-319-42345-6_1.[257] David Zuckerman, editor.60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Bal-timore, Maryland, USA, November 9-12, 2019