Constant-Time Dynamic $(\Delta+1)$-Coloring and Weight Approximation for Minimum Spanning Forest: Dynamic Algorithms Meet Property Testing

TL;DR

This paper introduces constant-time fully dynamic algorithms for graph coloring and weight approximation of minimum spanning forests, leveraging property testing techniques to surpass traditional logarithmic time bounds.

Contribution

It presents the first constant-time dynamic algorithms for proper coloring and approximate MSF weight, improving efficiency and establishing optimality bounds.

Findings

Constant-time algorithm for proper $( ext{Δ}+1)$-vertex coloring.

Deterministic approximation of MSF weight in constant time.

Randomized approximation algorithm with high probability and sub-logarithmic complexity.

Abstract

With few exceptions (namely, algorithms for maximal matching, $2$-approximate vertex cover, and certain constant-stretch spanners), all known fully dynamic algorithms in general graphs require (amortized) $\Omega(\log n)$ update/query time. Showing for the first time that techniques from property testing can lead to constant-time fully dynamic graph algorithms we prove the following results: (1) We give a fully dynamic (Las-Vegas style) algorithm with constant expected amortized time per update that maintains a proper $(\Delta+1)$-vertex coloring of a graph with maximum degree at most $\Delta$. This improves upon the previous $O(\log \Delta)$-time algorithm by Bhattacharya et al. (SODA 2018). We show that our result does not only have optimal running time, but is also optimal in the sense that already deciding whether a $\Delta$-coloring exists in a dynamically changing graph with maximum degree at most $\Delta$ takes $\Omega(\log n)$ time per operation. (2) We give two fully dynamic algorithms that maintain a $(1+\varepsilon)$-approximation of the weight $M$ of the minimum spanning forest of a graph $G$ with edges weights in $[1,W]$. Our deterministic algorithm takes $O({W^2 \log W}/{\varepsilon^3})$ worst-case time, which is constant if both $W$ and $\varepsilon$ are constant. This is somewhat surprising as a lower bound by Patrascu and Demaine (SIAM J. Comput. 2006) shows that it takes $\Omega(\log n)$ time per operation to maintain the exact weight of the MSF that holds even for $W=1$. Our randomized (Monte-Carlo style) algorithm works with high probability and runs in worst-case $O(\frac{1}{\varepsilon^4}\log^2(\frac{1}{\varepsilon}))$ time if $W= O({(m^*)^{1/3}}/{\log^3 n})$, where $m^*$ is the minimum number of edges in the graph throughout all the updates. It works even against an adaptive adversary.

Tables

Recolor($v$) 1. Run SetColor$\left(v\right)$ and obtain a new color $c$ (from ${ℬ}_v\cup {𝒰}_v\left(L\right)$). 2. Set $\chi \left(v\right)=c$. Update the data structures by the process $(\divideontimes )$ described in Appendix B.1. 3. If $c\in {𝒰}_v\left(L\right)$, (a) Find the unique neighbor $w\in L_v$ with $\chi \left(w\right)=c$. (b) Recolor($w$). 4. If $c\in {ℬ}_v$, then remove all the visited marks generated from the calls to SetColor.

SetColor($v$) 1. Mark $v$ as visited. Initialize sets $L_{v,\text{old}}:=\left\{v\right\}$ and $L_{v,\text{new}}:=\varnothing$. Scan the list $L_v$: for any $u\in L_v$, if it is marked as $\mathrm{𝐯𝐢𝐬𝐢𝐭𝐞𝐝}$, then add $u$ to $L_{v,\text{old}}$; otherwise (i.e., it is not marked), then add $u$ to $L_{v,\text{new}}$ and mark $u$ as $\mathrm{𝐯𝐢𝐬𝐢𝐭𝐞𝐝}$. 2. If (i.e., ), repeatedly sample a color uniformly at random from $\left[\Delta +1\right]$ until we get a color $c$ that is contained in ${ℬ}_v$, the set of blank colors for $v$ that have not been used by any neighbor of $v$. 3. Otherwise, we let denote the subset of vertices in $L_{v,\text{new}}$ with ranks at most the median of all ranks of vertices in $L_{v,\text{new}}$. We let denote the set of colors that each has been used by exactly one vertex in $L_{v,\text{new}}$ and additionally this vertex belongs to . Define and similarly. (a) If $\left|L_{v,\text{new}}\right|\ge \frac{1}{10}\left|L_v\right|$ or $L_v=\varnothing$, then we sample a random color $c$ from the set of the first elements of . (b) Else (i.e., $\left|L_{v,\text{old}}\right|>\frac{9}{10}\left|L_v\right|$) we sample a random color $c$ from the set of the first elements of . 4. Update the relevant data structures (i.e. of $v$ and its neighbors in $L_v$) and Return $c$.

Equations

$$\text{E}[T_v|r(v)\le \alpha ]=O(\alpha \Delta )$$

$$\text{E}[T_v|r(v)\le \alpha ,r(w)\forall w\in N(v)]=O(|L_v|)+O(\alpha \Delta )$$

$$\frac{\alpha \Delta }{8}\le \frac{\text{E}[|L_v|]}{2}\le |L_v|\le \frac{3\text{E}[|L_v|]}{2}\le \frac{3\alpha \Delta }{2}$$

$$\text{E}[r(v_{i_j+1})|r(v_0)\le \alpha ]\le \frac{\alpha }{2^j},\text{E}[|L_{v_{i_j}}||r(v_0)\le \alpha ]\le \frac{10\cdot \alpha \cdot \Delta }{2^{j-1}}.$$

$$\text{E}[r(v_{i_j+1})|r(v_0)\le \alpha ,r(w)\forall w\in N(v_0)]\le \frac{\alpha }{2^{j-1}},\text{E}[|L_{v_{i_j}}||r(v_0)\le \alpha ,r(w)\forall w\in N(v_0)]\le \frac{10\cdot \alpha \cdot \Delta }{2^{j-2}}.$$

$${\text{E}}_{\mathcal{R}(i_j)}[r(v_{i_j+1})]\le \frac{r(v_0)}{2^j}\text{ and }{\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j},\text{new}}|]\le \frac{r(v_0)\cdot \Delta }{2^{j-1}}.$$

$${\text{E}}_{\mathcal{R}(i_j)}[r(v_{i_j+1})|r(v_{i_j})]\le {\text{E}}_{\mathcal{R}(i_j)}[m_{v_{i_j},\text{new}}|r(v_{i_j})]\le \frac{r(v_{i_j})}{2},$$

$${\text{E}}_{\mathcal{R}(i_j)}[r(v_{i_j+1})]\le {\text{E}}_{r(v_{i_j})}[{\text{E}}_{\mathcal{R}(i_j)}[r(v_{i_j+1})|r(v_{i_j})]]$$

$${\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j},\text{new}}||r(v_{i_j})]\le r(v_{i_j})\cdot |N_{\text{new}}(v_{i_j})|\le r(v_{i_j})\cdot \Delta .$$

$${\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j},\text{new}}|]={\text{E}}_{r(v_{i_j})}[{\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j},\text{new}}||r(v_{i_j})]]\le {\text{E}}_{r(v_{i_j})}[r(v_{i_j})]\cdot \Delta \le \frac{r(v_0)\cdot \Delta }{2^{j-1}}.$$

$${\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j}}||r(v_0)\le \alpha ]$$

$${\text{E}}_{\mathcal{R}(i_j)}[r(v_{i_j+1})]\le \frac{r(v_{i_1})}{2^{j-1}}\text{ and }{\text{E}}_{\mathcal{R}(i_j)}[|L_{v_{i_j},\text{new}}|]\le \frac{r(v_{i_1})\cdot \Delta }{2^{j-2}}.$$

$$\Phi (-1):=0\text{ and }\Phi (i):=\sum _{k:k\le i}|\mathcal{F}(v_k,v_{i+1})|\forall i\ge 0,$$

$$\Phi (i)=\sum _{k:k\le i}|\mathcal{F}(v_k,v_{i+1})|$$

$$|L_{v_i}|\le (\Phi (i-1)-\Phi (i))\cdot \frac{20}{7}<3\cdot (\Phi (i-1)-\Phi (i)).$$

$$\sum _{\text{i: Step refalg:manyold}}|L_{v_i}|\le \sum _{\text{i: type III}}3(\Phi (i-1)-\Phi (i))$$

$$\le \sum _{\text{i: type I}}3(\Phi (i)-\Phi (i-1))$$

$$\sum _i|L_{v_i}|=\sum _{\text{i: type I}}|L_{v_i}|+\sum _{\text{i: type II}}|L_{v_i}|+\sum _{\text{i: type III}}|L_{v_i}|\le 3\sum _{\text{i: type I or II}}|L_{v_i}|=3\sum _j|L_{v_{i_j}}|$$

$$\text{E}[\sum _i|L_{v_i}||r(v)\le \alpha ]\le 3\cdot \text{E}[\sum _j|L_{v_{i_j}}||r(v)\le \alpha ]=O(\alpha \cdot \Delta \cdot \sum _j\frac{1}{2^j})=O(\alpha \Delta ).$$

$$\text{E}[\sum _i|L_{v_i}||r(v)\le \alpha ,r(w)\forall w\in N(v)]$$

$$\le 3\cdot |L_v|+3\cdot 10\cdot \alpha \cdot \Delta \cdot \sum _j\frac{1}{2^{j-2}}$$

$$M\le X:=n-c^{({\ell }_r)}\cdot (1+\frac{\epsilon }{2}{)}^r+\sum _{i=0}^{r-1}{\lambda }_i\cdot c^{({\ell }_i)}\le (1+\frac{\epsilon }{2})M.$$

$$|{\overline{c}}_j-c^{({\ell }_j)}|\le {\epsilon }^{\prime }\cdot T(G^{({\ell }_j)})=\frac{\epsilon }{4W}\cdot \mathrm{nis}(G),$$

$$O(\max \{1,\frac{\log (1/{\epsilon }^{\prime })\log (1/p)}{{\epsilon }^{\prime 3}{\mathrm{nis}}^{\ast }}\})$$

$$\max \{O(1),\sum _{j=1}^{r}O(\frac{W^3\log (W/\epsilon )\log (r/p^{\prime })}{{\epsilon }^3{\mathrm{nis}}^{\ast }})\}=O(\max \{1,\frac{W^3\log W\log (\frac{W}{\epsilon })\log (\frac{\log W}{\epsilon p^{\prime }})}{{\epsilon }^4{\mathrm{nis}}^{\ast }}\})$$

$$|\overline{c}-\mathrm{ncc}(G)|=|\overline{b}+n-\mathrm{nis}(G)-\mathrm{ncc}(G)|=|\overline{b}-\mathrm{ncc}(G_{\mathrm{nis}})|\le \frac{{\epsilon }^{\prime }\mathrm{nis}(G)}{4},$$

$$O(\max \{1,\frac{(1/{\epsilon }^2)\log (1/\epsilon )\log (1/p)}{\epsilon \Psi }\})=O(\max \{1,\frac{\log (1/{\epsilon }^{\prime })\log (1/p)}{{\epsilon }^{\prime 3}\Psi }\}).$$

$$O(\max \{1,\frac{\log (1/{\epsilon }^{\prime })\log (1/p)}{{\epsilon }^{\prime 3}{T}^{\ast }}\}).$$

$$|{\mathcal{M}}_v(L)|+|{\mathcal{B}}_v|+|{\mathcal{U}}_v(L)|=|{\mathcal{M}}_v(L)\cup {\mathcal{B}}_v\cup {\mathcal{U}}_v(L)|\ge |\mathcal{C}|-|H_v|=\Delta +1-|H_v|\ge 1+|L_v|.$$

$$2|{\mathcal{B}}_v|+|{\mathcal{U}}_v(L)|\ge 2+2|L_v|-|L_v|\ge 2+|L_v|$$

Full text

Constant-Time Dynamic $(\Delta+1)$-Coloring and Weight Approximation for Minimum Spanning Forest: Dynamic Algorithms Meet Property Testing

Monika Henzinger111University of Vienna, Faculty of Computer Science, Vienna, Austria. E-mail: monika.henzinger@univie.ac.at. The research leading to these results has received funding from the European Research Council under the European Union’s Seventh Framework Programme (FP/2007-2013) / ERC Grant Agreement no. 340506.

  

Pan Peng222Department of Computer Science, University of Sheffield, Sheffield, UK. Email: p.peng@sheffield.ac.uk.

With few exceptions (namely, algorithms for maximal matching, $2$-approximate vertex cover, and certain constant-stretch spanners), all known fully dynamic algorithms in general graphs require (amortized) $\Omega(\log n)$ update/query time. Showing for the first time that techniques from property testing can lead to constant-time fully dynamic graph algorithms we prove the following results:

(1) We give a fully dynamic (Las-Vegas style) algorithm with constant expected amortized time per update that maintains a proper $(\Delta+1)$-vertex coloring of a graph with maximum degree at most $\Delta$. This improves upon the previous $O(\log\Delta)$-time algorithm by Bhattacharya et al. (SODA 2018). We show that our result does not only have optimal running time, but is also optimal in the sense that already deciding whether a $\Delta$-coloring exists in a dynamically changing graph with maximum degree at most $\Delta$ takes $\Omega(\log n)$ time per operation.

(2) We give two fully dynamic algorithms that maintain a $(1+\varepsilon)$-approximation of the weight $M$ of the minimum spanning forest of a graph $G$ with edges weights in $[1,W]$. Our deterministic algorithm takes $O({W^{2}\log W}/{\varepsilon^{3}})$ worst-case time, which is constant if both $W$ and $\varepsilon$ are constant. This is somewhat surprising as a lower bound by Patrascu and Demaine (SIAM J. Comput. 2006) shows that it takes $\Omega(\log n)$ time per operation to maintain the exact weight of the MSF that holds even for $W=1$. Our randomized (Monte-Carlo style) algorithm works with high probability and runs in worst-case $O(\frac{1}{\varepsilon^{4}}\log^{2}(\frac{1}{\varepsilon}))$ time if $W=O({(m^{*})^{1/3}}/{\log^{3}n})$, where $m^{*}$ is the minimum number of edges in the graph throughout all the updates. It works even against an adaptive adversary.

1 Introduction

A (fully) dynamic graph algorithm is a data structure that provides information about a graph property while the graph is being modified by edge updates such as edge insertions or deletions. When designing a dynamic graph algorithm the goal is to minimize the time per update or query operation. The lower bounds of Patrascu and Demaine [PD06] showed that in the cell-probe model many fundamental graph properties, such as asking whether the graph is connected, require $\Omega(\log n)$ time per operation, where $n$ is the number of nodes in the graph. Their lower bound technique also gives logarithmic time lower bounds for further dynamic problems such as higher types of connectivity, planarity and bipartiteness testing, and minimum spanning forest, and it is an open research question for which other dynamic graph problems non-constant time lower bounds exist.

Furthermore, there are only very few graph problems for which it is known that no such lower bounds can exist. These are the following problems, which all have constant-time algorithms: maintaining (a) a maximal matching (randomized) [Sol16], (b) a $(2+\varepsilon)$-approximate vertex cover (deterministic) [BK19], and (c) a $(2k-1)$-stretch spanner of size $O(n^{1+\frac{1}{k}}\log^{2}n)$ for constant $k$ (randomized) [BKS12]. All these are amortized time bounds and all these algorithms maintain a sophisticated hierarchical graph decomposition, which makes them rather impractical.

Techniques from distributed, streaming, and online algorithms have been used in the past to design efficient dynamic graph algorithms (see also the Related Work Section in Section 1.3). However, we are not aware of any dynamic graph algorithm in general graphs that exploits techniques from sublinear-time algorithms and property testing and one goal of this paper is to push forward the study of the promising connection between these two fields. Intuitively, in both fields, dynamic graph algorithms and property testing, we try to find out information about a graph using as little (time) resources as possible and, thus, we want to probe only very few “places” in the graph. As we show this intuition can indeed be exploited to achieve new constant-time dynamic graph algorithms.

