Mincut Sensitivity Data Structures for the Insertion of an Edge

Abstract

Let $G=(V,E)$ be an undirected graph on n vertices with non-negative capacities on its edges. The mincut sensitivity problem for the insertion of an edge is defined as follows. Build a compact data structure for G and a given set $S\subseteq V$ of vertices that, on receiving any edge $(x,y)\in S\times S$ of positive capacity as query input, can efficiently report the set of all pairs from $S\times S$ whose mincut value increases upon insertion of the edge (x, y) to G. The only result that exists for this problem is for a single pair of vertices (Picard and Queyranne, in: Rayward-Smith (ed) Combinatorial optimization II. Mathematical programming Studies, vol 13, no 1. Springer, Berlin, pp 8–16, 1980. https://doi.org/10.1007/BFb0120902, and dates back to 1980. We present the following results for the single source and the all-pairs versions of this problem.

• 1. Single source  Given any designated source vertex s, there exists a data structure of size ${\mathcal {O}}(|S|)$ (Data structure sizes are in words unless specified otherwise, where a word occupies $\Theta (\log n)$ bits.) that can output all those vertices from S whose mincut value to s increases upon insertion of any given edge. The time taken by the data structure to answer any query is ${\mathcal {O}}(|S|)$.

• 2. All-pairs There exists an ${\mathcal {O}}(|S|^2)$ size data structure that can output all those pairs of vertices from $S\times S$ whose mincut value increases upon insertion of any given edge. The time taken by the data structure to answer any query is ${\mathcal {O}}(k)$, where k is the number of pairs of vertices whose mincut value increases.

For both these versions, we also address the problem of reporting the values of the mincuts upon insertion of any given edge. To derive our results, we use interesting insights into the nearest and the farthest mincuts for a pair of vertices. In addition, a crucial result, that we establish and use in our data structures, is that there exists a directed acyclic graph of ${\mathcal {O}}(n)$ size that compactly stores the farthest mincuts from all vertices of V to a designated vertex s in the graph. We believe that this result is of independent interest, especially, because it also complements a previously existing result (Hariharan et al., in: Proceedings of the 39th annual ACM symposium on theory of computing, San Diego, California, USA, June 11–13, 2007, pp 605–614, 2007. https://doi.org/10.1145/1250790) that the nearest mincuts from all vertices of V to s is a laminar family, and hence, can be stored compactly in the form of a rooted tree of ${\mathcal {O}}(n)$ size.

Appendices

Appendix A

We present the details of a dynamic programming based algorithm based on Eq. 12 that uses only ${{{\mathcal {O}}}}(n)$ space to retrieve M[i, j] for any $1\le i,j\le n$. We first define a term A(i, j) for any $1\le i, j \le n$ as follows.

$$\begin{aligned} A(i,j)=\sum _{1 \le k \le i, 1 \le \ell \le j} M[k,\ell ] \end{aligned}$$

We define $A(i,j)=0$ if $i\le 0$ or $j\le 0$. Using the term A(i, j) thus defined, we can rephrase Eq. 12 as follows.

$$\begin{aligned} M[i,j] =&\, \frac{1}{2} \left( Q(u_i,u_i) + Q(u_j',u_j') - Q(u_i,u_j')\right) \nonumber \\&- \left( A(i,j-1)+A(i-1,j)-A(i-1,j-1) \right) \end{aligned}$$

(13)

We shall now use the above equation to enumerate all values of the matrix M. In this algorithm, we shall also build and use the matrix A. However, as will soon become clear, we need not keep all of A at any time. In particular, we shall need only two of its diagonals at any stage of time.

Let S(t) and R(t) be the (multi-)sets defined as follows: $S(t) = \{M[i,j]~ |~i+j=t\}$ and $R(t)=\{A(i,j)~|~i+j=t\}$. We shall enumerate S(2), S(3), and so on. For S(2), we compute M[1, 1] as described in Eq. 10. Let $t>2$ be any integer. We now present the algorithm for enumerating the elements of S(t). Let i, j be any two integers with $i+j=t$. Our algorithm makes use of Eq. 13. It makes three queries to $D(G_M)$. In addition, it retrieves $A(i,j-1),A(i-1,j), A(i-1,j-1)$. Plugging these values in Eq. 13, it computes M[i, j]. The only extra space required is for retrieving the three values of A. These values vary depending upon i and j. But the key observation is that for computing any element from S(t), we need only those values of A that belong to the set $\{A(k,\ell ) ~|~ t-2\le k+\ell \le t-1\}$. This set is precisely $R(t-2)\cup R(t-1)$. So for computing elements of S(t), we need only $R(t-2)$ and $R(t-1)$. So the extra space needed consists of only $2t-3={\mathcal {O}}(n)$ elements. While we compute S(t), we also compute the corresponding entries of A for the set R(t) (to be used for computing $S(t+1)$ in future) using the following equation.

$$\begin{aligned} A(i,j)=A(i-1,j)+A(i,j-1)-A(i-1,j-1) +M[i,j]\end{aligned}$$

We discard the set $R(t-2)$ after we have enumerated S(t). So the extra space used in the enumeration of all elements of M is ${\mathcal {O}}(n)$ only.

Appendix B

In Sect. 5.2, we presented the algorithm for computing all pairs of vertices whose mincut increases upon insertion of any query edge. The time complexity of the algorithm is ${\mathcal {O}}(k)$, where k is the number of pairs of vertices whose mincut increases upon insertion of a query edge. We now address a variant of this problem—the objective is to report the number k. For this variant, we shall design an algorithm that achieves ${\mathcal {O}}(\min (k,n\log n))$ time to answer a query. The algorithm is a slight modification of the algorithm presented in Sect. 5.2. However, to execute it and achieve the desired query time, we need to suitably augment each nearest-mincut tree ${{{\mathcal {T}}}}(z)$. First we present this augmentation, and then we present our algorithm.

1.1 Augmentation of ${{{\mathcal {T}}}}(z)$

We augment ${{{\mathcal {T}}}}(z)$ so that given any node $\nu$ and integer i, we can report the ancestor of $\nu$ at depth i in $\mathcal{T}(z)$ efficiently. For this, we employ the Level-Ancestor data structure of Bender and Colton [7]. So we can state the following theorem.

Theorem 11

We can augment ${{{\mathcal {T}}}}(z)$ so that given any node $\mu \in \mathcal{T}(z)$ and integer i, the ancestor of $\mu$ at depth i can be reported in ${\mathcal {O}}(1)$ time.

We now augment ${{{\mathcal {T}}}}(z)$ so that given any node $\mu _1$ and another node $\mu _2$ which is ancestor of $\mu _1$, we can efficiently compute the number of vertices of G that belong to the nodes lying on the path from $\mu _1$ to $\mu _2$. It is possible to accomplish this objective with ${\mathcal {O}}(\log n)$ query time without any asymptotic blow up in the size of ${{{\mathcal {T}}}}(z)$ as follows. First we introduce some notations. For a node $\mu \in \mathcal{T}(z)$, let $p(\mu )$ denote the parent of $\mu$ and let size$(\mu )$ denote the number of vertices assigned to $\mu$ (it is the same as the number of elements in list $L(\mu )$). We augment ${{{\mathcal {T}}}}(z)$ as follows.

We decompose ${{{\mathcal {T}}}}(z)$ into a collection ${{{\mathcal {H}}}}$ of vertex disjoint paths using heavy-light decomposition [34]. This decomposition ensures that for any node $\mu _1$ and another node $\mu _2$ which is an ancestor of $\mu _1$, the path from $\mu _1$ to $\mu _2$ can be expressed as a union of ${\mathcal {O}}(\log n)$ paths from ${{{\mathcal {H}}}}$. Each path in ${{{\mathcal {H}}}}$ originates from a node of ${{{\mathcal {T}}}}(z)$, called its root, and terminates at a node which is a leaf node in ${{{\mathcal {T}}}}(z)$. Furthermore, we augment each path $p\in {{{\mathcal {H}}}}$ as follows.

• For each node $\nu \in p$, we keep a field sum$(\nu )$ that stores the sum of size$(\mu )$ for each $\mu$ which is descendant of $\nu$ on path p  (in our terminology, a node is also a descendant of itself).

• For each node $\nu \in p$, we keep a field labeled jump$(\nu )$ which stores the pointer to the root of the path p.

• The root node of path p also stores a field labeled next(p) that stores the pointer to its parent in ${{{\mathcal {T}}}}(z)$.

With the above augmentation, it is an easy exercise to extract the sum of the number of vertices belonging to the nodes of path from $\mu _1$ to ancestor $\mu _2$ in ${{{\mathcal {T}}}}(z)$—we start from $\mu _1$, and traverse to $\mu _2$ using jump() and next() fields. We extract the number of vertices lying on this path using the sum() field stored at the roots of various paths and the corresponding next pointer. The total time complexity will be ${\mathcal {O}}(\min (t,\log n))$ where t is the number of nodes on the path from $u_1$ to $\mu _2$. So we can state the following theorem.

Theorem 12

We can augment ${{{\mathcal {T}}}}(z)$ so that given any node $\mu _1$ and another node $\mu _2$ which is ancestor of $\mu _1$, it takes ${\mathcal {O}}(\min (t,\log n))$ time to compute the total number of vertices present in the nodes of the path from $\mu _1$ to $\mu _2$. Here t is the number of nodes on the path from $\mu _1$ to $\mu _2$ in ${{{\mathcal {T}}}}(z)$.

1.2 The Algorithm

Interestingly, we need to just slightly modify the algorithm presented in Sect. 5.2. Suppose (x, y) is the query edge to be inserted. Recall that first we compute all vertices whose mincut to y or x increases due to insertion of (x, y). Let $Z_y$ and $Z_x$ be the set of all these vertices whose mincut to y increased. We process $Z_y$ as follows ($Z_x$ is processed in a similar manner).

Let $z\in Z_y$. Let $\mu$ be the node in ${{{\mathcal {T}}}}(z)$ to which y belongs. Recall that, exploiting Lemma 15, we perform a sequential search from $\mu$ till we reach the first ancestor of $\mu$ that has a vertex whose mincut to z does not increases. This sequential search was necessary to enumerate all vertices whose mincut to z increases upon insertion of the edge (x, y). However, if our objective is to count all vertices in $\mu$ and its ancestors whose mincut to z increases upon insertion of (x, y), there is a faster way—we do a binary search over the ancestors of $\mu$ to find the highest ancestor of $\mu$, say $\mu '$, having a vertex whose mincut to z increases upon insertion of (x, y). For carrying out the binary search efficiently, we use Theorem 11. This ensures that we take ${\mathcal {O}}(\min (t,\log n))$ time for the search of $\mu '$ where t is the number of nodes on the path from $\mu$ to $\mu '$. Once we have computed $\mu '$, we use Theorem 12 to compute the total number of vertices present in the path from $\mu$ to $\mu '$. So we spend only ${\mathcal {O}}(\min (t,\log n))$ time for tree ${{{\mathcal {T}}}}(z)$. Adding this cost for each z in $Z_y$ and $Z_x$, the total time complexity for reporting the number of pairs of vertices whose mincut increases upon insertion of edge (x, y) is thus always bounded by ${\mathcal {O}}(\min (k,n \log n))$.