1.1 Our Contributions

Our first and main contribution is a new randomized333For randomized dynamic algorithms, we assume the (almost) standard oblivious adversary: the adversary who fixes the sequence of edge insertions and deletions is oblivious to the randomness in our algorithm. dynamic algorithm for vertex coloring. Given a graph let $\Delta$ be an upper bound on the maximum degree in the graph. A proper coloring assigns to each vertex an integer value, called color, such that the endpoints of every edge have a different color. A $(\Delta+1)$-vertex coloring is a proper coloring that uses only colors from the range $[1,\dots,\Delta+1]$. It was known that a proper $(\Delta+1)$-vertex coloring in a (static) graph with maximum degree at most $\Delta$ always exists and can be found in linear time by a simple greedy algorithm. Dynamically maintaining a proper $(\Delta+1)$-vertex coloring was investigated only very recently by Bhattacharya et al. [BCHN18], who observed a trivial algorithm with $O(\Delta)$ worst-case update time (which simply scans the whole neighborhood once an edge is inserted between two nodes of the same color), and gave a randomized algorithm444In [BCHN18], the authors also provided a deterministic algorithm that maintains a $(\Delta+o(\Delta))$-vertex coloring with $O(\textrm{poly}\log\Delta)$ amortized update time. for this problem with $O(\log\Delta)$ expected amortized time per operation. Note that if $\Delta$ is polynomial in $n$, their algorithm takes time $O(\log n)$. In this paper, we improve upon their algorithm and prove the following result. We call a dynamic graph $\Delta$-bounded if throughout the updates, the graph has maximum degree at most $\Delta$.

Theorem 1.1**.**

There exists a fully dynamic algorithm for maintaining a proper $(\Delta+1)$-vertex coloring for a $\Delta$-bounded graph with $O(1)$ expected amortized update time.

Apart from having optimal running time, our result is also optimal in the sense that deciding whether a proper coloring with only $\Delta$ colors exists in a dynamically changing graph (with maximum degree at most $\Delta$) takes at least $\Omega(\log n)$ time per operation, as we show in Appendix A.

Our second contribution is two new dynamic algorithms for maintaining the approximate weight of a minimum spanning forest (MSF). Given an edge-weighted graph $G$ an MSF is a subgraph of $G$ that forms a spanning forest and has minimum weight among all spanning forests of $G$. The weight of an MSF is the sum of the edge weights of the MSF. A $(1+\varepsilon)$-approximation of the weight $M$ of an MSF is a value $M^{\prime}$ such that $(1-\varepsilon)\cdot M\leq M^{\prime}\leq(1+\varepsilon)\cdot M$. We show that a $(1+\varepsilon)$-approximation of the weight of an MSF can be maintained deterministically in a graph with edge weights in the interval $[1,W]$ in worst-case time $O(W^{2}\log W/\varepsilon^{3})$ per operation. For constant $W$ and $\varepsilon$ this is a constant deterministic worst-case time bound. This result is somewhat surprising, as the lower bound of $\Omega(\log n)$ by [PD06] applies for maintaining the exact weight of an MSF even for $W=1$.

We also give a randomized dynamic algorithm that, with high probability, maintains a $(1+\varepsilon)$-approximation of the weight $M$ of the MSF of a dynamic graph in worst-case time $O({\log^{2}(1/{\varepsilon})}/{\varepsilon^{4}})$ if $W=O(\max\{1,{(m^{*})^{1/3}}/{\log^{3}n}\})$, where $m^{*}$ is the minimum number of edges in the graph throughout all the updates. This is useful if the graph always has $\omega(\textrm{poly}(\log n))$ edges. Interestingly, our algorithm works against an adaptive adversary, which is an adversary that sees the answers to all query operations before deciding which edge to update next.

Our algorithms (with constant $\varepsilon$ and small $W$) are much faster than the best known algorithms for maintaining the exact weight of an MSF: They assume only that $W$ is polynomial in $n$, but take $O(\log^{4}n/\log\log n)$ expected amortized time per operation [HRWN15] (that improves upon [HDLT01]) and $O(n^{o(1)})$ expected worst-case time per operation [NSWN17]. Furthermore, combining the techniques of [HK01] and of [KKM13], one can also maintain a spanning forest whose weight is a $(1+\varepsilon)$-approximate of the weight of an MSF with $O(\log^{4}n/\varepsilon)$ worst-case update time.

As we recently learnt, Bhattacharya et al. [BGK*+*] achieved a randomized dynamic algorithm for $(\Delta+1)$-vertex coloring with constant amortized update time independently.

1.2 Our Techniques

We use the following techniques in our algorithms.

(1) $(\Delta+1)$-vertex coloring. We first give a brief overview of the algorithm in [BCHN18] that maintains a proper $(\Delta+1)$-vertex coloring for a dynamic graph with maximum degree at most $\Delta$. First note that for edge deletion, there is no need to change an existing proper coloring, denoted by $\chi$. For an edge insertion $(u,v)$, if it does not cause a conflict, i.e., $\chi(u)\neq\chi(v)$, then the coloring remains unchanged. If a conflict occurs (i.e., $\chi(u)=\chi(v)$), then one needs to fix the coloring by recoloring one vertex from $\{u,v\}$, say $u$. Instead of scanning the whole neighborhood of $u$ to find the color (called a blank color) that has not been used by any of its neighbors, the algorithm in [BCHN18] tries to sample a color from the set that contains both blank colors and colors (called unique colors) that have been used by exactly one neighbor of $u$. It is observed in [BCHN18] that such a set has size $\Omega(\Delta)$, which guarantees that a future conflict edge incident to $u$ occurs with low probability (i.e., with probability at most $O(\frac{1}{\Delta})$). On the other hand, if a unique color is chosen, one needs to recolor the corresponding vertex $w$ (which is a neighbor of $u$), again, using a new color sampled from the set of blank and unique colors for $w$. This procedure might cause a cascade and even not terminate at all. The dynamic $(\Delta+1)$-vertex coloring algorithm of [BCHN18] resolves this problem by maintaining a hierarchical graph decomposition, and when recoloring a node it picks a color randomly out of all colors that are either (i) used by none of the neighbors or (ii) used by at most one of the neighbors on a lower level in the graph hierarchy. The resulting algorithm is then shown to having $O(\log\Delta)$ amortized update time for maintaining a proper coloring. However, maintaining such a hierarchical partition is not only complicated, but also inefficient, as it alone already takes $O(\log\Delta)$ amortized update time.

Now we briefly describe our main idea which leads to a constant-time dynamic coloring algorithm. We show that an approach based on assigning random ranks to vertices outperforms the graph-hierarchy based algorithm: During preprocessing each node $v$ is assigned a random rank $r(v)$ from $[0,1]$ and a random color (assuming as usual that the initial graph is empty). Let $L_{v}$ denote the set of neighbors of a node $v$ with rank lower than $r(v)$ and let $L_{v}^{\textrm{<}}$ denote the set of neighbors of $v$ whose rank is at most the median rank of the nodes in $L_{v}$. When recoloring $v$, we pick a color randomly out of all colors that are either (i) used by none of its neighbors (called blank colors) or (ii) by at most one neighbor in $L_{v}$ and this node belongs to $L_{v}^{\textrm{<}}$. (We show that there are always $\Omega(|L_{v}|)$ many such colors.) In case (ii) this neighbor $w$ must be recolored. This is done with a more refined recoloring procedure that additionally to the above information takes into account which nodes of $L_{w}$ also belong to $N(v)$, the neighborhood of $v$. It randomly samples a color out of the set which consists of (i) all blank colors and (ii) all colors which are used by exactly one node in $L_{w}$ and, depending on the size of the respective sets, either are used by a node in $L_{w,\textrm{new}}^{\textrm{<}}$, or by a node in $L_{w,\textrm{old}}^{\textrm{<}}$, where $L_{w,\textrm{new}}:=L_{w}\setminus N(v)$ and $L_{w,\textrm{old}}:=L_{w}\cap N(v)$. More specifically, if $L_{w,\textrm{new}}^{\textrm{<}}$ combined with the blank colors has size $\Omega(|L_{w}|)$, we sample from this set, otherwise from $L_{w,\textrm{old}}^{\textrm{<}}$ combined with the blank colors. This is necessary to guarantee that the new color is chosen randomly from a set of $\Omega(|L_{w}|)$ colors.

If the color of a node $y$ in $L_{w,\textrm{new}}^{\textrm{<}}$ or $L_{w,\textrm{old}}^{\textrm{<}}$ was chosen, $y$ will be recolored recursively taking $N(x)$ for all previously visited nodes $x$ into account. If $y$ was chosen from $L_{w,\textrm{new}}^{\textrm{<}}$, it is called a good vertex, otherwise a bad vertex. This results in a recoloring of nodes along a random path $P$ in the graph until a blank color is chosen (which is guaranteed to happen if a node $y$ with $L_{y}=\emptyset$ is reached) in total time $O(\sum_{y\in P}|L_{y}|)$.

However, even though the rank of the next node is at most the median rank of the lower-ranked neighbors of the previous node, (which, if there were no dependencies between the ranks of the nodes on $P$, would imply that the expected rank will halve in each step), the expected size of $L_{y}$ is not guaranteed to halve in each step. To deal with this we need to (a) introduce a novel potential function $\Phi$ based on the sizes of a suitable subset of $L_{y}$ for each $y$ on $P$ and (b) carefully analyze the expected number of lower-ranked neighbors of the nodes on $P$, dealing with dependencies that arise by the fact that two nodes on $P$ might share neighbors. More specifically, we show that, when traversing $P$ from an initial vertex $v$, at every good vertex the expected rank halves, while at every bad vertex $\Phi$ drops. As (i) $\Phi$ is always non-negative, (ii) $\Phi$ only increases at good vertices, and (iii) the drop of $\Phi$ gives an upper bound of the time spent at bad vertices, we can bound the total time for coloring all the vertices on $P$ by the total time spent at the good vertices on $P$. At the good vertices, however, the expected rank is halved. Due to our sampling routine picking colors from neighbors with at most median rank and with a careful analysis of the dependencies, we show that the total expected time at the good vertices on $P$, i.e. $O(\sum_{y\in P,y{\textrm{:good}}}|L_{y}|)$, forms a geometric series adding up to $O(\alpha\Delta)$, where $\alpha$ is the rank of the initial vertex $v$. Finally, we combine this bound with the fact that for many operations (such as all deletions and many insertions) no recoloring is necessary to show that the expected amortized time per update operation is constant. This depends crucially on the fact that the color of each node $v$ was picked uniformly at random from a set of $\Omega(|L_{v}|)$ many colors.

Note that the refined sampling routine as well as the analysis that combines a potential function analysis with a careful analysis of the expected size of the sets $L_{y}$ along a random path $P$ is novel. Furthermore, while the idea of assigning random ranks to nodes was used before in the area of property testing (see e.g. [NO08, HKNO09, YYI12, ORRR12]) and in dynamic distributed algorithms [CHHK16], this is, to the best of our knowledge, its first use in (centralized) dynamic graph algorithms for general graphs. The technique has the advantage that, unlike in a hierarchical graph decomposition where the ordering of nodes by levels might change and needs to be updated, the ordering of nodes by ranks is static and does not create update costs. However, it has the disadvantage that, unlike in the hierarchical graph decomposition of [BCHN18], (1) we do not have a worst-case upper bound on the number of nodes that are “lower” in the ordering and (2) the length of $P$, which is limited by the longest strictly decreasing path in the ordering, might be $\Theta(n)$ and not $\Theta(\log\Delta)$ in the worst case, as in [BCHN18]. We believe that this approach of assigning (static) random ranks to vertices instead of maintaining a hierarchical graph decomposition is of independent interest as it might lead to constant-time algorithms for other dynamic graph problems.

(2) $(1+\varepsilon)$-approximation for the weight of an MSF of a graph $G$. Both our deterministic and randomized algorithms for this problem use an approach developed in the area of property testing: Build an efficient algorithm for estimating the number of connected components (CCs) in a graph and apply it to suitable subgraphs of $G$ [CRT05, CS09, AGM12]. More specifically, we build constant-time dynamic algorithms that estimate the number of CCs with appropriate additive error, apply them to $O(\log W/\varepsilon)$ many subgraphs, and then use an extension of the formula in [CRT05] to disconnected graphs to estimate the weight of an MSF.

Though the above idea is quite simple, it is non-trivial to dynamically maintain the number CCs with the “right” additive error (see High-Level Ideas in Section 4.1). Furthermore, the techniques are very different from the fastest dynamic (exact) MSF algorithms: the algorithm of [HRWN15, HDLT01] maintains a hierarchical decomposition with $O(\log n)$ levels, the algorithm of [NSWN17] maintains a decomposition of the graph into expanders and a “remaining” part.

1.3 Other Related Work

Partially due to the $\Omega(\log n)$ lower bound for the fundamental problem of testing connectivity [PD06], a large amount of previous research on dynamic graph algorithms has focused on algorithms with polylogarithmic or super-polylogarithmic update time. Examples include testing $k$-edge (or vertex) connectivity (see e.g., [EGIN97, HDLT01, HK99]), maintaining minimum spanning tree (see e.g., [Fre83, EGIN97, HK99, HK97, HDLT01, HRWN15, KKM13, WN17, NS17, NSWN17]), and graph coloring [BM17, BCK*+*17, BCHN18, SW18, DHZ19]. There are also studies on partially dynamic graph algorithms, including incremental algorithms that only allow edge insertions, and decremental algorithms that only allow edge deletions throughout all the updates. In contrast to such studies, our work is focusing on fully dynamic algorithms, in which both edge insertions and deletions are allowed.

We remark that the connections of dynamic graph algorithms with other fields that concern “locality” has been exploited. Such examples include Solomon’s work on local algorithms for constructing bounded-degree sparsifiers, which lead to a dynamic algorithm for maintaining a $(1+\varepsilon)$-approximation of vertex cover with constant update time for any constant $\varepsilon>0$ in planar graphs [Sol18]. The classic sparsification technique for dynamic graph algorithms in some sense also makes uses of locality [EGIN97]. There is more work in dynamic graph algorithms that are explicitly or implicitly related to techniques from distributed computation (e.g., [BM17]), not to mention the area distributed dynamic graph algorithms (see e.g., [CHHK16]). However, the locality properties used in these techniques are different from ours (i.e., property testing techniques), as the corresponding static property testing algorithm not only just read the local neighborhood of vertices, but just read such neighborhoods of very few vertices, while still have provable performance guarantee of the global structure of graphs.

In the field of constant-time algorithms, an algorithm is given query access (e.g., to the adjacency list and/or adjacency matrix) to a fixed input graph (instead of a dynamic graph), and only makes a constant number queries to the graph. Examples include $(1+\varepsilon)$-approximating the weight of the MST [CRT05], approximating the number of connected components with additive error $\varepsilon n$ [CRT05, BKMT14], $(1,\varepsilon n)$-approximating555We use the term $(\alpha,\beta)$-approximation algorithm to denote an algorithm that approximates the objective with a guarantee of $\alpha\text{Opt}+\beta$, where Opt denotes the cost of an optimal solution. the size of maximal/maximum matching in bounded average graphs [NO08, YYI12], $(2,\varepsilon n)$-approximating the minimum vertex cover size [PR07, MR09, ORRR12], $(O(\log d),\varepsilon n)$-approximating the minimum dominating set size [PR07, NO08]. For $d$-bounded minor-free graphs, there are constant-time $(1,\varepsilon n)$-approximation algorithms for the size of minimum vertex cover, minimum dominating set and maximum independent set [HKNO09].

Recently, constant-time property testing and approximation algorithms have also been transformed to constant-space random order streaming algorithms [MMPS17, PS18, CFPS19]. However, these work concentrates mainly on the space complexity of the algorithms and assumes the edges come from a uniform random order (that only allows edge insertions), rather than an arbitrary edge sequence with both edge insertions and deletions as we are considering here. Sublinear-time algorithms for $(\Delta+1)$-vertex coloring in the graph streaming model, query access model and the massively parallel computation model have recently been studied by Assadi et al. [ACK19].

2 Preliminaries

A fully dynamic graph algorithm is an algorithm that maintains a graph property in a graph $G=(V,E)$ which is undergoing an arbitrary sequence of the following operations: 1) $\mathbf{Insert}$($u,v,w$): insert the edge $(u,v)$ with weight $w$ in $G$; 2) $\mathbf{Delete}$($u,v$): delete the edge $(u,v)$ from $G$. If the considered graph is unweighted, then the weight $w$ of an insertion is always set to be $1$. In the $(\Delta+1)$-vertex coloring problem the fully dynamic graph algorithm maintains after each update operation a proper $(\Delta+1)$-vertex coloring of the current graph, where $\Delta$ is the maximum degree of any vertex since the beginning of the sequence until now. When asked to perform a $\mathbf{Query}$($u$) operation, the algorithm returns the color of the given vertex $u$. In the $(1+\varepsilon)$-approximate MSF weight problem the fully dynamic algorithm maintains a value $M^{\prime}$ that is a $(1+\varepsilon)$ approximation of the weight of the MSF in the current graph and it can return this value in constant time. It returns $M^{\prime}$ when asked a $\mathbf{Query}$() operation.

3 Maintaining a Proper $(\Delta+1)$-Vertex Coloring

In this section, we give our constant-time dynamic algorithm and its analysis for maintaining a proper $(\Delta+1)$-coloring in a dynamic $\Delta$-bounded graph666Our algorithm can actually be extended to handle the case that the maximum degree $\Delta$ also changes. See Appendix B.4 for more discussions. and present the proof of Theorem 1.1. Recall that a dynamic graph is called to be $\Delta$-bounded if throughout the updates, it is $\Delta$-bounded. Given $\Delta$, let $\mathcal{C}:=\{1,\cdots,\Delta+1\}$ denote the set of colors. A coloring $\chi:V\rightarrow\mathcal{C}$ is proper if $\chi(u)\neq\chi(v)$ for any $(u,v)\in E$.

3.1 Data Structures and the Algorithm

Data structures.

We use the following data structures.

(1) We maintain a vertex coloring $\chi$ as an array such that $\chi(v)$ denotes the color of the current graph and guarantee that $\chi$ is a proper $(\Delta+1)$-vertex coloring after each update.

(2) For each vertex $v\in V$ we maintain: (a) its rank $r(v)$ that is chosen uniformly at random from $[0,1]$ during preprocessing; (b) its degree $\deg(v)$; (c) the last time stamp, denoted by $\tau_{v}$, at which $v$ was recolored; (d) two sets $L_{v}:=\{u:(u,v)\in E,r(u)<r(v)\},H_{v}:=\{u:(u,v)\in E,r(u)\geq r(v)\}$, which contain all neighbors of $v$ with ranks less than $v$, and all neighbors of $v$ with ranks at least $v$ (including $v$ itself), respectively; (e) the sizes of the previous two sets, i.e., $|L_{v}|$ and $|H_{v}|$. Note that $\deg(v)=|L_{v}\cup H_{v}|=|L_{v}|+|H_{v}|$.

For each vertex $v\in V$ note that every color of $\cal C$ is either (i) used by no neighbor of $v$ (and we call such color a blank color for $v$), (ii) used by a neighbor in $H_{v}$, or (iii) used by a neighbor in $L_{v}$ and by no neighbor in $H_{v}$. We call the corresponding sets of colors (i) $\mathcal{B}_{v}$, (ii) $\mathcal{C}_{v}(H)$, and (iii) $\mathcal{C}_{v}(L)$. We further partition $\mathcal{C}_{v}(L)$ into (iii.1) $\mathcal{U}_{v}(L)$, which denotes the set of unique colors for $v$ that have been used by exactly one vertex in $L_{v}$ and (iii.2) $\mathcal{M}_{v}(L)$, which denotes the set of colors that have been used by at least two vertices in $L_{v}$. Thus, $\mathcal{C}=\mathcal{C}_{v}(H)\ \dot{\cup}\ \mathcal{B}_{v}\ \dot{\cup}\ \mathcal{U}_{v}(L)\ \dot{\cup}\ \mathcal{M}_{v}(L)$. As it will be useful below, we finally define $\mathcal{C}_{v}(\overline{H}):=\mathcal{B}_{v}\cup\mathcal{U}_{v}(L)\cup\mathcal{M}_{v}(L)$. Note that for any fixed $v$, a color $c$ can appear in exactly one of the two sets $\mathcal{C}_{v}(H)$ and $\mathcal{C}_{v}(\overline{H})$.

(3) (i) For every vertex $v$, we maintain $\mathcal{C}_{v}(H)$ and $\mathcal{C}_{v}(\overline{H})$ in doubly linked lists. (ii) For each color $c\in\mathcal{C}$ and vertex $v\in V$, we keep the following information: (a) a pointer $p_{c,v}$ from $c$ to its position in either $\mathcal{C}_{v}(H)$ or $\mathcal{C}_{v}(\overline{H})$, depending on which list it belongs to; (b) a counter $\mu^{H}_{v}(c)$ such that $\mu^{H}_{v}(c)$ equals the number of neighbors in $H_{v}$ with color $c$ if $c\in\mathcal{C}_{v}(H)$; or equals [math] if $c\in\mathcal{C}_{v}(\overline{H})$. (iii) For any vertex $v$ and color $c\in\mathcal{C}$ we keep the pointer $p_{c,v}$ in a hash table $\mathcal{A}_{v}$ which is indexed by $c$. (iv) For any vertex $v$ and color $c\in\mathcal{C}_{v}(H)$, we maintain the pairs $(c,\mu^{H}_{v}(c))$ in a hash table $\mathcal{A}^{H}_{v}$ which is indexed by the pair $(v,c)$.

More precisely, we use the dynamic perfect hashing algorithm by Dietzfelbinger et al. [DKM*+*94], which takes amortized expected constant time per update and worst-case constant time for lookups. Alternatively we can get constant worst-case time for updates and lookups by spending time $O(n\Delta)$ during preprocessing to initialize suitable arrays. To simplify the presentation and since the randomness in the hash tables is independent of the randomness used by the algorithm otherwise, we will not mention the randomness introduced through the usage of hash tables in the following.

Initialization.

As the initial graph $G_{0}$ is empty, we initialize as follows: (1) For each vertex $u\in V$, sample a random number (called rank) $r(u)\in[0,1]$. (2) Color each vertex $u$ by a random color $\chi(u)\in\mathcal{C}=\{1,\cdots,\Delta+1\}$ and initialize all the data structures suitably. In particular, for each $u\in V$, we initialize $\mathcal{C}_{u}(H)$ to be the empty list and $\mathcal{C}_{u}(\overline{H})$ to be the doubly linked list containing all colors in $\mathcal{C}$. Note that the latter takes $O(n\Delta)$ time. In Appendix B.2, we show that the initialization time can be reduced to $O(n)$ while keeping constant expected amortized update time.

Time stamp reduction. Our algorithm does not use the actual values of the time stamps, only their relative order. Thus, every $\textrm{poly}(n)$ (say, $n^{4}$) number of updates we determine the order of the vertices according to the time stamps and set the time stamps of every vertex to equal its position in the order and set the current time stamp to $n+1$. This guarantees that we only need to use $O(\log n)$ bits to store the time stamp $\tau_{v}$ for each vertex $v$ and it does not affect the ordering of the time stamps. The cost of the recomputation of the time stamps is $O(n\log n)$ and can be amortized over all the operations that are performed between two updates, increasing their running time only by an additive constant.

Handling an edge deletion.

Note that the edge deletion $(u,v)$ does not lead to a violation of the current proper coloring, so we do not need to recolor any vertex. We only need to update the data structures corresponding to the two endpoints, for which we refer to Appendix B.1 for details.

Handling an edge insertion.

For an edge insertion $(u,v)$, we note that if $\chi(u)\neq\chi(v)$ before the insertion, then we only need to update the basic data structures corresponding to the two endpoints. If $\chi(u)=\chi(v)$, i.e, the current coloring $\chi$ is not proper any more, then we need to recolor one vertex $w\in\{u,v\}$ as well as to update the relevant data structures. We always recolor the vertex that was colored last, i.e., the one with larger $\tau_{w}$. Wlog, we assume this vertex is $v$. Then we invoke a subroutine Recolor($v$) to recolor $v$ and potentially some other lower level vertices, and update the corresponding data structures. More precisely, we will first update $H_{u},L_{u},H_{v},L_{v}$ and their sizes trivially in constant time. Then if $\chi(u)\neq\chi(v)$, we update the data structures corresponding to $u,v$ as described in Appendix B.1.

If $\chi(u)=\chi(v)$, and w.l.o.g., suppose that $\tau_{v}>\tau_{u}$, then we recolor $v$ by invoking the procedure Recolor($v$) below, where $\mathcal{U}_{v}(L)$ denotes the set of colors that have been used by exactly one vertex in $L_{v}$.

Note that the recursive calls will eventually terminate as for every recursive call Recolor($w$) in Step 3 it holds that $r(w)<r(v)$. Furthermore, no recursive call will be performed when $L_{v}=\emptyset$ as it implies that $\mathcal{U}_{v}(L)=\emptyset$. The subroutine ReColor($v$) calls the following subroutine Setcolor($v$).

3.2 The Analysis

Next we prove Theorem 1.1. Let $v_{0}:=v$ be the vertex that needs to be recolored after an insertion and let $v_{1},v_{2},\cdots,v_{\ell}$ denote the vertices on which the recursive calls of Recolor() were executed. We call $v_{0},v_{1},\cdots,v_{\ell}$ the recoloring path originated from $v$. We first show that the expected total time for all calls Recolor$(v_{i})$ is $O(1+\sum_{i=0}^{\ell}|L_{v_{i}}|)$. Then we bound the expected value of this sum. We have the following lemma.

Lemma 3.1**.**

Subroutine SetColor$(v)$ can be implemented to run in $O(1+|L_{v}|)$ expected time, where the expectation is not over the random choices of ranks or colors at Step 3, but comes from the use of hash tables and sampling colors at Step 2. For any recoloring path $v_{0},v_{1},\cdots,v_{\ell}$, the expected time for subroutine Recolor($u$) for any $u\in\{v_{1},\dots,v_{l}\}$ excluding the recursive calls to Recolor() is $O(|L_{u}|)$ if $u\neq v_{\ell}$, and is $O(1+\sum_{i=0}^{\ell}|L_{v_{i}}|)$ if $u=v_{\ell}$.

Proof.

Recall that we store $L_{v}$, $\mathcal{C}_{v}(H)$, and $\mathcal{C}_{v}(\overline{H})$ for every vertex $v$. We use them to build all the sets needed in SetColor$(v)$. First we use an array $R_{v,L_{\textrm{new}}}$ (resp. $R_{v,L_{\textrm{old}}}$) to store ranks of vertices in $L_{v,\textrm{new}}$ (resp. $L_{v,\textrm{old}}$), and then find the median $m_{v,{\textrm{new}}}$ (resp. $m_{v,L_{\textrm{old}}}$) of the set of ranks of vertices in $L_{v,\textrm{new}}$ (resp. $L_{v,\textrm{old}}$) deterministically in $O(|R_{v,L_{\textrm{new}}}|)=O(|L_{v}|)$ time [BFP*+*73]. Traversing $L_{v}$ again (and using an empty array of length $\Delta$ that we clean again after this step) we compute (1) the sets $\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{<}})$ and $\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{<}})$ of colors that contain all colors that have been used by exactly one vertex in $L_{v,\textrm{new}}^{\textrm{<}}$, and by exactly one vertex in $L_{v,\textrm{old}}^{\textrm{<}}$, respectively, and (2) the sets $\mathcal{M}_{v}(L)$ of colors that contain all colors that have been used by at least two vertices in $L_{v}$. Note that $\mathcal{U}_{v}(L)=\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{<}})\cup\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{<}})$, and, thus, it can be computed by copying these lists. All these lists have size $O(|L_{v}|)$ and, thus, all these steps take time $O(|L_{v}|)$.

We will keep the sets $\mathcal{M}_{v}(L)$, $\mathcal{U}_{v}(L)$, $\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{<}})$, $\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{<}})$ in four separate lists and build hash tables for these sets with pointers to their positions in the lists. Next we delete all colors in $\mathcal{M}_{v}(L)\cup\mathcal{U}_{v}(L)$ from the list $\mathcal{C}_{v}(\overline{H})$ and the resulting list will be $\mathcal{B}_{v}$. Note that the hash tables can be implemented in time linear in the size of corresponding sets, and each lookup (i.e., check if an element is in the set) takes constant worst-case time [DKM*+*94]. This completes the building of the data structure before Step 1.

Recall that $|L_{v}|+|H_{v}|=\deg(v)$. Then for Step 2, if $\deg(v)<\frac{\Delta}{2}$, we know that $|\mathcal{B}_{v}|>\Delta-\frac{\Delta}{2}=\frac{\Delta}{2}$. Thus, a randomly sampled color from $[\Delta+1]$ belongs to $\mathcal{B}_{v}$ with probability at least $1/2$, which implies that in $O(1)$ expected time, we will sample a color $c$ from $\mathcal{B}_{v}$. Note that a color $c$ belongs to $\mathcal{B}_{v}$ if and only if $c$ is not contained in $\mathcal{M}_{v}(L)\cup\mathcal{U}_{v}(L)\cup\mathcal{C}_{v}(H)$, which can be checked by using the hash tables for $\mathcal{M}_{v}(L),$ for $\mathcal{U}_{v}(L)$ and the hash table $\mathcal{A}^{H}_{v}$.

All the other steps only write, read and/or delete lists or hash tables of size proportional to $|L_{v}|$ or $|\mathcal{M}_{v}(L)\cup\mathcal{U}_{v}(L)|$, which is at most $|L_{v}|$. Though the list $\mathcal{B}_{v}\cup\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{<}})$ might have size much larger than $|L_{v,\textrm{new}}^{\textrm{<}}|$, it suffices to read at most $|L_{v,\textrm{new}}^{\textrm{<}}|$ elements from it in Step 3 (similar for $\mathcal{B}_{v}\cup\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{<}})$ versus $|{L_{v,\textrm{old}}^{\textrm{<}}}|$). In Step 4, to update the relevant data structures, we add all colors in $\mathcal{M}_{v}(L)\cup\mathcal{U}_{v}(L)$ back to the list $\mathcal{B}_{v}$ to construct $\mathcal{C}_{v}(\overline{H})$.

To analyze the running time of Recolor($u$) (apart from the recursive calls), for any $u\in v_{0},v_{1},\dots,v_{\ell}$, note that apart from calling Setcolor($u$), Recolor updates the data structures, determines the neighbor $w$ that needs to be recolored next (if any) and if no such neighbor $w$ exists, i.e. if $c$ is a blank color and $u$ is the last vertex of the recoloring path, then it unmarks all vertices that were marked by all the calls to Setcolor on the recoloring path. For this Setcolor has stored all the marked vertices on a list, which it returns to Recolor. This list is then used by recolor to unmark these vertices. The time to update the data structures is constant expected time (the expectation arises due to the use of hash tables) to update its own data structure and $O(|L_{u}|)$ to update the data structures of its lower neighbors. Determining $w$ requires $O(|L_{u}|)$ time, as all lower neighbors of $u$ have to be checked. Finally, Recolor($u$) for the last vertex $u=v_{\ell}$ on the recoloring path takes expected time $O(1+\sum_{i}|L_{v_{i}}|)$ as it unmarks all vertices on the recoloring path and their neighbors. ∎

Throughout the process we have two different types of randomness: one for sampling the ranks for the vertices and the other for sampling the colors. These two types of randomness are independent. Furthermore, only the very last vertex $v_{\ell}$ on the recoloring path $P=v_{0},v_{1},\cdots,v_{\ell}$ can satisfy the condition of Step 2 in SetColor, as once the condition is satisfied, we will sample a blank color which will not cause any further recursive calls. Thus, for all vertices on $P$, with the possible exception of $v_{\ell}$, Step 3 will be executed. We call a vertex $w$ with $\deg(w)<\frac{\Delta}{2}$ a low degree vertex. Note that for a low degree vertex $w$, SetColor($w$) executes Step 2 and takes $O(1)$ expected time, as with probability at least $1/2$ a randomly sampled color will be blank. In the following, we consider the expected time $T_{v}$ of recoloring $P$ that excludes the time of recoloring any low degree vertex (which, if exists, must be the last vertex on $P$). We first present a key property regarding the expected running time for recoloring a vertex $v$. Let $N(v)$ denote the set of all neighbors of $v$ in the current graph.

Lemma 3.2**.**

Let $G$ denote the current graph. For any vertex $v$ with rank $r(v)\leq\alpha$, the expected running time $T_{v}$ (over the randomness of choosing ranks of other vertices) is

[TABLE]

Furthermore, conditioned on ranks of vertices in $N(v)$ and $r(v)\leq\alpha$, it holds that the expected running time $T_{v}$ (over the randomness of sampling ranks of $V\setminus(N(v)\cup\{v\})$) is

[TABLE]

The proof of the above lemma is deferred to Section 3.2.1. We will also need the following lemma regarding the size of the sampled color set. The proof of the lemma follows from a more refined analysis of the proof of Claim 3.1 in [BCHN18] and can be found in Appendix B.3.

Lemma 3.3**.**

Let $v$ be any vertex that needs to be recolored. Let $s$ denote the size of the set of colors that the algorithm samples from in order to choose a new color for $v$. Then it holds that 1) if $|L_{v}|+|H_{v}|<\frac{\Delta}{2}$, then $s\geq\frac{\Delta}{2}+1$; 2) otherwise, $s\geq\frac{1}{100}|L_{v}|+1$.

With the lemmas above, we are ready to prove Theorem 1.1.

Proof of Theorem 1.1.

Note that an edge deletion does not lead to the recoloring of any vertex. Let us consider an insertion $(u,v)$. If $\chi(u)\neq\chi(v)$, we do not need to recolor any vertex. Otherwise, we need to recolor one vertex from $\{u,v\}$. Suppose w.l.o.g. that $\tau_{v}>\tau_{u}$, where $\tau_{u}$ denotes the last time that $u$ has been recolored. This implies that $v$ is recolored at the current time step, which be denote by $\tau$. We will invoke Recolor($v$) to recolor $v$. Recall that we let $T_{v}$ denote the running time of calling Recolor($v$), including all the recursive calls to Recolor, while excluding the time of recoloring any low degree vertex (i.e. a vertex where SetColor($w$) executed Step 2) and on the recoloring path originated from $v$ (which, if exists, must be the last vertex on the path). If the last vertex is indeed a low degree vertex, then the expected total running time (over all sources of randomness) of Recolor($v$) will be $\textrm{E}[T_{v}]+O(1)$, where the expectation $\textrm{E}[T_{v}]$ in turn is over the randomness of sampling ranks of all vertices; otherwise, the expected total running time (over all sources of randomness) of Recolor($v$) will be $\textrm{E}[T_{v}]$. Let $\alpha_{0}=\frac{4C\log\Delta}{\Delta}$ for some constant $C\geq 1$. Now we consider two cases:

Case I: $r(v)\leq\alpha_{0}$. First we note that this case happens with probability at most $\alpha_{0}$ as $r(v)$ is chosen uniformly at random from $[0,1]$. Furthermore, by Lemma 3.2, conditioned on the event that $r(v)\leq\alpha_{0}$, the expected time of the subroutine Recolor($v$) is $\textrm{E}[T_{v}|r(v)\leq\alpha_{0}]=O(\alpha_{0}\Delta)$, where the expectation is taken over the randomness of choosing ranks of all other vertices except $v$. Therefore, the expected time of Recolor($v$) (over the randomness of choosing ranks of all vertices) is at most $\alpha_{0}\cdot O(\alpha_{0}\Delta)=O(\alpha_{0}^{2}\Delta)=O(\frac{\log^{2}\Delta}{\Delta})=O(1)$.

Case II: $r(v)>\alpha_{0}$. Let $r(v)=\alpha$. Conditioned on the event that $r(v)=\alpha$, by Lemma 3.2, the expected running time (over the randomness of choosing ranks of other vertices) of Recolor($v$) at time $\tau$ is $O(\alpha\Delta)$.

We let $L_{v}$ and $L^{\prime}_{v}$ denote the set of neighbors of $v$ with ranks lower than $v$ in the graph at (current) time $\tau$ and at time $\tau_{v}$, (the latest time that $v$ was recolored), respectively. We define $H_{v},H^{\prime}_{v}$ similarly. We let $\deg(v)=|L_{v}\cup H_{v}|$ and $\deg^{\prime}(v)=|L^{\prime}_{v}\cup H^{\prime}_{v}|$ denote the degree of $v$ at time $\tau$ and $\tau_{v}$, respectively.

Case (a): $\deg^{\prime}(v)<\Delta/2$. In this case, we know that at time $\tau_{v}$, we will sample a color from the set of blank colors $\mathcal{B}(v)$, which has size at least $\Delta/2$. Thus, the probability that we sampled the color $\chi(u)$ is at most $2/\Delta$. On the other hand, at time $\tau$, we will spend at most $O(\alpha\Delta)=O(\Delta)$ expected time (over the randomness of sampling ranks of vertices in $V\setminus\{v\}$). Thus, the expected time (over the randomness of sampling ranks and of sampling colors at time $\tau_{v}$) we spent on recoloring $v$ at time $\tau$ is $O(\frac{1}{\Delta}\cdot\Delta)=O(1)$.

Case (b): $\deg^{\prime}(v)\geq\Delta/2$. We now consider two sub-cases.

Case (b1): If $\deg(v)<\Delta/4$, then there must have been at least $\deg^{\prime}(v)/2=\Omega(\Delta)$ deletions of edges incident to $v$ between $\tau_{v}$ and $\tau$. We can recolor $v$ at time $\tau$ in expected $O(\alpha\Delta)=O(\Delta)$ time. We charge this time to the updates incident to $v$ between $\tau_{v}$ and $\tau$. Note that each update is only charged twice in this way, once from each endpoint, adding a constant amount of work to each deletion.

Case (b2): If $\deg(v)\geq\Delta/4$, then $\textrm{E}[|L_{v}|]=\alpha\deg(v)\geq\alpha\Delta/4\geq\frac{\alpha_{0}\Delta}{4}\geq C\log\Delta$ for some constant $C\geq 1$ and $\textrm{E}[|L_{v}|]=\alpha\deg(v)\leq\alpha\Delta$. Then over the randomness of sampling ranks for vertices in $N(v)$, it follows from a Chernoff bound that with probability at least $1-\frac{1}{\Delta}$, $\frac{\textrm{E}[|L_{v}|]}{2}\leq|L_{v}|\leq\frac{3\textrm{E}[|L_{v}|]}{2}$, which implies that with probability at least $1-1/\Delta$ it holds that

[TABLE]

By inequality (2) in Lemma 3.2, over the randomness of sampling ranks for $V\setminus(N(v)\cup\{v\})$, the expected work for recoloring $v$ at time $\tau$ is $O(|L_{v}|)+O(\alpha\Delta)=O(\alpha\Delta)$. Then the work for recoloring is $O(\Delta)$ as $|L_{v}|\leq\Delta$. Thus the expected work of this case is $\frac{1}{\Delta}\cdot O(\Delta)=O(1)$.

Next we analyze the case that the above inequalities hold and further distinguish two sub-cases.

Case (b2-1): If $|L_{v}\triangle L^{\prime}_{v}|>\frac{1}{10}|L_{v}|$, then there must have been at least $\frac{1}{10}|L_{v}|=\Theta(\alpha\Delta)$ edge updates incident to $v$ between $\tau_{v}$ and $\tau$. By the same argument as above we can amortize the expected work of $O(\alpha\Delta)$ over these edge updates, charging each edge update at most twice. This adds an expected amortized cost of $O(1)$ to each update.

Case (b2-2): If $|L_{v}\triangle L^{\prime}_{v}|\leq\frac{1}{10}|L_{v}|$, then it holds that $|L^{\prime}_{v}|\geq|L_{v}|-|L_{v}\triangle L^{\prime}_{v}|\geq\frac{9}{10}|L_{v}|$. By Lemma 3.3, $\chi(v)$ was picked at time $\tau_{v}$ from a set of $\Omega(|L^{\prime}_{v}|)$ many colors. Thus, the probability that we picked the color $\chi(u)$ at time $\tau_{v}$ is at most $O(\frac{1}{|L^{\prime}_{v}|})=O(\frac{1}{|L_{v}|})$. As the expected work at time $\tau$ is at most $O(\alpha\Delta)=O(|L_{v}|)$ (with the expectation over randomness of sampling ranks), the expected amortized update time is $O(\frac{1}{|L_{v}|})\cdot O(|L_{v}|)=O(1)$.

This completes the proof of the theorem. ∎

3.2.1 Bounding the Expected Work per Recoloring: Proof of Lemma 3.2.

Let $v_{0},v_{1},\cdots$ be the vertices on the recoloring path after an insertion. By Lemma 3.1 the total expected time for all calls Recolor($v_{i}$) is $O(1+\sum_{i\geq 0}|L_{v_{i}}|)$. Recall that the running time $T_{v}$ excludes the time spent on recoloring a low degree vertex (and a low degree vertex can only be the last vertex of a recoloring path). Thus, for all vertices $v_{i}$ that contribute to $T_{v}$ only Step 3a or Step 3b of SetColor can occur. Let $v_{i_{0}}=v_{0},v_{i_{1}},v_{v_{2}},\cdots$ be the vertices for which Step 3a occurred during Setcolor($v$), which we call good vertices. We bound the expected value of ranks of good vertices and the expected size of the lower-ranked neighborhood of these vertices in the following lemma. Note that the expectations are taken over the randomness for sampling ranks of vertices, whose ranks are not in the conditioned events.

Lemma 3.4**.**

For any $j\geq 0$, it holds that

[TABLE]

Furthermore, for any $j\geq 1$, it holds that

[TABLE]

Proof.

To prove the lemma, we use the principle of deferred decisions: Instead of sampling the ranks for all vertices (independently and uniformly at random from $[0,1]$) at the very beginning, we sample the ranks of vertices sequentially by the following random process:

Starting from $v_{0}$ with rank $r(v_{0})$, we sample all the ranks of vertices in $N(v_{0})$. We will then choose $v_{1}$ as described in the algorithm Recolor (if a non blank color has been sampled). Now for each $i\geq 1$, we note that the ranks of all the vertices in $N_{\textrm{old}}(v_{i}):=N(v_{i})\cap(\cup_{j<i}N(v_{j})\cup\{v_{0}\})$ have already been sampled, and then we only need to sample (independently and uniformly at random from $[0,1]$) the ranks for all vertices in $N_{\textrm{new}}(v_{i}):=N(v_{i})\setminus N_{\textrm{old}}(v_{i}).$ In this case, we say that the ranks of vertices in $N_{\textrm{new}}(v_{i})$ are sampled when we are exploring $v_{i}$. Then we will choose $v_{i+1}$ in the algorithm Recolor (if a non blank color has been sampled). We iterate the above process until Recolor has sampled a blank color.

For any $i$, we call $N_{\textrm{new}}(v_{i})$ the free neighbors of $v_{i}$ with respect to $v_{0},v_{1},\cdots,v_{i-1}$. In particular, $N_{\textrm{new}}(v_{0})=N(v_{0})$ and $N(v_{i})=N_{\textrm{new}}(v_{i})\dot{\cup}N_{\textrm{old}}(v_{i})$. Now a key observation is that

• $(\star)$

for any vertex $v_{i}$, it holds that $L_{v_{i},\textrm{new}}$ (as defined in the algorithm SetColor($v_{i}$)) is entirely determined by the ranks of the vertices $N_{\textrm{new}}(v_{i})$ and is independent of the randomness for sampling ranks of $N_{\textrm{old}}(v_{i})$.

This is true since $L_{v_{i},\textrm{new}}$ contains all the neighbors of $v_{i}$ with ranks less than $r(v_{i})$ and have not been visited so far: for any vertex in $N_{\textrm{old}}(v_{i})$, either its rank is higher than $v_{i}$, or its rank is less than $v_{i}$ and it has been marked as visited before we invoke SetColor($v_{i}$).

We first prove the first part of the lemma. We assume for now that $r(v_{0})$ is fixed and we denote by $\mathcal{R}{(i_{j})}$ the randomness of sampling ranks for vertices in $N_{\textrm{new}}(v_{i_{j}})$. We will prove by induction on the index $j$ that

[TABLE]

Note that this holds for $j=0$ since $i_{0}=0$, $r(v_{1})\leq r(v_{0})$, $L_{v_{i_{0}},\textrm{new}}=L_{v_{0}}$, and $\textrm{E}_{\mathcal{R}{(0)}}[|L_{v_{0}}|]=r(v_{0})\cdot|N(v_{0})|\leq r(v_{0})\cdot\Delta$. Next we assume it holds for $j-1$, and prove it also holds for $j$. By the definition of the good vertex $v_{i_{j}}$, we know that $v_{i_{j}+1}\in L_{v_{i_{j}}}$, and that the rank of $v_{i_{j}+1}$ is at most the median, denoted by $m_{v_{i_{j}},{\textrm{new}}}$, of all the ranks of vertices in $L_{v_{i_{j}},\textrm{new}}$, which in turn consists of all vertices in $N_{\textrm{new}}(v_{i_{j}})$ with rank not larger than $r(v_{i_{j}})$. Furthermore, by the observation $(\star)$, the rank of $r(v_{i_{j}+1})$ depends only on $r(v_{i_{j}})$ and the ranks in $N_{\textrm{new}}(v_{i_{j}})$. This implies that

[TABLE]

where the last inequality follows from the fact that $m_{v_{i_{j}},{\textrm{new}}}$ is the median of a set of numbers chosen independently and uniformly at random from $[0,1]$, conditioned on that they are at most $r(v_{i_{j}})$ (see e.g., Lemma 8.2 and 8.3 in [MU05]). Since $r(v_{i_{j}})\leq r(v_{(i_{j-1})+1})$ in all cases and, by the induction assumption, $\textrm{E}_{\mathcal{R}{(i_{j-1})}}[r(v_{(i_{j-1})+1})]\leq\frac{r(v_{0})}{2^{j-1}}$, it holds that

[TABLE]

Furthermore, for any $j\geq 0$, by the observation $(\star)$, $L_{v_{i_{j}},\textrm{new}}$ depends only on $r(v_{i_{j}})$ and ranks in $N_{\textrm{new}}(v_{i_{j}})$. Thus

[TABLE]

This further implies that

[TABLE]

Now let us no longer assume that $r(v_{0})$ is fixed, but instead condition on the event that $r(v_{0})\leq\alpha$. Then it follows that $\textrm{E}_{\mathcal{R}{(i_{j})}}[r(v_{i_{j}+1})|r(v_{0})\leq\alpha]\leq\frac{\alpha}{2^{j}}\text{ and }\textrm{E}_{\mathcal{R}{(i_{j})}}[|L_{v_{i_{j}},\textrm{new}}|\ |r(v_{0})\leq\alpha]\leq\frac{\alpha\cdot\Delta}{2^{j-1}}.$

Finally, by the definition of good vertices, it holds that $|L_{v_{i_{j}},\textrm{new}}|\geq\frac{1}{10}|L_{v_{i_{j}}}|$. This implies that

[TABLE]

This completes the proof of the first part of the lemma.

For the “Furthermore” part of the lemma, the analysis is similar as above. Now we start with the assumption that $r(v_{0}),r(w)\forall w\in N(v_{0})$ are fixed. Note that $v_{i_{1}}\in N(v_{0})$, which implies that $r(v_{i_{1}})$ is also fixed. We will then prove by induction on the index $j$ that

[TABLE]

In the base case $j=1$, the above two inequalities hold as $r(v_{i_{1}+1})\leq r(v_{i_{1}})$ and $\textrm{E}_{\mathcal{R}{(i_{1})}}[|L_{v_{i_{1}},\textrm{new}}|]=r(v_{i_{1}})\cdot|N_{\textrm{new}}(v_{i_{1}})|\leq r(v_{i_{1}})\cdot\Delta$. The inductive step from case $j-1$ to $j$ can be then proven in the same way as we proved Inequalities (3). Then instead of assuming that $r(v_{0}),r(w)\forall w\in N(v_{0})$, we condition on the event that $r(v_{0})\leq\alpha,r(w)\forall w\in N(v_{0})$, which directly implies that $r(v_{i_{1}})\leq\alpha$. Then it follows that $\textrm{E}_{\mathcal{R}{(i_{j})}}[r(v_{i_{j}+1})|r(v_{0})\leq\alpha,r(w)\forall w\in N(v_{0})]\leq\frac{\alpha}{2^{j-1}}\text{ and }\textrm{E}_{\mathcal{R}{(i_{j})}}[|L_{v_{i_{j}},\textrm{new}}|\ |r(v_{0})\leq\alpha,r(w)\forall w\in N(v_{0})]\leq\frac{\alpha\cdot\Delta}{2^{j-2}}.$ Finally, by the definition of good vertices, $|L_{v_{i_{j}},\textrm{new}}|\geq\frac{1}{10}|L_{v_{i_{j}}}|$, which implies that $\textrm{E}_{\mathcal{R}{(i_{j})}}[|L_{v_{i_{j}}}|\ |r(v_{0})\leq\alpha,r(w)\forall w\in N(v_{0})]\leq 10\cdot\textrm{E}_{\mathcal{R}{(i_{j})}}[|L_{v_{i_{j}},\textrm{new}}|\ |r(v_{0})\leq\alpha,r(w)\forall w\in N(v_{0})]\leq\frac{10\alpha\cdot\Delta}{2^{j-2}}.$ This completes the “Furthermore” part of the lemma. ∎

Now we relate the total work to the work incurred by Step 3a. Note that the total work $T_{v}$ is proportional to the sum of sizes of all lower-ranked neighborhoods of $v_{0},v_{1},\dots$. We will prove the following lemma, which implies that the total work of recoloring $v$ is at most a constant factor of the total work for recoloring all the good vertices on the recoloring path.

Lemma 3.5**.**

It holds that \sum_{i}|L_{v_{i}}|\leq 3\sum_{\textrm{i:v_{i} is good}}|L_{v_{i}}|=3\sum_{j}|L_{v_{i_{j}}}|.

Proof.

We first introduce the following definition. For any $i$ and $k<i$, we let ${\mathcal{F}}(v_{k},v_{i})$ denote the set of vertices whose ranks are less than $r(v_{i})$, and are sampled when we are exploring $v_{k}$, i.e., ${\mathcal{F}}(v_{k},v_{i})=\{w:w\in N_{\textrm{new}}(v_{k}),r(w)<r(v_{i})\}$. Note that as $r(v_{i+1})<r(v_{i})$, it always holds that for any $0\leq k<i$, ${\mathcal{F}}(v_{k},v_{i+1})\subseteq{\mathcal{F}}(v_{k},v_{i}).$ Now we define the following potential function $\Phi$:

[TABLE]

We have the following claim regarding the potential functions.

Claim 3.6**.**

For any $i\leq 0$, $\Phi(i)\geq 0$. Furthermore, if $v_{i}$ is a good vertex, then $\Phi(i)-\Phi(i-1)\leq|L_{v_{i}}|/2$, otherwise $\Phi(i)-\Phi(i-1)\leq-7|L_{v_{i}}|/20.$

Proof.

Note that if Step 3a in subroutine SetColor is executed at vertex $v_{i}$, i.e., $v_{i}$ is good, then the potential $\Phi(i)$ might be larger or smaller than $\Phi(i-1)$. If $v_{i}$ is good then $|{\mathcal{F}}(v_{i},v_{i+1})|\leq\frac{|L_{v_{i},\textrm{new}}^{\textrm{<}}|}{2}$ by the fact that $r(v_{i+1})$ is at most the median rank in $L_{v_{i},\textrm{new}}^{\textrm{<}}$. Furthermore, it holds that

[TABLE]

Now suppose that Step 3b is executed at vertex $v_{i}$, i.e., $v_{i}$ is not good. Since $v_{i+1}$ is a vertex from the lower half of the old lower neighbors of $v_{i}$ (i.e., $v_{i+1}\in L_{v_{i},\textrm{old}}^{\textrm{<}}\subseteq\cup_{k<i}{\mathcal{F}}(v_{k},v_{i})\cap L_{v_{i},\textrm{old}}$), we have that to obtain the set $\cup_{k<i}{\mathcal{F}}(v_{k},v_{i+1})$ from the set $\cup_{k<i}{\mathcal{F}}(v_{k},v_{i})$, we need to remove at least $\frac{1}{2}|L_{v_{i},\textrm{old}}|\geq\frac{1}{2}(1-\frac{1}{10})|L_{v_{i}}|$ vertices. Furthermore, ${\mathcal{F}}(v_{i},v_{i+1})$ can contain at most $|L_{v_{i},\textrm{new}}|\leq\frac{1}{10}|L_{v_{i}}|$ vertices. This implies that

[TABLE]

∎

Now we distinguish three types of indices. We call an index $i$, a type I index, if Step 3a occurred during Setcolor($v$) and $\Phi(i)-\Phi(i-1)\geq 0.$ By Claim 3.6 it holds that for such an index $i$, $|L_{v_{i}}|\geq 2(\Phi(i)-\Phi({i-1})).$ We call $i$ a type II index, if Step 3a occurred during Setcolor($v$) and $\Phi(i)-\Phi(i-1)\leq 0.$ It holds that for such an index $i$ (as for any index), $|L_{v_{i}}|\geq 0$. We call $i$ a type III index, if Step 3b occurred during Setcolor($v$), i.e. $v_{i}$ is not a good vertex. By Claim 3.6 it holds that for such an index $i$, $\Phi$ decreases and

[TABLE]

Now we bound the sum of sizes of lower-ranked neighborhoods of vertices corresponding to Step 3b. It holds that

[TABLE]

where the third inequality follows from the fact that $\Phi$ starts at 0 and is non-negative at the end, and, thus, the total decrease of $\Phi$ is at most its total increase. Thus, it follows that

[TABLE]

∎

Now we finish the proof of Lemma 3.2. By Lemma 3.5 and Lemma 3.4, it holds that

[TABLE]

Since the expected work $T_{v}$ satisfies that $T_{v}=O(\sum_{i}|L_{v_{i}}|)$, the first part of the lemma follows. By the “Furthermore” part of Lemma 3.4, it holds that

[TABLE]

Then the “Furthermore” part of Lemma 3.2 follows from the fact that $T_{v}=O(\sum_{i}|L_{v_{i}}|)$.

4 Maintaining the Approximate Weight of the MSF

In this section, we present our dynamic algorithms for maintaining the weight $M$ of a minimum spanning forest of a graph $G$ without parallel edges and with edge weights in $[1,W]$. Our algorithms exploit a relation between the weight of MSF of a graph $G$ and the number of CCs of some subgraphs of $G$. Let $G^{(\ell)}$ denote the subgraph of $G$ spanned by all edges with weights at most $\ell$ and let $c^{(\ell)}$ denote the number of CCs in $G^{(\ell)}$. We will make use of the following Lemma.

Lemma 4.1** ([CRT05, CS09, AGM12]).**

Let $G$ be a weighted graph777We remark that in [CRT05, CS09, AGM12], the input graph is assumed to be connected. The lemma we stated here does not require the connectedness assumption and its proof is a straightforward generalization of previous proofs, by noting that $M=n-W\cdot c^{(W)}+\sum_{i=0}^{W-1}c^{(i)}$ in a general graph $G$ with edges weights from $\{1,\dots,W\}$ for any integer $W\geq 1$. and let $M,W,c^{(\ell)}$ be defined as above. Let $r=\lceil\log_{1+\frac{\varepsilon}{2}}W\rceil$. Let $\lambda_{i}=(1+\frac{\varepsilon}{2})^{i+1}-(1+\frac{\varepsilon}{2})^{i}$ and $\ell_{i}=(1+\frac{\varepsilon}{2})^{i}$. Then it holds that

[TABLE]

Now we first present some high-level ideas of the algorithms.

4.1 High-Level Ideas

As briefly mentioned in the introduction, we would like to build constant-time dynamic algorithms that estimate the number of CCs with appropriate additive error, apply them to $O(\log W/\varepsilon)$ many subgraphs, and then use the formula (5) to disconnected graphs to estimate the weight of an MSF. In particular, we want to estimate the number of CCs with an additive error $\varepsilon^{\prime}\cdot\mathrm{nis}(G)$, where $\mathrm{nis}(G)$ is the number of non-isolated vertices in $G$ (see below why this is crucial). Our randomized dynamic algorithm for this problem achieves such an error in time $O(\max\{1,\frac{\log(1/\varepsilon^{\prime})\log n}{(\varepsilon^{\prime})^{3}\cdot m^{*}}\})$ with high probability (see precise statement in Section 4.3), and our deterministic algorithm achieves the same error $\varepsilon^{\prime}\cdot\mathrm{nis}(G)$ in time $O((1/\varepsilon^{\prime})^{2})$.

The randomized algorithm uses the following general approach used before (see e.g. [GP13]): Whenever (1) there exists a static algorithm that in time $T$ estimates a desired parameter (here the number of CCs) with an additive error of Err and (2) each update operation changes the value of a desired parameter only by an additive value up to $+/-\delta$ (here 1), then running the static algorithm every $\frac{{\textsc{Err}}}{\delta}$ update operations leads to a dynamic algorithm with additive error of at most $2{\textsc{Err}}$ and amortized time $O(\frac{T\delta}{{\textsc{Err}}})$ per update and this can be turned into a worst-case time bound using “rebuilds in the background”. We use the static (constant-time) algorithm of [BKMT14] (that improves upon [CRT05]) for estimating the number of CCs with additive error $\varepsilon^{\prime}n$ as a subroutine. By a straightforward application of the above general approach, we can obtain a dynamic estimator for the number of CCs with an additive error $\varepsilon^{\prime}n^{2/3}\log^{2/3}n$ with $O(1/\varepsilon^{\prime 3})$ update time.

However, to use this algorithm for dynamically estimating the number of CCs with an additive error $\varepsilon^{\prime}\cdot\mathrm{nis}(G)$ achieving the above bound, we need to carefully choose different values of Err throughout all the updates and be able to sample the non-isolated vertices uniformly at random. The latter is exactly the problem solved by $\ell_{0}$-sampling in streaming algorithms. However, all such algorithms, while only using $O(\textrm{poly}\log n)$ space, require time $\Omega(\log n)$ per operation. We give a relatively simply data structure that allows to subsample all non-zero entries in a dynamically changing vector of size $n$ in constant time (no matter how small their number might be), albeit with space $O(n)$. We believe that our data structure might be of independent interest.

To design a deterministic worst-case dynamic algorithm we cannot simply invoke the static constant-time algorithm: this algorithm is inherently randomized as it is designed with the goal of reading the smallest possible portion of the graph. Instead we carefully implement the random local exploration that underlies the static randomized algorithm in a deterministic way. Our key observations are (1) that we only need to count the number of CCs that are small in size, i.e. consist of up to $1/\varepsilon^{\prime}$ vertices, as the number of larger CCs is at most $\varepsilon^{\prime}\cdot\mathrm{nis}(G)$ and (2) that these counts can be maintained in worst-case time $O(1/\varepsilon^{\prime 2})$ after each update by exploring a neighborhood of $O(1/\varepsilon)$ vertices “around” the endpoints of the updated edge.

Both the randomized and the deterministic MSF algorithm run their respective CC estimation algorithms on each of the $O({\log W}/{\varepsilon})$ relevant subgraphs with $\varepsilon^{\prime}=\varepsilon/(4W)$. Using the above-mentioned formula results in an additive error of $\varepsilon\mathrm{nis}(G)/4$ for MSF. As the weight of any MSF is at least $\mathrm{nis}(G)/2$, this additive error is at most $\varepsilon M/2$, i.e., a $(1+\varepsilon)$-approximation of $M$. For our deterministic algorithm for MSF, the time per edge update is $O(1/\varepsilon^{\prime 2})=O(W^{2}/\varepsilon^{2})$ for each of the $O({\log W}/{\varepsilon})$ subgraphs, resulting in a worst-case $O(W^{2}\log W/\varepsilon^{3})$ update time. The running time of our randomized algorithm for MSF can be analyzed analogously.

4.2 A Deterministic Dynamic Algorithm

We first present a deterministic dynamic algorithm for approximating the number of connected components (CCs) with appropriate additive error. We use $\mathrm{ncc}(G)$ to denote the number of CCs of $G$, $\mathrm{nis}(G)$ to denote the number of non-isolated vertices of $G$, and size of a CC to denote the number of vertices in the CC.

Theorem 4.2**.**

Let $\varepsilon>0$. There exists a fully dynamic and deterministic algorithm that preprocesses a potentially non-empty graph in $O(\frac{n}{\varepsilon})$ time, and maintains an estimator $\overline{c}$ s.t., $|\overline{c}-\mathrm{ncc}(G)|\leq\varepsilon\cdot\mathrm{nis}(G)$ with worst-case $O(1/\varepsilon^{2})$ update time per operation.

We remark that in the above theorem, the initial graph can be an arbitrary graph, and the performance guarantee holds even if the algorithm is not aware of the value $\mathrm{nis}(G)$. By combining the algorithm from Theorem 4.2 and the relation in Lemma 4.1, we can obtain the following result.

Theorem 4.3**.**

There exists a fully dynamic and deterministic algorithm that maintains an estimator $\overline{M}$ that $(1+\varepsilon)$-approximates the weight $M$ of a MSF of a graph with edge weights from $[1,W]$. The worst-case time per update operation is $O(\frac{W^{2}\cdot\log W}{\varepsilon^{3}})$.

Proof.

Recall that $\mathrm{nis}(G)$ is the number of non-isolated vertices in $G$ and note that $\mathrm{nis}(G)\geq\mathrm{nis}(G^{(\ell_{i})})$, since $G^{(\ell_{i})}$ is a subgraph of $G$ for any $1\leq i\leq r$. We call the dynamic algorithm from Theorem 4.2 for estimating $c^{(\ell_{i})}$ for each $1\leq i\leq r$ with $\varepsilon^{\prime}=\varepsilon/(4W)$, which gives an additive error $\varepsilon\cdot\mathrm{nis}(G^{(\ell_{i})})/{4W}\leq\varepsilon\cdot\mathrm{nis}(G)/{4W}$. Its worst-case time per update operation is $O(1/\varepsilon^{\prime 2})$, which is $O({W^{2}}/{\varepsilon^{2}})$. Since $G$ is simple, we know that $M\geq{\mathrm{nis}(G)}/{2}$, as each non-isolated vertex is incident to at least one edge (of weight at least $1$) of any MSF.

Let $\overline{c}_{i}$ denote the estimator for $c^{(\ell_{i})}$. Then we define $\overline{M}:=n-\overline{c}_{r}\cdot(1+\frac{\varepsilon}{2})^{r}+\sum_{i=0}^{r-1}\lambda_{i}\cdot\overline{c}_{i}.$ Since $|\overline{c}_{i}-c^{(\ell_{i})}|\leq\frac{\varepsilon\cdot\mathrm{nis}(G)}{4W}$ and $M\geq\frac{\mathrm{nis}(G)}{2}$, we have that $|\overline{M}-X|\leq\frac{\varepsilon\cdot\mathrm{nis}(G)}{4}\leq\frac{\varepsilon M}{2},$ where $X$ is the quantity in Lemma 4.1. Together with inequality (5), $\overline{M}$ is a $(1+\varepsilon)$-approximation of $M$. Note that the worst-case time per update operation of the algorithm for maintaining $\overline{M}$ is $\sum_{i=1}^{r}O(\frac{W^{2}}{\varepsilon^{2}})=O(\frac{r}{\varepsilon^{2}}W^{2})=O(\frac{W^{2}\cdot\log W}{\varepsilon^{3}})$. ∎

In the following, we give the proof of Theorem 4.2.

Proof of Theorem 4.2.

We first give a static algorithm for computing the number of small CCs of any graph $G$. We maintain a set of $\lceil 1/\varepsilon\rceil$ counters $\mathrm{cnt}_{\ell}$, where $\mathrm{cnt}_{\ell}$ denotes the number of CCs of size $\ell$. Initially, all the counters are set to [math] and all vertices are marked unvisited. We recursively choose an arbitrary unvisited vertex $v$, mark it as visited and start a BFS at $v$ which runs until (1) it has reached (e.g. discovered an edge to) $1/\varepsilon+1$ unvisited vertices, (2) it reaches a visited vertex, or (3) the BFS terminates because whole connected component (of size at most $1/\varepsilon$) containing $v$ has been explored. Then we mark all the newly discovered vertices as visited and update the counters accordingly. More precisely, the static and the dynamic algorithms are as follows.

[TABLE]

The dynamic algorithm updates the counter $\overline{c}$ in time $O(1/\varepsilon^{2})$ by running a limited BFS from $u$ and $v$ in the graph before and after the update. The details are given below.

Correctness. For the correctness of the dynamic algorithm, we let $\mathrm{nscc}(G)$ denote the number of CCs of size at most $1/\varepsilon$ in $G$. We show that the maintained estimator $\overline{c}$ is equal to $\mathrm{nscc}(G)$ throughout all the updates. Note that we preprocess the graph using the above static algorithm and obtain the estimator $\overline{c}$ for the initial graph. By definition, $\overline{c}=\mathrm{nscc}(G_{0})$. Now for any edge insertion $(u,v)$, we know that the number $\mathrm{nscc}$ (of CCs of size at most $1/\varepsilon$) can change by at most $2$. More precisely, it changes if and only if at least one of $s_{u}^{(0)},s_{v}^{(0)}$ is at most $1/\varepsilon$ and $u,v$ do not belong to the same CC before the edge insertion, where $s_{u}^{(0)}$ and $s_{v}^{(0)}$ are the sizes of the explored subgraphs (before the edge insertion) starting from $u$ and $v$, respectively, that we compute in the algorithm. Furthermore, if Step 2a happens, i.e., exactly one of $s_{u}^{(0)}$ and $s_{v}^{(0)}$, say $s_{u}^{(0)}$, is no larger than $1/\varepsilon$, then a small CC merges into a large CC, and thus $\mathrm{nscc}$ decreases by $1$. If Step 2b happens (i.e., $s_{u}^{(0)},s_{v}^{(0)}$ are smaller than $1/\varepsilon$): if Step 2(b)i happens, i.e., $s_{u}^{(1)}$ is larger than $1/\varepsilon$, then two small CCs merge into a CC of size larger than $1/\varepsilon$ and thus $\mathrm{nscc}$ decreases by $2$; if Step 2(b)ii happens, i.e., $s_{u}^{(1)}$ is no larger than $1/\varepsilon$ and $s_{u}^{(1)}=s_{u}^{(0)}$, then $u,v$ belong to the same CC before $(u,v)$ was inserted and thus $\mathrm{nscc}$ remains unchanged; if Step 2(b)iii happens, i.e., $s_{u}^{(1)}$ is no larger than $1/\varepsilon$ and $s_{u}^{(1)}\neq s_{u}^{(0)}$, then two small CCs merge into a CC of size no larger than $1/\varepsilon$ and thus $\mathrm{nscc}$ decreases by $1$. By the description of our algorithm, after the insertion $(u,v)$, the maintained $\overline{c}$ still satisfies that $\overline{c}=\mathrm{nscc}(G^{\prime})$, where $G^{\prime}$ is the updated graph. The case for edge deletions can be analyzed similarly.

Since the total number of CCs of size larger than $\frac{1}{\varepsilon}$ is at most $\varepsilon\cdot\mathrm{nis}(G)$, where $\mathrm{nis}(G)$ is the number of non-isolated vertices of $G$, we know that $\overline{c}$ approximates $\mathrm{ncc}(G)$ with an additive error $\varepsilon\cdot\mathrm{nis}(G)$.

Running time. Now we analyze the running time of our dynamic algorithm. We first show that our static algorithm for preprocessing the initial graph can be implemented in $O(n\cdot\frac{1}{\varepsilon})$ time. Note that it suffices to bound the time of *exploring * each CC $C$, i.e., until all the vertices inside $C$ have been marked as visited. Note that $\mathrm{cnt}_{\ell}$ is exactly the number of CCs of size $\ell$, for $\ell\leq 1/\varepsilon$ and consider two cases, which together show the $O(n/\varepsilon)$ bound. (1) If $|C|=\ell\leq\frac{1}{\varepsilon}$, then the total time for exploring $C$ is $O(\ell^{2})$. In this case, we note that the total time for exploring CCs of size at most $1/\varepsilon$ is $\sum_{\ell=1}^{1/\varepsilon}\mathrm{cnt}_{\ell}\cdot O(\ell^{2})\leq\sum_{\ell=1}^{1/\varepsilon}\mathrm{cnt}_{\ell}\cdot\ell\cdot O(1/\varepsilon)=O(n/\varepsilon)$, where the last equation follows from the fact that $\sum_{\ell=1}^{1/\varepsilon}\mathrm{cnt}_{\ell}\cdot\ell\leq n$.

(2) If $|C|>1/\varepsilon$, let $S=\{v_{1},v_{2},\cdots,v_{b}\}$ denote the set of vertices from which we start a BFS in $C$ and let $s_{i}$ denote the number of newly discovered vertices from vertex $v_{i}$. It holds that $s_{i}\leq 1/\varepsilon+1$ for each $i\leq b$ by the description of our algorithm. Let $t_{j}$ denote the number of vertices in $S$ from which the BFS discovers exactly $j$ new vertices, for each $j\leq 1/\varepsilon+1$. Then $|C|=\sum_{j=1}^{1/\varepsilon+1}t_{j}\cdot j$. Furthermore, we note that for each $j\geq 1$, it takes time $O(j\cdot\frac{1}{\varepsilon})$ for the BFS to discover exactly $j$ new vertices, as we will only scan at most $\frac{1}{\varepsilon}+1$ neighbors for each of these new vertices. Thus, the total time of exploring $C$ is $\sum_{j=1}^{1/\varepsilon+1}t_{j}\cdot O(j\cdot\frac{1}{\varepsilon})\leq O(1/\varepsilon)\cdot\sum_{j=1}^{1/\varepsilon+1}t_{j}\cdot j=O(|C|/\varepsilon)$. Thus, the total time of exploring CCs of size at least $1/\varepsilon+1$ is $\sum_{C:|C|\geq 1/\varepsilon+1}O(|C|/\varepsilon)=O(n/\varepsilon)$, where the last equation follows from the fact that $\sum_{C:|C|\geq 1/\varepsilon+1}|C|\leq n$.

Finally, we note that for each update (either insertion or deletion), we only need to execute $O(1)$ BFS calls, each of which will explore at most $O(1/\varepsilon)$ vertices (and thus $O(1/\varepsilon^{2})$ edges). Therefore, the worst-case time per update operation is $O(1/\varepsilon^{2})$. ∎

4.3 A Randomized Dynamic Algorithm

In this section, we give a randomized dynamic algorithm for estimating the weight of the MSF. Our algorithm will be built upon a dynamic algorithm for approximating $\mathrm{ncc}(G)$ with an additive error $\varepsilon\cdot T(G)$, for some parameter $T(G)\geq\mathrm{nis}(G)$. We have the following result.

Theorem 4.4**.**

Let $1>\varepsilon^{\prime}>0$ and $0<p<1$. Let $G$ be a dynamically changing graph such that each update operation has as additional parameter a value $T(G)$ such that (a) $T(G)\geq\mathrm{nis}(G)$ (where $G$ denotes the graph right before the update) and (b) each update changes $T(G)$ by at most $2$ in comparison to the previous update. Then there exists a fully dynamic algorithm that takes as input the initial graph and the sequence of update operations and, with probability at least $1-p$, maintains an estimator $\overline{cc}$ for the number $\mathrm{ncc}$ of CCs of a graph $G$ s.t., $|\overline{cc}-\mathrm{ncc}(G)|\leq\varepsilon^{\prime}\cdot T(G)$. The worst-case time per update operation is $O(\max\{1,\frac{\log(1/\varepsilon^{\prime})\log(1/p)}{\varepsilon^{\prime 3}T^{*}}\})$, where $T^{*}$ is the minimum value of $T(G)$ over all updates. Our algorithm works against an adaptive adversary.

We defer the proof of the above theorem to Section 4.3.1. Given Theorem 4.4 and the relation from Lemma 4.1, we have the following theorem.

Theorem 4.5**.**

Let $0<p^{\prime}<1$. There exists a fully dynamic algorithm that with probability at least $1-p^{\prime}$, maintains an estimator $\overline{M}$ that is a $(1+\varepsilon)$-approximation of the weight $M$ of MSF of a graph $G$ with edge weights from $[W]$. The worst-case time per update operation is $O(\max\{1,\frac{W^{3}\log W\log(\frac{W}{\varepsilon})\log(\frac{\log W}{\varepsilon p^{\prime}})}{\varepsilon^{4}\mathrm{nis}^{*}}\})$, where $\mathrm{nis}^{*}$ is the minimum number of non-isolated vertices in $G$ throughout all the updates. Our algorithm works against an adaptive adversary.

Proof.

Recall from the proof of Theorem 4.3, $\mathrm{nis}(G)\geq\mathrm{nis}(G^{(\ell_{i})})$, since $G^{(\ell_{i})}$ is a subgraph of $G$ for any $1\leq i\leq r$. Since $G$ is simple, we know that $M\geq{\mathrm{nis}(G)}/{2}$, as each non-isolated vertex is incident to at least one edge (of weight at least $1$) of any MSF.

Now for each $j\leq r$, we would like to maintain $c^{(\ell_{j})}$, the number of CCs in $G^{(\ell_{j})}$, by invoking Theorem 4.4. In order to do so, we first ensure that $G^{(\ell_{j})}$ will update with $G$ “synchronously”: for each edge update $(u,v)$ in $G$, if the weight of $(u,v)$ is at most $\ell_{j}$, then we update $G^{(\ell_{j})}$ accordingly; if the weight of $(u,v)$ is larger than $\ell_{j}$, then we update $G^{(\ell_{j})}$ by first inserting a self-loop $(u,u)$ and then immediately deleting the self-loop $(u,u)$. In the latter case, each update in $G$ corresponds to two updates in $G^{(\ell_{j})}$, which guarantee that $G^{(\ell_{j})}$ is unchanged after the updates.

Now for each $j\leq r$, we execute the algorithm of Theorem 4.4 on $G^{(\ell_{j})}$ (which is updated according to the above scheme) using $p=\frac{p^{\prime}}{r}$, $\varepsilon^{\prime}=\frac{\varepsilon}{4W}$, and $T(G^{(\ell_{j})})=\mathrm{nis}(G)$, i.e., each update operation uses as additional parameter $\mathrm{nis}(G)$. Note that it always holds that $T(G^{(\ell_{j})})\geq\mathrm{nis}(G^{\ell_{j}})$, and each update in $G^{(\ell_{j})}$ changes $T(G^{(\ell_{j})})$ by at most $2$ in comparison to the previous update, which is guaranteed by the above update sequence. Thus, by Theorem 4.4 the algorithm computes an estimator $\overline{c}_{j}$ for $c^{(\ell_{j})}$ such that with probability $1-\frac{p^{\prime}}{r}$, it holds that

[TABLE]

Note that throughout all the updates, it holds that $T(G^{(\ell_{j})})=\mathrm{nis}(G)\geq\mathrm{nis}^{*}$. Thus the amortized time spent per update for computing $\overline{c}_{j}$ is

[TABLE]

Let $\overline{M}=n-\overline{c}_{r}\cdot(1+\frac{\varepsilon}{2})^{r}+\sum_{j=0}^{r-1}\lambda_{j}\cdot\overline{c}_{j}$. Since $|\overline{c}_{j}-c^{(\ell_{j})}|\leq\frac{\varepsilon\mathrm{nis}(G)}{4W}$ and $M\geq\frac{\mathrm{nis}(G)}{2}$, we have that $|\overline{M}-X|\leq\frac{\varepsilon\mathrm{nis}(G)}{4}\leq\frac{\varepsilon M}{2}$, where $X$ is as defined in Lemma 4.1. Together with inequality (5), $\overline{M}$ is a $(1+\varepsilon)$-approximation of $M$. The success probability of the algorithm is at least $1-r\cdot\frac{p^{\prime}}{r}=1-p^{\prime}$, and the worst-case time per update operation is

[TABLE]

The algorithm works against an adaptive adversary as each of the algorithms from  Theorem 4.4 works against an adaptive adversary and the MSF algorithm simply computes a weighted sum of the values returned by each of these algorithms. This completes the proof of the theorem. ∎

The following is a direct corollary of the above theorem by setting $p^{\prime}=1/n^{c}$ and the fact that $\mathrm{nis}^{*}\leq n$.

Corollary 4.6**.**

Let $c$ be any constant such that $c\geq 1$. There exists a fully dynamic algorithm that with probability at least $1-\frac{1}{n^{c}}$, maintains an estimator $\overline{M}$ that is a $(1+\varepsilon)$-approximation of the weight $M$ of the MSF of a graph $G$ with edge weights from $[W]$ and $W=O((\mathrm{nis}^{*})^{1/3}/\log^{3}n)$, where $\mathrm{nis}^{*}$ is the minimum number of non-isolated vertices in $G$ throughout all the updates. The algorithm runs in $O(\frac{1}{\varepsilon^{4}}\log^{2}(\frac{1}{\varepsilon}))$ worst-case time per update operation.

We note that $\mathrm{nis}^{*}\geq 2m^{*}$, where $m^{*}$ is the minimum number of edges of the graph throughout all the updates. This is true as for the graph $G$ with minimum non-isolated vertices, i.e., $\mathrm{nis}(G)=\mathrm{nis}^{*}$, each non-isolated vertex will contribute at least half of an edge, and thus the number of edges in $G$ is at least $\frac{\mathrm{nis}^{*}}{2}$, which is at least $m^{*}$ by the definition of $m^{*}$. Then we have the following corollary.

Corollary 4.7**.**

Let $c$ be any constant such that $c\geq 1$. There exists a fully dynamic algorithm that with probability at least $1-\frac{1}{n^{c}}$, maintains an estimator $\overline{M}$ that is a $(1+\varepsilon)$-approximation of the weight $M$ of the MSF of a graph $G$ with edge weights from $[W]$ and $W=O((m^{*})^{1/3}/\log^{3}n)$, where $m^{*}$ is the minimum number of edges of the graph throughout all the updates. The algorithm runs in $O(\frac{1}{\varepsilon^{4}}\log^{2}(\frac{1}{\varepsilon}))$ worst-case time per update operation.

4.3.1 Proof of Theorem 4.4

We first state a known constant-time static algorithm for estimating the number $\mathrm{ncc}(G)$ of CCs with additive error $\varepsilon n$, building on which, we then give a dynamic algorithm for estimating $\mathrm{ncc}(G)$ with an additive error $\varepsilon T(G)$, for some parameter $T(G)\geq\mathrm{nis}(G)$.

Static algorithms for estimating the number of CCs.

Recall that $\mathrm{ncc}(G)$ denotes the number of CCs of a graph $G$. We need the following lemma by Berenbrink et al. [BKMT14] (which improves upon the result in [CRT05]) that gives a constant-time algorithm for estimating $\mathrm{ncc}(G)$. It is assumed that the algorithm can make some types of queries888Please note that the query access to the input graph from the sublinear-time community is different from the query operation in the dynamic algorithms community. to access to the graph. That is, the algorithm can perform a vertex-sample query, which allows it to sample a vertex uniformly at random from $V$, and can make queries to the adjacency list of the graph. Note that these two queries for accessing a static graph can be supported by maintaining an array of vertices and the adjacency list of the graph, respectively.

Lemma 4.8** ([BKMT14]).**

Let $\varepsilon>0$ and $0<p<1$. Suppose the algorithm has access to the adjacency list of a graph $G$ and can perform vertex-sample queries. Then there exists an algorithm that with probability at least $1-p$, returns an estimate that approximates $\mathrm{ncc}(G)$ with an additive error $\varepsilon n$. The running time of the algorithm is $O(1/\varepsilon^{2}\log(1/\varepsilon)\log(1/p))$.

We remark that the algorithm in [BKMT14] simply samples (uniformly at random) $O(1/\varepsilon^{2})$ vertices, performs a BFS starting from each sampled vertex (for a number of steps) and then makes decisions based on the explored subgraphs. Note that if the algorithm is able to perform a non-isolated vertex-sample query, i.e., the algorithm can sample a vertex uniformly at random from the set $N$ of all non-isolated vertices in a graph $G$, then one can approximate the size of CCs in the subgraph $G[N]$ induced by vertices in $N$ with an additive error $\varepsilon|N|=\varepsilon\mathrm{nis}(G)$. This is true as we can simply treat $G[N]$ as the input graph in the algorithm from Lemma 4.8. We let $G_{\mathrm{nis}}=G[N]$, and thus $\mathrm{ncc}(G_{\mathrm{nis}})$ denotes the number of CCs in $G[N]$. We have the following corollary.

Corollary 4.9**.**

Let $\varepsilon>0$ and $0<p<1$. Let $\mathrm{nis}(G)$ be the number of non-isolated vertices in $G$. Suppose the algorithm has access to the adjacency list of a graph $G$ and can perform non-isolated vertex-sample queries. Then there exists an algorithm that with probability at least $1-p$, returns an estimate $\overline{b}$ that approximates $\mathrm{ncc}(G_{\mathrm{nis}})$ with an additive error $\varepsilon\cdot\mathrm{nis}(G)$. The running time of the algorithm is $O(1/\varepsilon^{2}\log(1/\varepsilon)\log(1/p))$.

Estimating $\mathrm{ncc}(G)$: from static to dynamic.

In order to dynamically maintaining an estimate for $\mathrm{ncc}(G)$ with an additive error $\varepsilon T(G)$ for some $T(G)\geq\mathrm{nis}(G)$, we will periodically invoke the algorithm from Corollary 4.9 as a subroutine for our dynamic algorithm. This requires us to maintain some data structures so that the algorithm can query the adjacency list of the graph and perform non-isolated vertex-sample queries at any time. The adjacency list of a dynamic graph can be updated trivially in constant time. Next we give a data structure to support non-isolated vertex-sample queries in a dynamic setting.

Data structure for supporting non-isolated vertex-sample queries.

We first present a more general data structure to sample non-zero entries from an array and then show how to use it to support non-isolated vertex-sample queries.

Given a set $V$ of $n$ elements (here vertices), numbered from [math] to $n-1$, each element $u$ with an associated number $d_{u}$ (here degree), we show how to support the following operations in constant time with preprocessing time $O(n)$:

[TABLE]

Let us call an element $u$ of $V$ with $d_{u}\not=0$ a non-zero element. We implement the data structure by using two arrays and a counter:

We keep the number $\mathrm{nis}$ of non-zero elements of $V$. 2. 2.

We keep an array $\mathcal{A}$ of size $n$, where only the first $\mathrm{nis}$ entries are used, such that (i) each entry in $\mathcal{A}$ stores a non-zero element $u$ together with $d_{u}$ and (ii) each non-zero element of $V$ is stored in $\mathcal{A}$ within the first $\mathrm{nis}$ entries. 3. 3.

We keep an array $\mathcal{P}$ of size $n$, which has an entry for every element of $V$, such that if an element $u$ is stored in $\mathcal{A}[i]$ (i.e. $u$ is non-zero), then $\mathcal{P}[u]=i$; and if an element $u$ is not stored in $\mathcal{A}$ (i.e. $d_{u}=0$), then $\mathcal{P}[u]=-1$. Thus $\mathcal{P}$ consists of indices corresponding to the positions of elements in $\mathcal{A}$ or the number $-1$.

During preprocessing we initialize both arrays, set all entries of $\mathcal{P}$ to -1, and set $\mathrm{nis}$ to 0. Then we insert every element $u$ whose initial value $d_{u}\not=0$ by calling Update($u,d_{u}$).

Handling an Update($u,\delta$) operation.

Whenever an Update($u,\delta$) operation is executed, we check if $\mathcal{P}[u]>-1$.

Case (1): $\mathcal{P}[u]>-1$. This means that $u$ is stored in $\mathcal{A}$ and $\mathcal{P}[u]$ contains the index of $u$ in $\mathcal{A}$. Thus we add $\delta$ to $d_{u}$, which is retrieved and then stored in the entry $\mathcal{A}[\mathcal{P}[u]]$. If the resulting value $d_{u}\not=0$, this completes the update operation. If, however, the resulting value $d_{u}=0$, let $v$ be the element stored in $\mathcal{A}[\mathrm{nis}]$. We copy into $\mathcal{A}[\mathcal{P}[u]]$ all information of element $v$, which we retrieve from $\mathcal{A}[\mathrm{nis}]$. Then we set $\mathcal{P}[v]=\mathcal{P}[u]$, set $\mathcal{P}[u]=-1$, and decrement $\mathrm{nis}$.

Case (2): $\mathcal{P}[u]=-1$. We increment $\mathrm{nis}$ by 1, set $d_{u}=\delta$, store $u$ and $d_{u}$ in $\mathcal{A}[\mathrm{nis}]$, and set $\mathcal{P}[u]=\mathrm{nis}$.

Handling Non-zero sample operation.

To implement a Non-zero sample operation, we pick a random integer number $j$ between [math] and $\mathrm{nis}-1$ and return the element from $\mathcal{A}[j]$.

Supporting non-isolated vertex-sample queries in dynamic graphs.

Next we show how to use the above data structure to support non-isolated vertex-sample query throughout all the updates. Whenever an edge $(u,v)$ is inserted, for each $x\in\{u,v\}$, we call Update($x,1$). Whenever an edge $(u,v)$ is deleted, for each $x\in\{u,v\}$, we call Update($x,-1$). To sample a non-isolated vertex, we call Non-zero sample().

Remark: It is interesting to contrast our data structure for non-isolated vertex-sample queries to the sketches for $\ell_{0}$-sampling in the data streaming community. To the best of our knowledge, all the sketches for $\ell_{0}$-sampling use only $O(\textrm{poly}\log n)$ space, but require $\Omega(\log n)$ update time, while we use $O(n)$ space, but require only constant time.

Dynamically estimating $\mathrm{ncc}(G)$ with an additive error $\varepsilon\cdot T(G)$, for a parameter $T(G)\geq\mathrm{nis}(G)$.

Now we are ready to describe our randomized dynamic algorithm for estimating $\mathrm{ncc}(G)$ with an additive error $\varepsilon\cdot T(G)$. Our idea is as follows: We will maintain the value $\Gamma=\mathrm{nis}(G)$. During initialization, we set $\Psi=T(G)$ and $\overline{c}=\mathrm{ncc}(G)$. Then we repeat the following: after every $\varepsilon^{\prime}\Psi/4$ updates, we re-compute the estimator $\overline{c}$ by invoking the static algorithm from Corollary 4.9 on the current graph $G$ with parameter $\varepsilon^{\prime}/4$ and re-set $\Psi=T(G)$. In the meanwhile, we maintain the adjacency list of the dynamic graph in a trivial way and maintain the data structures for supporting non-isolated vertex-sample queries as above. The description of our randomized algorithm is given as follows. (For simplicity, we did not include the details for maintaining adjacency list, array of degrees, and data structures for sampling non-isolated vertices.)

[TABLE]

Note that the algorithm runs a static BFS traversal to obtain the exact values for $\mathrm{nis}(G)$ and $\mathrm{ncc}(G)$ in the initial graph. Then it partitions the updates into phases, starting a new phase every $\varepsilon^{\prime}\Psi/4$ updates. At the beginning of each phase, it sets $\Psi=T(G_{i})$, where $i$ is the update at the beginning of the phase, and runs the constant-time algorithm from Corollary 4.9). (The parameter $T(G_{i})$ is ignored for all updates that do not happen at the beginning of a phase.) When asked a query, it returns $\overline{c}$.

Correctness. We consider an arbitrary phase. At the beginning of the phase either the algorithm computes the correct value of $\overline{c}$ (for the first phase) or it calls the the static algorithm, which returns with probability $1-p$ an estimator $\overline{b}$ for $\mathrm{ncc}(G_{\mathrm{nis}})$ such that $|\overline{b}-\mathrm{ncc}(G_{\mathrm{nis}})|\leq\frac{\varepsilon^{\prime}\mathrm{nis}(G)}{4}$, which gives

[TABLE]

where the second equation follows from the fact that $\mathrm{ncc}(G)$ is the sum of $\mathrm{ncc}(G_{\mathrm{nis}})$ and the number of isolated vertices, $n-\mathrm{nis}(G)$. Let $\Lambda=\mathrm{nis}(G)$ at the beginning of the phase and note that $\Gamma$ always equals the value $T(G)$ that was given by the first update of a phase. We are guaranteed that at each update $T(G)\geq\mathrm{nis}(G)$ and, thus, it follows that $\Gamma\geq\Lambda$.

We analyze the additive error throughout the phase, ie. the next $\frac{\varepsilon^{\prime}\Psi}{4}$ updates. As each update changes $\mathrm{ncc}(G)$ by at most 1, with at least probability $1-p$, it holds that $\lvert\overline{c}-\mathrm{ncc}(G)\rvert\leq\frac{\varepsilon^{\prime}\Lambda}{4}+\frac{\varepsilon^{\prime}\Psi}{4}\leq\frac{\varepsilon^{\prime}\Psi}{2}$. Note that $|\Psi-T(G)|\leq\frac{\varepsilon^{\prime}\Psi}{2}$, as each update (for all $\frac{\varepsilon^{\prime}\Psi}{4}$ updates) can change $T(G)$ by at most $2$. Thus $\Psi\leq\frac{1}{1-\varepsilon^{\prime}/2}T(G)\leq(1+\varepsilon^{\prime})T(G)\leq 2T(G)$. This implies that $\overline{c}$ approximates $\mathrm{ncc}(G)$ with an additive error $\varepsilon^{\prime}T(G)$ at any time in a phase.

Thus it follows that with probability $1-p$, at any time $\lvert\overline{c}-\mathrm{ncc}(G)\rvert\leq\varepsilon^{\prime}T(G)$.

Note that the algorithm uses “fresh” random bits at the beginning of each phase, only needs to access to the current graph, and does not reuse any information computed in prior phases. Within each phase we performed a worst-case analysis, i.e., we assumed that the adversary changes the graph in the worst possible way, i.e., changing $\mathrm{ncc}(G)$ by 1 in each update. Thus, our algorithm works against an adaptive adversary, i.e. an adversary that sees the answers to all queries before deciding on the next update operation.

Running time. For each phase with parameter $\Psi$, the amortized running time is

[TABLE]

(Note that we always need to use $O(1)$ time to update the adjacency list and other data structures so as to provide query access to the graph). If we let $T^{*}$ denote the minimum value $T(G)$ over all the graphs throughout all the updates, then in any phase, the parameter $\Psi\geq T^{*}$ and the amortized running time of the algorithm is

[TABLE]

By using the standard global rebuilding technique, we can de-amortize the running time and obtain $O(\max\{1,\frac{\log(1/\varepsilon^{\prime})\log(1/p)}{\varepsilon^{\prime 3}T^{*}}\})$ worst-case time per update operation. This finishes the proof of Theorem 4.4.

Remark: We further remark that by using a similar algorithm and analysis, we can maintain an estimator for $\mathrm{ncc}(G)$ with an additive error $\varepsilon n^{O(1)}$ (instead of $\varepsilon\cdot T(G)$ or $\varepsilon\cdot\mathrm{nis}(G)$), which might be of independent interest. We defer the details to Appendix C.

Appendix A Lower Bound for Dynamic $\Delta$-Colorability Testing

In [PD06] Patrascu and Demaine construct an $n$-node graph and show that there exists a sequence $\mathcal{S}$ of $T$ edge insertion, edge deletion, and query operations such that any data structure for dynamic connectivity must perform $\Omega(T\log n)$ cell probes to process the sequence, where each cell has size $O(\log n)$. This shows that the amortized number of cell probes per operation is $\Omega(\log n)$.

We now show how to use this result to get a lower bound for the following dynamic $\Delta$-colorability testing problem: An insert($u,v)$ operation inserts the edge $(u,v)$, a delete($u,v$) operation deletes the edge $(u,v)$, and a query($u,v$) operation returns yes if the graph is $\Delta$-colorable and no otherwise, where $\Delta$ is the maximum degree in the current graph. Specifically we show the lower bound for $\Delta=2$.

The graph $G$ in the proof of[PD06] consists of a $\sqrt{n}\times\sqrt{n}$ grid, where each node in column $1$ has exactly 1 edge to a node of column 2 and no other edges, each node in column $i$, with $1<i<\sqrt{n}$ has exactly 1 edge to a node of column $i-1$ and 1 edge to a node of column $i+1$ and no other edges, and each node in column $\sqrt{n}$ has exactly 1 edge to a node of column $\sqrt{n}-1$ and no other edges. Thus, the graph consists of $\sqrt{n}$ paths of length $\sqrt{n}-1$ and the edges between column $i$ and $i+1$ for any $1\leq i<\sqrt{n}$ represent a permutation of the $\sqrt{n}$ rows. The sequence $\mathcal{S}$ consists of “batches” of $O(\sqrt{n})$ edge updates, replacing the permutation of some column $i$ by a new permutation for column $i$. Between the batches of updates are “batches” of connectivity queries, each consisting of $\sqrt{n}$ connectivity queries and a parameter $1\leq k\leq\sqrt{n}$, where the $j$-th query for $1\leq j\leq\sqrt{n}$ of each batch tests whether the $j$-th vertex of column 1 is connected with a specific vertex of column $k$.

Note that the maximum degree $\Delta$ is 2. We now show how to modify each connectivity query $(u,v)$ such that it consists of a constant number of edge updates and one query whether the resulting graph is $\Delta$-colorable. The answer will be no iff $u$ and $v$ are connected. Thus, in the resulting sequence $\mathcal{S}^{\prime}$ the number of query operations equals the number of query operations in $\mathcal{S}$ and the number of update operations is linear in the number of update and query operations in $\mathcal{S}$. Thus the total number of oerations in $\mathcal{S}^{\prime}$ is only a constant factor larger than the number of operations in $\mathcal{S}$, which, together with the result of [PD06], implies that the amortized number of cell probes per operation is $\Omega(\log n)$.

We now show how to simulate a connectivity query($u,v$), where $u$ is in column 1 and $v$ is in column $k$ for some $1\leq k\sqrt{n}$. We assume that $k$ is even and explain below how to deal with the case that $k$ is odd. The instance for the dynamic $\Delta$-colorability testing consists of $G$ with an additional node $s$ added. To simulate a connectivity query($u,v$) we (1) remove the edge from $v$ to its neighbor in column $k+1$ if $k<\sqrt{n}$, (2) add the edges $(u,s)$ and $(v,s)$ and then (3) ask a $\Delta$-colorability query. Note that the resulting graph still has maximum degree 2. Furthermore, if $u$ and $v$ are connected in $G$ then there exists a unique path of odd length $k-1$ between them. Together with the edges $(u,s)$ and $(v,s)$ and the assumption that $k$ is even, this results in an odd length cycle, so that the answer to the 2-colorability query is no. If, however, $u$ and $v$ are not connected in $G$, then adding the edges $(u,s)$ and $(v,s)$ creates a path of length $2+\sqrt{n}-1+k-1=\sqrt{n}+k$, but no cycle. Thus, the 2-colorability query returns yes. Thus $u$ and $v$ are connected in $G$ iff the 2-colorability query in the modified graph returns no. Afterwards we remove the edges $(u,s)$ and $(v,s)$. Finally if $k$ is odd, we do not add a vertex $s$ to $G$ and to simulate the connectivity query($u,v$) we simply insert the edge $(u,v)$. As before there exists an odd length cycle in the graph iff $u$ and $v$ are connected. The rest of the proof remains unchanged.

This shows the following theorem.

Theorem A.1**.**

Any data structure for dynamic $\Delta$-colorability testing, where $\Delta$ is the maximum degree in the graph, must perform $\Omega(\log n)$ cell probes, where each cell has size $O(\log n)$.

Appendix B Deferred Implementations, Proofs and Discussions from Section 3

B.1 Updating the Data Structures

Case I: an edge deletion $(u,v)$.

Whenever an edge $(u,v)$ gets deleted, we update the data structures corresponding to $u$ and $v$ as follows. More precisely, we first update the sets $H_{u},L_{u},H_{v},L_{v}$ and their sizes trivially in constant time. The lists $\mathcal{C}_{u}(H),\mathcal{C}_{u}(\overline{H}),\mathcal{C}_{v}(H),\mathcal{C}_{v}(\overline{H})$ can be updated in constant worst-case time. The hash tables $\mathcal{A}_{u}^{H},\mathcal{A}_{v}^{H}$ can also be maintained in constant amortized expected update time. More precisely, suppose w.l.o.g., $u\in L_{v}$, then we do the following:

Delete $(\chi(v),\mu_{u}^{H}(\chi(v)))$ from $\mathcal{A}_{u}^{H}$; $\mu_{u}^{H}(\chi(v))\leftarrow\mu_{u}^{H}(\chi(v))-1$. 2. 2.

If $\mu_{u}^{H}(\chi(v))=0$, then $\mathcal{C}_{u}(H)\leftarrow\mathcal{C}_{u}(H)\setminus\{\chi(v)\}$, $\mathcal{C}_{u}(\overline{H})\leftarrow\mathcal{C}_{u}(\overline{H})\cup\{\chi(v)\}$. 3. 3.

Otherwise, insert $(\chi(v),\mu_{u}^{H}(\chi(v)))$ to $\mathcal{A}_{u}^{H}$.

Case II: an edge insertion $(u,v)$ such that $\chi(u)\neq\chi(v)$.

In this case, w.l.o.g., suppose that $r(u)<r(v)$, we update the data structures as follows:

$\mathcal{C}_{u}(H)\leftarrow\mathcal{C}_{u}(H)\cup\{\chi(v)\}$, $\mathcal{C}_{u}(\overline{H})\leftarrow\mathcal{C}_{u}(\overline{H})\setminus\{\chi(v)\}$, $\mu_{u}^{H}(\chi(v))\leftarrow\mu_{u}^{H}(\chi(v))+1$ 2. 2.

Delete $(\chi(v),\mu_{u}^{H}(\chi(v))-1)$ from $\mathcal{A}_{u}^{H}$ if $\mu_{u}^{H}(\chi(v))>1$, insert $(\chi(v),\mu_{u}^{H}(\chi(v)))$ to $\mathcal{A}_{u}^{H}$.

Case III: procedure $(\divideontimes)$ in the subroutine Recolor($v$).

In the subroutine Recolor($v$), if the color of $v$ is changed from $c^{\prime}$ to $c$, then we update the relevant data structure as follows:

• $(\divideontimes)$

For every $w\in L_{v}$:

$\mu_{w}^{H}(c^{\prime})\leftarrow\mu_{w}^{H}(c^{\prime})-1$ 2. 2.

If $\mu_{w}(c^{\prime})=0$, then $\mathcal{C}_{w}(H)\leftarrow\mathcal{C}_{w}(H)\setminus\{c^{\prime}\}$, $\mathcal{C}_{w}(\overline{H})\leftarrow\mathcal{C}_{w}(\overline{H})\cup\{c^{\prime}\}$, 3. 3.

$\mathcal{C}_{w}(H)\leftarrow\mathcal{C}_{w}(H)\cup\{c\}$, $\mathcal{C}_{w}(\overline{H})\leftarrow\mathcal{C}_{w}(\overline{H})\setminus\{c\}$, $\mu_{w}^{H}(c)\leftarrow\mu_{w}^{H}(c)+1$. 4. 4.

Delete $(c,\mu_{w}^{H}(c))$ from $\mathcal{A}_{w}^{H}$ if $\mu_{w}^{H}(c)>1$, and insert $(c,\mu_{w}^{H}(c))$ to $\mathcal{A}_{w}^{H}$.

B.2 Initialization in $O(n)$ Time

Now we describe how we can reduce the initialization time from $O(n\Delta)$ to $O(n)$. Note that the only part that takes $O(n\Delta)$ time is to initialize $\mathcal{C}_{u}(\overline{H})$ for each vertex $u$, and the rest part of initialization already only takes $O(n)$ time. The main observation is that $\mathcal{C}_{u}(\overline{H})$ is only needed in the sampling subroutine of SetColor($u)$ and even there only once the degree of a vertex is at least $\Delta/2$. Since we make the standard assumption that we start with an empty graph, this means that $\Omega(\Delta)$ insertions incident to $u$ must have happened. Thus, we build $\mathcal{C}_{u}(\overline{H})$ only once this is the case and amortize the cost of building it over these previous $\Omega(\Delta)$ insertions.

To be more precise, we change the initialization phase as follows: We do not build $\mathcal{C}_{u}(\overline{H})$ for any vertex $u$. Note that all other data structure are built as before, but they only have size $O(n)$ and only take time $O(n)$ to build.

When an edge $(u,v)$ is inserted, we check whether one of the endpoints, say $u$, of the newly inserted edge reaches the degree $\Delta/2$ and does not yet have the data structure $\mathcal{C}_{u}(\overline{H})$. If so, we build $\mathcal{C}_{u}(\overline{H})$ and its hash table at this point in time $O(\Delta)$. We amortize this cost over the $\Delta/2$ updates that increased the degree of $u$ to $\Delta/2$, adding a constant amortized cost to each of them. (If the other endpoint $v$ also reaches the degree $\Delta/2$, we handle it analogously.)

Note that this does not affect the SetColor algorithm: as long as the degree of a vertex $u$ is less than $\Delta/2$, SetColor($u$) selects a new color by sampling in Step 2 from $\mathcal{B}_{u}$. To do so $\mathcal{C}_{u}(\overline{H})$ is not needed: In time $O(|L_{u}|)$ time we build the lists and corresponding hash tables for $\mathcal{M}_{u}(L)\cup\mathcal{U}_{u}(L)$, which together with the maintained list and hash table for $\mathcal{C}_{u}(H)$ suffice for us to sample a color from $\mathcal{B}_{u}$ in $O(1)$ time: We pick a random color from $\cal C$ and test whether it belongs to $\mathcal{B}_{u}$ by making sure that it does not belong to $\mathcal{M}_{u}(L)\cup\mathcal{U}_{u}(L)$ or $\mathcal{C}_{u}(H)$. The fact that the degree of $u$ is at most $\Delta/2$ implies that in expectation the second randomly chosen color will belong to $\mathcal{B}_{u}$.

Once $\mathcal{C}_{u}(\overline{H})$ and its hash table has been built, it is used in the way as we described before and updated as in Section B.1.

B.3 Deferred Proofs

Proof of Lemma 3.3.

In the following, we provide the proof of Lemma 3.3.

Proof.

Note that the first item of the lemma follows from Step 2 of the subroutine Recolor($v$), as the algorithm samples a new color from $\mathcal{B}_{v}$, whose size is larger than $\Delta+1-\frac{\Delta}{2}=\frac{\Delta}{2}+1$.

Now we consider the second item, i.e., the case that $|L_{v}|+|H_{v}|\geq\frac{\Delta}{2}$. Recall that $\mathcal{M}_{v}(L)$ denote the set of colors that have been used by at least two vertices in $L_{v}$. We first note that

[TABLE]

Furthermore, by definition of $\mathcal{M}_{v}(L)$, it holds that $2|\mathcal{M}_{v}(L)|+|\mathcal{U}_{v}(L)|\leq|L_{v}|$. Thus,

[TABLE]

Now we distinguish two cases. If Step 3a happens, i.e., $|L_{v,\textrm{new}}|\geq\frac{1}{10}|L_{v}|$, then $|L_{v,\textrm{new}}^{\textrm{<}}|\geq\frac{1}{20}|L_{v}|$. This further implies that $|L_{v}\setminus L_{v,\textrm{new}}^{\textrm{<}}|\leq\frac{19}{20}|L_{v}|$ and thus $|\mathcal{U}_{v}(L)\setminus\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{g}})|\leq|L_{v}\setminus L_{v,\textrm{new}}^{\textrm{<}}|\leq\frac{19}{20}|L_{v}|$. Then if $|\mathcal{B}_{v}|\geq\frac{1}{50}|L_{v}|+1$, then $s=\min\{|\mathcal{B}_{v}\cup\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{g}})|,|L_{v,\textrm{new}}^{\textrm{<}}|+1\}\geq\frac{1}{50}|L_{v}|+1$; otherwise (i.e., $|\mathcal{B}_{v}|\leq\frac{1}{50}|L_{v}|)$, by inequality (6), $|\mathcal{U}_{v}(L)|\geq 2+|L_{v}|-\frac{2}{50}|L_{v}|$. Thus

[TABLE]

This gives that $s=\min\{|\mathcal{B}_{v}\cup\mathcal{U}_{v}(L_{\textrm{new}}^{\textrm{g}})|,|L_{v,\textrm{new}}^{\textrm{<}}|+1\}\geq\frac{1}{100}|L_{v}|+1$.

If Step 3b happens, i.e., $|L_{v,\textrm{old}}|>\frac{9}{10}|L_{v}|$, then $|L_{v,\textrm{old}}^{\textrm{<}}|>\frac{9}{20}|L_{v}|$. Thus $|L_{v}\setminus L_{v,\textrm{old}}^{\textrm{<}}|<\frac{1}{20}|L_{v}|$ and $|\mathcal{U}_{v}(L)\setminus\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{g}})|\leq|L_{v}\setminus L_{v,\textrm{old}}^{\textrm{<}}|<\frac{1}{20}|L_{v}|$. Furthermore,

[TABLE]

where in the last inequality we use the inequality (6). Thus $s=\min\{|\mathcal{B}_{v}\cup\mathcal{U}_{v}(L_{\textrm{old}}^{\textrm{g}})|,|L_{v,\textrm{old}}^{\textrm{<}}|+1\}\geq 1+\frac{1}{20}|L_{v}|$. This finishes the proof of the Lemma. ∎

B.4 Extension to Work for Changing $\Delta$

As we mentioned, we can extend our algorithm to work with changing $\Delta$. (A similar extension was also done in [BCHN18]). For any time stamp $t\geq 0$, we will maintain a global value $\Delta_{t}:=\max_{j=1}^{t}\max_{v\in V}\deg_{j}(v)$, where $\deg_{j}(v)$ denotes the degree of $v$ in the graph after $j$ edge updates, that is, $\Delta$ is the maximum degree seen so far (till time $t$). Then we have a randomized algorithm for maintaining a $(\Delta_{t}+1)$-coloring. More precisely, for any time stamp $j$, for each vertex $v$, we only need to guarantee that the color $\chi(v)$ is chosen from $\{1,\dots,\deg_{j}(v)+1\}$. Then for each vertex $v\in V$, we let $\mathcal{C}_{v}(\overline{H})\subseteq\mathcal{C}$ consist of all the colors in $\{1,\dots,\deg_{j}(v)+1\}$ that have not been assigned to any neighbor $u$ of $v$ for $u\in H_{v}$. It is easy to see that Lemma 3.1, 3.2 and 3.3 still hold, and our randomized dynamic coloring algorithm maintains a proper $(\Delta_{t}+1)$-coloring of the graph $G_{t}$ at time $t$ with constant amortized update time, for any $t\geq 0$.

Additionally we can keep a variable $\Delta$ such that we rebuild the data structure every $\Delta n$ operations as follows: We determine the list of current edges and set $\Delta$ to be the maximum degree of the current graph. Then we build the data structure for an empty graph and insert all edges using the insert operation. This increases the running time by an amortized constant factor and guarantees that $\Delta$ is the maximum degree in the graph within the last $\Delta n$ updates.

Appendix C A Note on Dynamically Estimating the Number of CCs

Estimating $\mathrm{ncc}(G)$ with an additive error $\varepsilon n^{O(1)}$.

We note that similar to our previous algorithm (in Section 4.3.1) for estimating $\mathrm{ncc}(G)$ with an additive error $\varepsilon T(G)$, if we simply invoke the static algorithm from Lemma 4.8 to obtain an estimator $\overline{cc}$ for the current graph and re-compute the estimator every $\Theta(\varepsilon n)$ updates, then the corresponding algorithm always maintain an estimator for $\mathrm{ncc}(G)$ with an additive error $\varepsilon n$. That is, we have the following theorem.

Theorem C.1**.**

Let $1>\varepsilon>0$ and $0<p<1$. There exists a fully dynamic algorithm that with probability at least $1-p$, maintains an estimator $\overline{cc}$ for the number $\mathrm{ncc}$ of CCs of a graph $G$ s.t., $|\overline{cc}-\mathrm{ncc}(G)|\leq\varepsilon\cdot n$. The worst-case time per update operation is $O(\max\{1,\frac{\log(1/\varepsilon)\log(1/p)}{\varepsilon^{3}n}\})$.

The following is a direct corollary of the above theorem.

Corollary C.2**.**

Let $\varepsilon>0$ and let $c$ be any constant such that $c\geq 1$. There exists a fully dynamic algorithm that with probability at least $1-\frac{1}{n^{c}}$, maintains an estimator $\overline{cc}$ for the number $\mathrm{ncc}$ of CCs of a graph $G$ s.t., $|\overline{cc}-\mathrm{ncc}(G)|\leq\varepsilon n^{2/3}\log^{2/3}n$. The worst-case time per update operation is $O(\varepsilon^{-3})$.

Proof.

If $\varepsilon<n^{-\frac{2}{3}}$, then for each update, one can use the naive BFS algorithm to exactly compute $\mathrm{ncc}(G)$, which runs in time $O(n^{2})=O(\varepsilon^{-3})$. If $\varepsilon\geq n^{-\frac{2}{3}}$, we can apply Theorem C.1 with parameters $p=\frac{1}{n^{c}}$, $\varepsilon^{\prime}=\varepsilon n^{-1/3}\cdot\log^{2/3}n$, to obtain an $\overline{cc}$ for $\mathrm{ncc}(G)$ with an additive error $\varepsilon n^{2/3}\log^{2/3}n$. The corresponding dynamic algorithm has update time $O(\varepsilon^{-3}\cdot(1+\frac{\log(1/\varepsilon)}{\log n}))=O(\varepsilon^{-3})$.∎

Remark: We cannot expect to be able to get a constant-time algorithm for maintaining the number of connected components with an additive error of $1$ or a multiplicate error of $2$: Any such algorithm would be able to decide whether the graph is connected or not, contradicting the $\Omega(\log n)$ lower bound for dynamically maintaining whether a graph is connected [PD06].