Layered Graphs: Applications and Algorithms

Abstract

The computation of distances between strings has applications in molecular biology, music theory and pattern recognition. One such measure, called short reversal distance, has applications in evolutionary distance computation. It has been shown that this problem can be reduced to the computation of a maximum independent set on the corresponding graph that is constructed from the given input strings. The constructed graphs primarily fall into a class that we call layered graphs. In a layered graph, each layer refers to a subgraph containing, at most, some k vertices. The inter-layer edges are restricted to the vertices in adjacent layers. We study the MIS, MVC, MDS, MCV and MCD problems on layered graphs where MIS computes the maximum independent set; MVC computes the minimum vertex cover; MDS computes the minimum dominating set; MCV computes the minimum connected vertex cover; and MCD computes the minimum connected dominating set. MIS, MVC and MDS run in polynomial time if $k=\mathsf{\Theta }\left(\log \right|V\left|\right)$. MCV and MCD run in polynomial time if $k=O\left({\left(\log \right|V\left|\right)}^{\alpha }\right)$, where $\alpha <1$. If $k=\mathsf{\Theta }({\left(\log \right|V\left|\right)}^{1+ϵ})$, for $ϵ>0$, then MIS, MVC and MDS run in quasi-polynomial time. If $k=\mathsf{\Theta }\left(\log \right|V\left|\right)$, then MCV and MCD run in quasi-polynomial time.

1. Introduction

A string is a sequence of symbols from an alphabet $\mathsf{\Sigma }$, in which a symbol can be repeated. An adjacent swap exchanges two consecutive elements in a sequence [1,2]. In a signed string ($\pi$, ${\forall }_i\pi \left[i\right]$) the following signs are assigned: + for normal orientation and − for reverse orientation. Adjacent swap over positions $i,i+1$ are denoted by ($ii+1$). For unsigned strings ($\pi$), where $\pi$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi \left[i\right],\pi [i+1],\dots ,\pi \left[n\right]$, $\pi$ transforms into ${\pi }^{\prime }$, where ${\pi }^{\prime }$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi [i-1],\pi [i+1],\pi \left[i\right],\pi [i+2],\dots ,\pi \left[n\right]$. For signed strings ($\pi$), where $\pi$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi \left[i\right],\pi [i+1],\dots ,\pi \left[n\right]$, $\pi$ transforms into ${\pi }^{\prime }$, where ${\pi }^{\prime }$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi [i-1],-\pi [i+1],-\pi \left[i\right],\pi [i+2],\dots ,\pi \left[n\right]$. Two strings are compatible under some operation if they can be transformed into each other with the operation. That is, the unsigned string (2, 1, 3, 2) is compatible with (2, 1, 2, 3), whereas it is not compatible with (3, 2, 1, 1). The computation of the minimum number of adjacent swaps required to transform one given string into another compatible string, i.e., the adjacent swap distance, has applications in genetics and music theory [1]. A 1-flip toggles the orientation of a particular $\pi \left[i\right]$; it is denoted by $f_1\left(i\right)$. It changes the sign of $\pi \left[i\right]$. When it is applied to a signed string ($\pi$), where $\pi$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi \left[i\right],\pi [i+1],\dots ,\pi \left[n\right]$, $\pi$ transforms into ${\pi }^{\prime }$, where ${\pi }^{\prime }$ = $\pi \left[1\right],\pi \left[2\right],\pi \left[3\right],\dots ,\pi [i-1],-\pi \left[i\right],\pi [i+1],\pi [i+2],\dots ,\pi \left[n\right]$.

A short reversal is either a (1-flip) or an adjacent swap. The short reversal distance is the minimum number of short reversals required to transform a signed string into another compatible string. Two strings are compatible under short reversals if and only if their unsigned versions, i.e., the strings whose signs are disregarded, are compatible [1]. The computation of the short reversal distance between $\alpha$ and $\beta$ is reduced to the computation of the cardinality of the maximum independent set on a conflict graph constructed from $\alpha$ and $\beta$. It has applications in HOX gene clusters in vertebrate evolution [2,3]. In music theory, a composition is represented as a string. The smaller the distance between two patterns (compositions), the more similar they are [4].

The maximum independent set problem on a graph, $G=(V,E)$, seeks to identify a subset of V with maximum cardinality, such that no two vertices in the subset have an edge between them. If $V^{*}\subseteq V$ is the maximum independent set (or MIS for short) of G, then $\forall u,v\in V^{*},(u,v)\notin E$. In this article, G is undirected, so an edge $(u,v)$ is understood to be an undirected edge. Karp proposed a method for proving problems to be NP-complete [5]. The maximum independent set problem on a general graph is known to be NP-complete [6]. Certain classes of graphs have a polynomial time solution for this problem. Such algorithms are known for trees and bipartite graphs [7], chordal graphs [8], cycle graphs [9], comparability graphs [10], claw-free graphs [11], interval graphs and circular arc graphs [12]. The maximum weight independent set problem is defined on a graph where the vertices are mapped to corresponding weights. The maximum weight independent set problem seeks to identify an independent set where the sum of the weights of the vertices is maximized. On trees, the maximum weighted independent set problem can be solved in linear time [13]. Thus, for several classes of graphs, MIS can be efficiently computed.

Hsiao et al. designed an $O\left(n\right)$ time algorithm to solve the maximum weight independent set problem on an interval graph with n vertices, given its interval representation with a sorted endpoints list [14]. Several articles improved the complexity of the exponential algorithms that compute an MIS on a general graph [15,16]. Lozin and Milanic showed that MIS is polynomially solvable for the class of $S_{1,2,k}$-free planar graphs, generalizing several previously known results, where $S_{1,2,k}$ is the graph consisting of three induced paths of lengths 1, 2 and k with a common initial vertex [17].

The minimum vertex cover problem on G seeks to identify a vertex cover with minimum cardinality, i.e., minimum vertex cover or MVC. If $V^{*}\subseteq V$ is the MVC of G, then $\forall e=(u,v)\in E$, $u\in V^{*}\vee v\in V^{*}$. In this article, G is undirected, so an edge $(u,v)$ is understood to be an undirected edge. The minimum dominating set (i.e., MDS) and the minimum connected dominating set (i.e., MCD) problems seek to identify a dominating set i.e., DS and a connected dominating set i.e., CDS, respectively, with minimum cardinalities. The MVC, MDS and MCD problems on general graphs are known to be NP-complete [6]. Garey and Johnson showed that MVC is one of the first NP-complete problems [6]. In connected vertex cover problems (i.e., MCV), given a connected graph (G), a connected vertex cover (i.e., CVC) with minimum cardinality is sought. Garey and Johnson proved that MCV is NP-complete [18]. For trees and bipartite graphs, the minimum vertex cover can be identified in polynomial time [19,20]. Garey and Johnson proved that the MCV problem is NP-hard in planar graphs, with a maximum degree of 4 [6]. Li et al. proved that for 4-regular graphs, the MCV problem is NP-hard [21]. It has been shown that for series-parallel graphs, which are a set of planar graphs, the minimum vertex cover can be computed in linear time [22].

Garey and Johnson showed that the MDS problems on planar graphs with maximum vertex degree 3 and planar graphs that are regular with degree 4 are NP-complete [6]. MCD is NP-complete even for planar graphs that are regular with degree 4 [6]. Bertossi showed that the problem of identifying a MDS is NP-complete for split graphs and bipartite graphs [23]. Cockayne et al. proved that MDS in trees can be computed in linear time [24]. Baker designed various approximation algorithms for planar graphs [25]. Muller and Brandstadt showed that MDS and MCD are NP-complete for chordal bipartite graphs [26]. Ruo-Wei et al. proved that for a given circular arc graph with n sorted arcs, MCD is linear in time and space [27]. Fomin et al. proposed an algorithm with a time complexity faster than $2^n$ to solve the connected dominating set problem [28].

The term “layered graph” has been used in the literature. The hop-constrained minimum spanning tree problem related to the design of centralized telecommunication networks with quality of service (QoS) constraints is NP-hard [29]. A graph known as a layered graph was constructed from a given input graph, and the authors showed that the hop-constrained minimum spanning tree problem is equivalent to the Steiner tree problem. In software architecture, the system is divided into several layers; this has been viewed as a graph with several layers. In this article, we define a new class of graphs that we call layered graphs and design algorithms for various graph-theoretic problems.

2. Layered Graph

Consider a set of undirected graphs, $G_1,G_2,\dots ,G_q$, on the corresponding vertex sets ($V_1,V_2,\dots ,V_q$) and the edge sets ($E_1,E_2,\dots ,E_q$ i.e.,  $G_i=(V_i,E_i)$). Consider a graph, G, that is formed from ${\forall }_i{G}_i$ with special additional edges called inter-layer edges, denoted as $E_{ij}$, where $j=i+1$ and $E_{ij}$ denotes the edges between $V_i$ and $V_j$. We call such a graph a layered graph, denoted as $LG$, where the i-th layer is $G_i$. Note that for any given i, $E_{ij}$, where $j=i+1$ can be $\varphi$ and ${\forall }_{l\ne i+1}{E}_{il}=\varphi$. Every vertex within a given layer gets a label from $(1,2,3,\dots ,k)$. Thus, $V_i\subseteq \{V_{i1},V_{i2},\dots ,V_{ik}\}$. Note that $V_{ix}$ is the vertex number, x, in layer i. However, in layer i, the vertex number, x, may not exist. Further, if $(V_{ix},V_{i+1y})\in E_{ii+1}$, then it follows that vertex x is present in layer i and vertex y is present in layer $i+1$.

We defined the following restrictions on a layered graph. Several of the these restrictions can be combined. Please see Figure 1.

• If ${\forall }_i\left|V_i\right|\le k$, then a k-restricted layered graph, i.e., $L{G}_k$, is obtained. $L{G}_k^q$ denotes an $LG$ with q layers. $L{G}_k^{n,q}$ denotes an $L{G}_k^q$ with n vertices.
• If ${\forall }_t$, $(V_{it},V_{ju})$ is an inter-layer edge $\to (t=u)\wedge j\in \{i-1,i+1\}$, then a linear layered graph, i.e., $LLG$, is obtained. $LL{G}_k$ denotes an $LLG$ that is k-restricted.
• If ${\forall }_i{G}_i$ is a connected component, then a single component layered graph, i.e., $SLG$, is obtained.
• If G is required to be a connected component, then a connected layered graph, i.e., $CLG$, is obtained.

The problems of computing the adjacent swap distance between unsigned strings, adjacent swap distance between signed strings and short reversal distance were addressed in [1]. If the alphabet is $\mathsf{\Sigma }$, $\left|\mathsf{\Sigma }\right|$ is k, the source string is $\alpha$ and the destination string is $\beta$ and the length of $\alpha$ (and $\beta$) is n, a pairing diagram can be drawn for $\alpha$ and $\beta$, where all elements of $\alpha$ and $\beta$ are treated as vertices, and perfect matching is performed on all $2n$ vertices, where each edge corresponds to ($\alpha \left[i\right]$, $\beta \left[j\right]$) (here, both $\alpha \left[i\right]$, $\beta \left[j\right]$ denote the same symbol [1]). The solutions to the above problems are based on optimum pairing (in contrast to any perfect matching), where there is an edge from the i-th occurrence of a symbol x in $\alpha$ to the i-th occurrence of x in $\beta$; the corresponding pairing diagram is the optimum pairing diagram. The solutions for adjacent swap distances are complete. However, the solution suggests that the short reversal distance is partial; it can solve very few sub-cases. Several distance problems on strings have been shown to be NP-complete [30]. However, the complexity of short reversal distance problem is unknown. The short reversal distance was studied in [2]. It was shown that the edges corresponding to two consecutive occurrences of a symbol x in optimum pairing form a special edge-pair if they meet certain criteria. A conflict graph, G, is constructed from an optimum pairing diagram where a vertex denotes a special edge-pair, and an edge exists between a pair of vertices that are in conflict. The computation of the short reversal distance is reduced to the computation of MIS on G. G consists of several subgraphs, ${\forall }_i{G}_i$, each having, at most, k vertices, where each vertex corresponds to a symbol in $\mathsf{\Sigma }$. Each $G_i$ is a subgraph of the $K_k$ clique. The vertices, $u\in G_i,v\in G_j(i\ne j)$, can have a conflict only if they correspond to the same symbol. Further, they share a common edge in the optimum pairing diagram. In this particular scenario, the layered graphs arise naturally. Further, such layered graphs are LLGs. In this framework, the computation of MIS on a LLG is a necessary component in the computation of the corresponding short reversal distance.

Considering a tribal society S consisting of some villages on a bank of a river, a village consists of a few families where each family has its own family-head. The family-heads of a given village know one another, and they also interact with specific family-heads of adjacent villages for trade (of produce) and partnership (collaboration in farming etc.). If one models this society as a social network, where a family-head is denoted by a vertex and an interaction (among family-heads) is denoted by an edge, then one obtains a layered graph. In this social network, identifying the smallest set of influencers is a natural pursuit (whose solution is given by computing MDS). These applications motivate the study of MIS, MDS and other graph theoretic problems on layered graphs. In general, graph theoretic problems, like subgraph isomorphism, and its variations have extensive applications in computational biology, e.g., references [31,32].

This article designs algorithms for $L{G}_k$ where every vertex within a given layer gets a label from $\{1,2,3,\dots ,k\}$. The results are applicable for any restrictions of $L{G}_k$, like $LLG$, $SLG$, etc. Consider a layered graph, G, whose first a layers and last b layers do not have any edges. The graph is not a $CLG$; however, the MCV of G is the same as the MCV of the subgraph where the first a and the last b layers are removed. Further, if every layer has at least one intra-layer edge, then MCV can be computed only on $CLG$. MCD is well defined only for $CLG$ because it must dominate all vertices.

The complete graph on k vertices, a clique on k vertices, is denoted by $K_k$. Consider a graph, G, formed from several copies of $K_k$, say $G_1,G_2,\dots ,G_q$, where, in addition to the edges that exist in each of $G_i$, an edge is introduced between every pair, $uv$: $u\in G_i$ and $v\in G_{i+1}$. We denote this particular graph, G, that has q layers with $K_k^q$. The class of k-restricted layered graphs are in fact subgraphs of $K_k^q$. Thus, we call $K_k^q$ a full $L{G}_k^q$. Likewise, a $LLG$ that is defined on q cliques, where  for any $i,i+1$, for all values of l, an edge is introduced between vertex l of layer i and vertex l of layer $i+1$, is called a full$LL{G}_k^q$. The number of layers in $L{G}_k$ i.e., q is bound by $n/k\le q\le n$.

A subgraph of G induced by vertices $u_1,u_2,\dots ,u_i$ consists of all vertices ($u_1,u_2,\dots ,u_i$) and all the edges restricted to them. We designed algorithms that compute the cardinalities of MVC, MIS and MDS of any subgraph of $K_k^q$ i.e., $L{G}_k^{n,q}$ in polynomial time when $k=O\left(\log n\right)$ and the cardinalities of MCV and MCD in polynomial time when $k=O\left({\left(\log n\right)}^{\alpha }\right)$, $\alpha <1$. Additionally, these algorithms report the corresponding numbers of MISs, MVCs, MDSs, MCVs and MCDs in $L{G}_k^{n,q}$.

3. Algorithm

Consider a layered graph with q layers, i.e., $L{G}_k^{n,q}$ with layers $(1,2,3,\dots ,q)$. We designed a generic dynamic programming algorithm for all of the problems. However, certain restrictions exist corresponding to the problem at hand. The specific details pertaining to each problem are elucidated along with its solution. For example, MCD is meaningful only when the underlying graph is connected, i.e., the input graph is restricted to $CLG$.

We denoted the vertices chosen in a particular layer with a k-bit variable that we called $mask$. The pth bit of the mask was set to one to include the pth vertex. Otherwise, the bit was set to zero and the vertex was excluded. Let $S={\bigcup }_{i=1}^q{V}_i^{*}$ be a candidate solution for a problem where $V_i^{*}$ denotes the set of nodes that are chosen from layer i. The candidate sub-solution for layer i is denoted $c{s}_i$. For layers $1,\dots ,i$, a combined candidate sub-solution is maintained, denoted $cc{s}_i$. Likewise, $c{s}_{i,j}$ and $cc{s}_{i,j}$ denote the sub-solutions (of layer i and first i layers respectively), where the vertices chosen from layer i are denoted by mask j. Only the cardinality of the best options is stored; such cardinality is called an optimum value. This is stored in the variable $so{l}_{i,j}$, and the corresponding number of solutions that yield the optimum value is stored in $coun{t}_{i,j}$. In this article, an optimal solution is a solution that corresponds to the optimum value. We say that $c{s}_{i,j}$ and $cc{s}_{i-1,l}$ are compatible if $c{s}_{i,j}\bigcup cc{s}_{i-1,l}\in cc{s}_{i,j}$. That is, the union of $c{s}_{i,j}$ and $cc{s}_{i-1,l}$ yields a $ccs$ for the first i layers. Note that compatibility is determined by $c{s}_{i,j}$ and $c{s}_{i-1,l}\in cc{s}_{i-1,l}$, and the vertices chosen by $cc{s}_{i-1,l}$ in the earlier layers are irrelevant. This is a key feature.

3.1. Input

The input consists of $L{G}_k^{n,q}$ which is specified in terms of $M_1,\dots ,M_q$ and $I_1,\dots ,I_{q-1}$, where $M_i$ is the 0–1 adjacency matrix for layer i, i.e., $G_i$. $I_i$ is the 0–1 adjacency matrix for $E_{i,i+1}$. Rows $1,2,\dots ,k$ of $I_i$ correspond to vertices $V_{i1},V_{i2},\dots ,V_{ik}$, and columns $1,2,\dots ,k$ of $I_i$ are vertices $V_{i+11},V_{i+12},\dots ,V_{i+1k}$. It must be noted that for a linear graph, $I_i$ can just be a k dimensional vector and the corresponding computation is less expensive where $I_i\left[a\right]=1\iff$ an edge between $a\in V_i,a\in V_{i+1}$ exists. The adjacency matrix $M_i$, for layer i, is a matrix of dimensions $k\times k$, which means it requires $O\left(k^2\right)$ space. Similarly, each $G_i$ also requires $O\left(k^2\right)$ space. Therefore, the total space required for the input graph is $O\left(nk\right)$, since each layer requires $O\left(k^2\right)$ space, and there are $O(n/k)$ layers.

The Boolean valued function compatible (please see Algorithm 1) determines whether the candidate sub-solutions (of the current layer and the subgraph induced by vertices of all previous layers) can be combined; here, the layer number, i, is implicit. For each mask, j, of a given layer, i, the function $valid(i,j)$ determines if j is a feasible option for layer i. The helper function, $cardinality\left(j\right)$, returns the number of bits that are set in the binary representation of mask j.

All algorithms consist of the following sequence of computational tasks:

• Repeat (i) and (ii) for all layers $1,\dots ,q-1$.
• (i) Feasible: ${\forall }_j$ (if $valid(i,j)$), then go to step(ii).
• (ii) Extension: If j and l are compatible, then store the cardinality of $c{s}_{i,j}\bigcup cc{s}_{i-1,l}$ in $so{l}_{i,j}$ and the count of $cc{s}_{i,j}$ in $coun{t}_{i,j}$.
• (iii) Summarize: At layer $q:$, execute (i) and (ii). Identify the optimum cardinality among ${\forall }_{j}so{l}_{q,j}$ and the corresponding count.

A particular problem has specific characteristics. In the sequel, where a problem is dealt with in detail, the corresponding validity/compatibility and other specifics are elucidated.

Algorithm 1 Compatible Algorithm

Input: $L{G}_k$, j, l, and I.                                       //The function call: $compatible(j,l)$. l: Mask for layer i.   Output: 0 (incompatible) or 1 (compatible). //j: Mask for layer $i+1$. I denotes matrix for $E_{ii+1}$.                                                                               // $bi{t}_c\left(i\right)$ returns true if bit c is set in i, otherwise, it returns false. Case MIS:                            // Input: two valid MISs of two adjacent layers   if $independent(j,l)$ then   // $independent(j,l)$: for any $a,b:$$bi{t}_a\left(l\right)$ and $bi{t}_b\left(j\right)$:       return 1;                       //if $I\left[a\right]\left[b\right]=1$, return 0; otherwise, return 1; $O\left(k^2\right)$ algorithm.   else      return 0;                   //∃ a pair of vertices across the layers joined with an edge.   end if Case MVC:                      // Input: two VCs of two adjacent layers   if $cover(j,l)$ then            // $cover(j,l)$: ${\forall }_{a,b}$ where $I\left[a\right]\left[b\right]=1$: $bi{t}_a\left(l\right)\vee bi{t}_b\left(j\right)=1$       return 1;                    // then return 1; otherwise, return 0; $O\left(k^2\right)$ algorithm.   else      return 0;   end if Case MCV:                      // Input: two masks of two adjacent layers; need not be MCVs of their respective layers.   if $ccover(j,l)$ then       // $ccover(j,l)$: ${\forall }_{a,b}$ where $I\left[a\right]\left[b\right]=1$: $bi{t}_a\left(l\right)\vee bi{t}_b\left(j\right)=1$       return 1;                 // and for each component of l, $\exists c\in l$: $({\exists }_d:I\left[c\right]\left[d\right]=1)\wedge (bi{t}_d\left(j\right)=1)$   else                               // then return 1; otherwise, return 0; $O\left(k^2\right)$ algorithm.       return 0;   end if Case MDS:                      // Input: two masks of two adjacent layers,   if $dom(j,l)$ then             // $dom(j,l)$: $D\leftarrow c{s}_{i,l}\bigcup c{s}_{i+1,j}\bigcup Adj\left(c{s}_{i,l}\right)\bigcup Adj\left(c{s}_{i+1,j}\right)$       return 1;                   // $i<q-1$: if $V_i\subseteq D$, then return 1; otherwise, return 0;   else                                // $i=q-1$: if $V_i\bigcup V_{i+1}\subseteq D$, then return 1; otherwise, return 0;       return 0;                  //$V_i$ or $V_i\bigcup V_{i+1}$ is not dominated. $O\left(k^2\right)$ algorithm.   end if                           // $Adj\left(V\right)$ is the set of all vertices neighboring any vertex in V   Case MCD:                 // Input: two masks of two adjacent layers,                                        // For each component of l, $\exists c\in l$: $({\exists }_d:I\left[c\right]\left[d\right]=1)\wedge (bi{t}_d\left(j\right)=1)$   if $dom(j,l)$ then        // $dom(j,l)$: $D\leftarrow c{s}_{i,l}\bigcup c{s}_{i+1,j}\bigcup Adj\left(c{s}_{i,l}\right)\bigcup Adj\left(c{s}_{i+1,j}\right)$       return 1;               // $i<q-1$: if $V_i\subseteq D$ then return 1; otherwise return 0;   else                            // $i=q-1$: if $V_i\bigcup V_{i+1}\subseteq D$ then return 1; otherwise return 0;       return 0;              //$V_i$ or $V_i\bigcup V_{i+1}$ is not dominated. $O\left(k^2\right)$ algorithm.   end if                        // $Adj\left(V\right)$ is the set of all vertices neighboring any vertex in V

3.2. MIS

Consider the structure of an MIS on $L{G}_k^{n,q}$. Say, $V^{*}={\bigcup }_{j=1}^q{V}_j^{*}$ where $V_j^{*}$ are the vertices in MIS from layer j. Clearly, $V_j^{*}$ must be an independent set. (please see Figure 2). Let $G_1$ be the subgraph of $L{G}_k^{n,q}$ induced by $V^1={\bigcup }_{j=1}^i{V}_j$, and let $G_2$ be the subgraph of $L{G}_k^{n,q}$ induced by $V^2={\bigcup }_{j=i+1}^q{V}_j$. Consider the IS of G. If $M_1={\bigcup }_{j=1}^i{V}_j^{*}$ and $M_2={\bigcup }_{j=i+1}^q{V}_j^{*}$, then $M_1$ and $M_2$ are ISs. Let the set of edges crossing the cut, $C=(M_1,M_2)$, be $E^C$. It follows that $M_1\bigcup M_2$ is an IS of G with cardinality $\left|M_1\right|+\left|M_2\right|$ when there is no edge crossing C. Only the edges in $E_{ii+1}$ need to be considered. Thus, the cardinality of an MIS of $L{G}_k^{n,q}$ is equal to $max\left({\forall }_{E^C=\varphi }\right|M_1|+|M_2\left|\right)$.

• $feasible\left(j\right)$: The mask j must denote an IS for $G_i$.
• $compatible(j,l)$: The union of two ISs must be an IS.
• Extension: If $(cardinality\left(j\right)+so{l}_{i-1,l}>so{l}_{i,j})$$so{l}_{i,j}\leftarrow cardinality\left(j\right)+so{l}_{i-1,l}$.
• Summarize: Let $opt\leftarrow max\left({\forall }_{j}so{l}_{q,j}\right)$; $count\leftarrow 0$; ${\forall }_{j}if(so{l}_{q,j}=opt)count\leftarrow count+coun{t}_{q,j}$; Return $(opt,coun{t}_{q,j}))$

3.3. MVC and MCV

Consider a vertex cover $V^{*}={\bigcup }_{j=1}^q{V}_j^{*}$ of $L{G}_k^{n,q}$ where $V_j^{*}$ denotes the set of vertices in $V^{*}$ from layer j. Clearly, $V_j^{*}$ is a VC for layer j (please see Figure 3). $V_j^{*}$ depends only on $V_{j-1}^{*}$ and $V_{j+1}^{*}$. Consider two adjacent layers, p and $p+1$. $V_p^{*}\bigcup V_{p+1}^{*}$ must cover all inter-layer edges between layers p and $p+1$. Specifically, $V^{*}={\bigcup }_{j=1}^{p+1}{V}_j^{*}$ must cover all edges in the corresponding induced subgraph, including $E_{pp+1}$. Similar constraints hold for MCV. Additionally, for MCV, the induced subgraph of $V^{*}$ must be a connected component (please see Figure 4). In the sequel, the time and space complexity analyses for these problems are presented.

Clearly, each layer must choose a mask that is a VC. In the case of MCV, when considering a mask, j, for the current layer, i, the following cases exist:

(a)

The previous layer mask, l, corresponds to one component.

(b)

l has more than one component, i.e., the set of vertices denoting l is partitioned into several connected components.

Case (a): For layer i, mask j is infeasible if either (I) vertices corresponding to j and l have no edges among them or (II) all edges in $I_i$ are not covered. Otherwise, j is feasible. If at least one edge exists across j and l:

(i)

If j is a single connected component, then the result is also a single component (consisting of all chosen vertices).

(ii)

If j has more than one connected component and all of them connect to l, then the result is also a single component.

(iii)

If j has more than one connected component and only some of them connect to l, then the result consists of many components. All components from j connected to l become one component and the rest are separate components.

Case (b): Every component from the previous layer corresponding to mask l must connect to some component in the current layer. Otherwise, the pair j and l is infeasible for layer i. For feasible pairs the following possibilities exist:

(i)

Every component in l has an edge with exactly one component in j. Here, the partition is determined by j.

(ii)

A component, C, in l has edges with $C_1,\dots ,C_a$ in j. Then, $C_1,\dots ,C_a$ can be merged into one component as they are connected through C.

A particular partitioning of the current layer can occur due to various choices of l. For each partition corresponding to j, the sub-solution is stored with minimum cardinality. Thus, for each mask, j, there are, at most, $B_k$ (k-th Bell number) solutions stored. When mask x is chosen for the last layer, then the vertices of the mask must be connected to the components of the previous layer and yield a single component.

• $feasible\left(j\right)$: Mask j must denote a VC for $G_i$.
• $compatible(j,l)$: The union of two VCs must be a VC for edges in $G_{i-1},G_i$ and $I_{i-1}$. i is the current layer. For MCV, all components of l must have edges with vertices in j. If $i=q$, then $V^{*}$ must be one component.
• Extension: If $(cardinality\left(j\right)+so{l}_{i-1,l}<so{l}_{i,j})$$so{l}_{i,j}\leftarrow cardinality\left(j\right)+so{l}_{i-1,l}$.
• Summarize: Let $opt\leftarrow min\left({\forall }_{j}so{l}_{q,j}\right)$; $count\leftarrow 0$; ${\forall }_{j}if(so{l}_{q,j}=opt)count\leftarrow count+coun{t}_{q,j}$; Return $(opt,count)$

3.4. MDS and MCD

Let an MDS of $L{G}_k^{n,q}$ be $V^{*}$, such that, $V^{*}={\bigcup }_{j=1}^q{V}_j^{*}$, where $V_j^{*}$ represents the vertices in this MDS from layer j. Clearly, $V_j^{*}$ may not be a dominating set of layer j because the vertices of $V_j$ can be dominated by any subset of $V_{j-1}^{*}\bigcup V_j^{*}\bigcup V_{j+1}^{*}$. In Figure 5, $e\in G_2$ is dominated by $d\in G_1$. It follows that ${\bigcup }_{j=1}^{p+1}{V}_j^{*}$ must dominate all vertices in ${\bigcup }_{j=1}^p{V}_j$. Further, $V^{*}={\bigcup }_{j=1}^{q-1}{V}_j^{*}\bigcup V_q^{*}$ must dominate ${\bigcup }_{j=1}^q{V}_j$. A vertex that is not dominated is undominated.

Consider mask j in layer i, where $c{s}_{i,j}\bigcup cc{s}_{i-1,l}$ dominates layer $i-1$. This particular subset of vertices can leave some vertices in layer i undominated. The number of such choices is $2^k$; each choice is denoted by a k-bit variable that we call a mask—here, a mask of exclusion. Further, when one processes layer $i+1$, this information is critical. We show that the $O\left(2^k\right)$ triples stored for each mask of a given layer suffice to compute MDS of $L{G}_k$. For a chosen mask, j, in layer i, it suffices to store $2^k$ triples of the form $(u,s,c)$. Here, u is the mask of the vertices that are undominated in layer i, s is the cardinality of the vertices chosen so far and c is the number of choices corresponding to u for a particular j in layer i.

MCD has an additional requirement compared to MDS, i.e., $V^{*}$ must form a single component (please see Figure 6). For possible combinations of component layouts of the current and previous layer masks, see MCV. For MCD, it suffices to store $O\left(B_k{2}^k\right)$ triples of the form $(lo,un,r)$, where $B_k$ is the k-th Bell number. This corresponds to $O\left(B_k\right)$ component layouts, $lo$, for a mask, j, and $O\left(2^k\right)$ masks $un$ of the vertices that are not dominated in layer i and $O\left(2^k\right)$ triples r of the form $(m,s,c)$ for every unique pair of $(lo,un)$. Here, m is the mask of the current layer that produces the respective $(lo,un)$ pair, i.e., mask j, while s and c are same as that for MDS, corresponding to mask m and pair $(lo,un)$. The particular mask in the previous layer that is the cause of a particular triple in the current layer needs not be carried forward. So, for MDS, $so{l}_{i,j}$ indicates an array of $2^k$ triples. As for MCD, it indicates $O\left(B_k{2}^k\right)$ triples where $O\left(2^k\right)$ triples are associated with each of the $O\left(B_k{2}^k\right)$ unique pairs of $(lo,un)$. Also, when $k=O\left(\log n\right)$ for MDS and $k=O{\left(\log n\right)}^{\alpha }$ where $\alpha <1$ for MCD, the algorithm runs in polynomial time.

Consider the following analysis for MDS. Let mask j be chosen in layer i; it can potentially be combined with every mask ($O\left(2^k\right)$ masks) of the previous layer. Thus, potentially, ($O\left(2^k\right)$) triples need be stored. Further, the total number of triples of the form $(un,s,c)$ is $\mathsf{\Omega }(n.2^k)$, because $un$ can potentially assume any $0,\dots ,2^k-1$; s is $O\left(n\right)$ and c can, in fact, be exponential in $\frac{n}{k}$. Here, we make the following critical observations:

• Let the chosen mask for layer i be j. When all the compatible vertex sets of the previous layer are considered, then let the resultant triples for the choice of j in layer i be set as S.
• In S, for any two triples with the same mask, we need only to retain the triples with the smallest size. The other triples cannot lead to an optimal solution.
• If two triples have the same mask and the minimum size, then they can be combined into one triple where the respective counts are added.
• Thus, only $2^k$ triples suffice for a chosen mask for layer i which implies $2^{2k}$ triples suffice ${\forall }_{j}c{s}_{i,j}$. The information of only two layers is stored. Thus, the algorithm needs $O\left(k{2}^{2k}\right)$ space. This is in addition to the space required by the input graph, which is $O\left(nk\right)$. For $k=O\left(\log n\right)$, $O\left(k{2}^{2k}\right)$ is the dominating term, so the space complexity is $O\left(k{2}^{2k}\right)$.
• Thus, for a chosen mask for layer i, potentially $2^{2k}$ triples of the previous layer must be processed. That is, for all masks of layer i, a total of $2^{3k}$ triples must be processed.
• Consider mask j in layer i and mask l in layer $i-1$. Recall that there are $2^k$ triples stored corresponding to mask l in layer $i-1$. All the vertices that are covered by the combination of j and l in layer $i-1$, say A, and not covered in layer i, say B, can be computed in $O\left(k^2\right)$. This needs to be computed only once. Subsequently, for each of the triples stored corresponding to l in layer $i-1$, we need only to check if the undominated vertices are a subset of B in $O\left(k\right)$ time. Thus, $O\left(k{2}^k\right)$ is the dominating term in the time complexity, yielding $O\left(k{2}^{2k}\right)$ for all masks in the previous layer. So, for all masks in the current layer, the time complexity is $O\left(k{2}^{3k}\right)$. Thus, the time complexity of the algorithm is $O\left(\frac{n}{k}k{2}^{3k}\right)=O\left(n{2}^{3k}\right)$.

Similar constraints hold for MCD. We carry forward the existing connected components, and eventually, when the final layer is processed, all the components must be connected. The MCD algorithm is explained in detail in Theorem 4 along with time and space complexity analyses. The current layer in the following functions is i.

• $feasible\left(j\right)$: Any j is valid.
• $compatible(j,l)$: Tthe union must dominate all vertices of $V_{i-1}$. For MCD, all components of l must have edges with vertices in j. If $i=q$, then $V^{*}$ must be one component and it must dominate $V_q$ also.
• Extension: Performed as per the observations listed above.
• Summarize: Let $opt\leftarrow min\left({\forall }_j{\forall }_{d}siz{e}_{q,j,d}\right)$; $count\leftarrow 0$; ${\forall }_j{\forall }_d$ if $(siz{e}_{q,j,d}=opt)$ then $count\leftarrow count+ccoun{t}_{q,j,d}$; return $(opt,count)$.

3.5. Compatible Algorithm

Given candidate sub-solutions for consecutive layers one must determine if their union is a feasible sub-solution. The following algorithm determines the same for the problems addressed in this article.

3.6. Generic Optimum Algorithm

The algorithms (please see Algorithm 2) for the MIS, MVC and MDS problems on $L{G}_k^{n,q}$ are similar, while those for MCV and MCD must additionally ensure connectedness criterion. We give a generic dynamic programming based algorithm for both sets of problems. Some specific instances are shown in Appendix A.

Initialization: $\forall iso{l}_{0i}=so{l}_{1i}=0$; $\forall icoun{t}_{0i}=coun{t}_{1i}=0$; $so{l}_{ij}:$ The optimum value (of IS, VC, MCD, etc.) up to layer i, where the chosen vertices of layer i are given by the binary value of j. $coun{t}_{ij}:$ The number of ways that the j-th mask in layer i yields the corresponding optimum value.

Algorithm 2 Generic Optimum Algorithm

Input: $L{G}_k^{n,q}$   Output: The cardinality and corresponding count for the respective problem.   for ($i=0,...,2^k-1$) do       if $valid(1,i)$ then //for layer 1            $coun{t}_{0i}=1;so{l}_{0i}=cardinality\left(i\right);$ // For all valid masks, set their count       end if  end for  for ($i=2,...,q$) do //For layers 2 through maximum       for $(j=0,...,2^k-1)$ do //For all masks of the current layer            Compose larger sub-solutions by considering all compatible masks of the              previous layer and any accompanying information.       end for//Masks of previous layer   end for//For all layers, The current layer being processed is the final layer.   $best\leftarrow 0;sum\leftarrow 0;$   for ($i=0,...,2^k-1$) do       Identify $best$, the cardinality of an optimal solution.   end for  for ($i=0,...,2^k-1$) do       Compute $sum$, the count of the optimal solutions.   end for  $return(best,sum)$

4. Correctness and Complexity

The Algorithm Generic Optimum when adapted to a specific problem, say MVC, is referred to as Algorithm MVC. The correctness is shown for MIS, MVC and MCD problems. The time complexities for MIS, MVC, and MDS are respectively $O\left(nk{2}^{2k}\right)$, $O\left(nk{2}^{2k}\right)$ and $O\left(n{2}^{3k}\right)$, where $k=O\left(\log n\right)$. When $k=\log n$ these time complexities yield $O\left(n^{3}k\right)$, $O\left(n^{3}k\right)$ and $O\left(n^4\right)$ respectively. The space complexities are $O\left(nk\right)$, $O\left(nk\right)$ and $O\left(k{2}^{2k}\right)$ respectively. When $k=\log n$ these space complexities yield $O\left(nk\right)$, $O\left(nk\right)$ and $O\left(k{n}^2\right)$ respectively. For MCV and MCD problems, the time complexity is $O\left(n^{1+ϵ}\right)$ for any $ϵ>0$, where the number of vertices in a layer is $k=O\left({\left(\log n\right)}^{\alpha }\right)$ for $\alpha <1$. The space complexity is $O\left(nk\right)$ for MCD and MCV. The time and space complexities of MVC and MCD are analyzed. The proofs of correctness for the remaining problems are similar. The time complexity for MDS was presented earlier.

Theorem 1.

The MIS Algorithm correctly computes the MIS on $L{G}_k^{n,q}$.

Proof. 

Let $G=(V,E)$ be a graph and let V be partitioned into $V^1,V^2$. Further, let $I_1,I_2$ be the ISs of the graphs induced by $V^1,V^2$, respectively, and let $I=I_1\bigcup I_2$. If we consider the cut, $C=(I_1,I_2)$, on I, where $E^C$ is the set of edges crossing the cut, then it follows that I is an IS of G if $E^C=\varphi$. Further, the cardinality of an MIS of G is $max({\forall }_{E^C=\varphi }|I_1|+|I_2|)$. It is possible that either $\left|I_1\right|=0$ or $\left|I_2\right|=0$.

Let G be $L{G}_k^{n,q}$. Let $G_1$ be the subgraph of $L{G}_k^{n,q}$ induced by $V^1={\bigcup }_{j=1}^i{V}_j$, and let $G_2$ be the subgraph of $L{G}_k^{n,q}$, induced by $V^2={\bigcup }_{j=i+1}^q{V}_j$. Consider the IS of G. Let $I_1$ and $I_2$ be the independent sets of $G_1$ and $G_2$, respectively. Let the set of edges crossing the cut, $C=(I_1,I_2)$, be $E^C$. It follows that $I=I_1\bigcup I_2$ is an IS of G with cardinality $\left|I_1\right|+\left|I_2\right|$ when there is no edge crossing C. Only the edges in $E_{ii+1}$ need to be considered. Thus, the cardinality of an MIS of $L{G}_k^{n,q}$ is equal to $max({\forall }_{E^C=\varphi }|I_1|+|I_2|)$. When the last layer is processed, the cardinalities of the ISs of subgraphs induced by both V and $V-V_q$ are known. Further, these ISs have maximum cardinalities with respect to the vertices chosen in layers $q-1$ and q, respectively. The theorem follows. Likewise, $coun{t}_{ij}$ gives the number of ways that an independent set of maximum cardinality can be formed when the vertices chosen in layer i are given by j. Thus, the $coun{t}_{qj}$ corresponding to the maximum value of $so{l}_{qj}$ yields the total number of MISs. ☐

Theorem 2.

The MVC Algorithm correctly computes the MVC on $L{G}_k^{n,q}$.

Proof. 

Consider the structure of MVC on $L{G}_k^{n,q}$. Let $G_1$ be the subgraph of $L{G}_k^{n,q}$ induced by $V^1={\bigcup }_{j=1}^i{V}_j$, and let $G_2$ be the subgraph of $L{G}_k^{n,q}$ induced by $V^2={\bigcup }_{j=i+1}^q{V}_j$. Consider a VC of G. Let $M_1$ and $M_2$ be the vertex covers of $G_1$ and $G_2$, respectively. Let the set of edges crossing the cut, $C=(M_1,M_2)$, be $E^C$. It follows that the cardinality of a VC of G is $\left|M_1\right|+\left|M_2\right|$ when every edge crossing C is covered by either $M_1$ or $M_2$. Note that the only edges from $E_{ii+1}=E^C$ can go across the cut. Thus, the cardinality of the MVC of $L{G}_k^{n,q}$ is equal to $min\left(\right|M_1|+|M_2\left|\right)$ for any such cut. When the last layer is processed, this property is ensured. The theorem follows. Similarly, $coun{t}_{ij}$ gives the number of ways that a vertex cover of minimum cardinality can be formed when the vertices chosen in the layer i are given by j. Thus, $coun{t}_{qj}$ corresponding to the minimum value of $so{l}_{qj}$ yields the total number of MVCs. ☐

Theorem 3.

The MVC Algorithm on $L{G}_k^{n,q}$ runs in polynomial time in n when $k=O\left(\log n\right)$. The space required is $O\left(nk\right)$.

Proof. 

We presume that $I_i$, the 0–1 adjacency matrix for the subgraph induced by $V_i\bigcup V_{i+1}$ where the edges are restricted to $E_{ii+1}$ is given. Likewise, we assume that the 0–1 adjacency matrix, $M_i$, for each of $G_i$ is given. Recall that $L{G}_k^{n,q}$ was formed from $G_1,G_2,\dots ,G_q$. For a linear graph, $I_i$ is just a $k$-dimensional vector where, if bit j is set, then there is an edge between $V_{ij}$ and $V_{i+1j}$.

• The initialization step requires $O\left(2^k\right)$ time.
• Given a mask for layer i, it can be determined whether VC is valid in $O\left(k^2\right)$ time with $M_i$. That is, for any two $M_i\left[a\right]\left[b\right]$ that are set, the mask should have either a bit a or a bit b set.
• Given $I_i$ and two masks, $mask1$ and $mask2$, for layers i and $i+1$, respectively, it can be directly determined whether the union of the two masks is a VC of the subgraph induced by ${\bigcup }_i^{i+1}{V}_j$, of $L{G}_k^{n,q}$, in $O\left(k^2\right)$ time.
• In order to determine the MVC up to layer i, whose mask is j, j must be checked for compatibility with all masks of the previous layer. Thus, $O\left(k^2{2}^k\right)$ time is required. For all masks of the current layer, $O\left(k^2{2}^{2k}\right)$, time is required. For all layers, the time required is maximized when each layer has k vertices yielding $O\left(\frac{n}{k}{k}^2{2}^{2k}\right)$ = $O\left(nk{2}^{2k}\right)$ time.

The time complexity is clearly exponential in k; however, if $k=O\left(1\right)$, the time complexity is $O\left(n\right)$. The time complexity remains polynomial when $k=O\left(\log n\right)$; specifically, $O\left(n^3\log n\right)$ when $k=\log n$. The additional space required is $O\left(k{2}^k\right)$ because for two layers, ${4.2}^k$ masks and count variables are stored, each of size k. The space required is $O\left(nk\right)$ to store the graph and an additional space of $O\left(k{2}^k\right)$ that is needed by the algorithm. When $k=O\left(\log n\right)$, the space complexity is $O\left(nk\right)$. ☐

Lemma 1.

Let $0\le \alpha <1.0$, where $\alpha \in R^{+}$. If $x={\left(\log n\right)}^{\alpha }$, then $x!=O\left(n^{ϵ}\right)$ for any $ϵ>0$.

Proof. 

Let $f\left(n\right)={\left(\log n\right)}^{\alpha }$, $\alpha <1$. Let $h\left(n\right)=n^{ϵ},ϵ>0$.

Thus, $f\left(n\right)!={\left(\log n\right)}^{\alpha }!$. Taking log on both sides we obtain:

$$\begin{array}{cc}\hfill \log \left(\lceil f\left(n\right)!\rceil \right)& =\log 1+\log 2+\cdots +\log (\lceil {\left(\log n\right)}^{\alpha }\rceil )\hfill \\ & =\sum _{x=1}^{\lceil {\left(\log n\right)}^{\alpha }\rceil }\log x\hfill \\ & \approx {\int }_1^{{\left(\log n\right)}^{\alpha }}\log xdx\hfill \\ & ={[x\log x-x]}_1^{{\left(\log n\right)}^{\alpha }}\hfill \\ & =\alpha {\left(\log n\right)}^{\alpha }\log \log n-{\left(\log n\right)}^{\alpha }+1\hfill \end{array}$$

Disregarding smaller order terms we obtain the expression: ${\left(\log n\right)}^{\alpha }\left(\alpha \log \log n\right)$ $\alpha \log \log n$ = $\log \left({\left(\log n\right)}^{\alpha }\right)$. Note that $\log n=O\left(n^{\mu }\right)$ for any $\mu >0$. Thus, ${\left(\log n\right)}^{\alpha }\left(\alpha \log \log n\right)<\left({\left(\log n\right)}^{\alpha }\right){)}^{(1+\mu )}$ for any $\mu >0$. Given that $\alpha <1$ one can always choose $\mu$ such that $\alpha +\alpha \mu <1$. Thus, the expression is $O\left(\log n\right)=O\left(n^{ϵ}\right)$ for any $ϵ>0$.

Thus, ${\left(\log n\right)}^{\alpha }!=O\left(n^{ϵ}\right)$. ☐

Lemma 2.

$\left(\log n\right)!$ is quasi-polynomial and $\left(\log n\right)!=n^{O(\log \log n})$.

Proof. 

From Stirling’s Approximation, we have $\log \left(\right(\log n)!)\approx \theta \left(\log n\log \log n\right)$

$$\begin{array}{c}\hfill \Rightarrow \left(\log n\right)!\approx e^{\theta \left(\log n\log \log n\right)}\end{array}$$

Thus, for some constants $\mu$ and $\delta$, $\left(n^{\delta \log \log n}\right)\le (\left(\log n\right)!)\le \left(n^{\mu \log \log n}\right)$

Thus, $\left(f\right(n)!)$ is quasi-polynomial. ☐

Lemma 3.

If $k=\mathsf{\Theta }({\left(\log n\right)}^{1+ϵ})$, for any $ϵ>0$ then, the MIS Algorithm, MVC Algorithm and MDS Algorithm run in quasi-polynomial time.

Proof. 

The time complexities of all these algorithms can be written as $O\left(f\left(n\right)g\left(k\right)2^{ck}\right)$, where $f\left(n\right)=\mathsf{\Theta }\left(n\right)$, $g\left(k\right)=O\left(k\right)$ and $c=O\left(1\right)$. Thus, when $k=\mathsf{\Theta }({\left(\log n\right)}^{1+ϵ})$ for $ϵ>0$, the complexities for all the algorithms will be quasi-polynomial. ☐

Theorem 4.

The MCD Algorithm correctly computes the cardinality of a connected minimum dominating set for $L{G}_k$ with a time complexity of $O\left(n^{1+ϵ}\right)$ for any $ϵ>0$ when $k=O{\left(\log n\right)}^{\alpha }$ and $\alpha <1$. The space complexity of the algorithm is $O\left(nk\right)$.

Proof. 

First, we show that the algorithm correctly computes the cardinality of a connected minimum dominating set. Consider the structure of CDS on a connected graph, G. Let V be arbitrarily partitioned into $V^1,V^2$, where both $\left|V^1\right|>0$ and $\left|V^2\right|>0$. Let $G_1$ be the subgraph of G induced by $V^1$, and let $G_2$ be the subgraph of G induced by $V^2$. Let $M_1\subseteq V^1$ and $M_2\subseteq V^2$ be DSs of $G_1$ and $G_2$. Let C be the cut $(M_1,M_2)$ and let $E^C$ be the edges that cross this cut. Clearly, $M=M_1\bigcup M_2$ is DS for G. Further, M is a CDS for G if $\left|E^C\right|>0$, and M forms a connected component in G. For a given partition $V^1,V^2$ of V, M is a MCD if it minimizes $\left|M_1\right|+\left|M_2\right|$, where M forms a connected component in G.

Let G be a $L{G}_k^{n,q}$; in particular, let G be a $CL{G}_k^{n,q}$. Let $V^1={\bigcup }_{j=1}^{q-1}{V}_j$ and $V^2=V_q$. Let $G_1$ be the subgraph of G induced by $V^1$, and let $G_2$ be the subgraph of G induced by $V^2$. Let $M_1\subseteq V^1$ and $M_2\subseteq V^2$ be DSs of $G_1$ and $G_2$, respectively. Let C be the cut $(M_1,M_2)$, and let $E^C$ be the edges that cross this cut. Note that $E^C=E_{q-1q}$. When the algorithm processes layer q, it chooses $M=M_1\bigcup M_2$, such that $\left|M_1\right|+\left|M_2\right|$ is minimized where M forms a connected component in G. Thus, the theorem follows. Similarly, $coun{t}_{ij}$ gives the number of ways a CDS of minimum cardinality can be formed when the vertices chosen in layer i are given by j. Thus, ${\forall }_j\mathsf{\Sigma }coun{t}_{qj}$ corresponding to the minimum value of ${\forall }_{j}so{l}_{qj}$ yields the total number of MDSs.

The time complexity of the algorithm is analyzed below. We presumed that similar prerequisites as in Theorem 3 were provided. The steps are presented below.

• A global structure, $sol$, consisting of $so{l}_0$ and $so{l}_1$, corresponding to the previous and current layers, is maintained for the whole algorithm. The final solution for the problem can be determined just by using information from $so{l}_0$ and $so{l}_1$. This structure is maintained for the whole algorithm and not for every layer.
• $so{l}_0$ and $so{l}_1$ consist of a maximum of $B_k{2}^k$ triples of the form $(lo,un,r)$. This corresponds to a maximum of $B_k$ component layouts ($lo$), $2^k$ masks, $un$ undominated vertices of the current layer and a maximum of $2^k$ triples, r, of the form $(m,s,c)$, for every unique pair $(lo,un)$. Here, m is the mask of the current layer that produced the respective (component layout, undominated vertices) pair; s is the minimum cardinality of the sub-solution corresponding to mask m and pair $(lo,un)$; and c is the count of s corresponding to mask m and pair $(lo,un)$.
• Throughout the algorithm, $so{l}_0$ and $so{l}_1$ are maintained by clearing $so{l}_0$ when the current layer is processed and the information of $so{l}_1$ is used as $so{l}_0$ for the next layer.
• $so{l}_0$ is initialized with the triple $(lo,un,r)$, corresponding to $2^k$ masks of the first layer. The initialization takes $O\left(k^2{2}^k\right)$.
• A candidate sub-solution for layers $1,\dots ,i$ induces connected components in layer i that are defined in terms of vertices of layer i. We call this the component layout.
• The number of component layouts is upper bounded by $B_k$, the number of ways of partitioning k vertices of a layer. Here, $k=f\left(n\right)$, $f\left(n\right)=O{\left(\log n\right)}^{\alpha }$, $\alpha <1$. $B_k=O(f\left(n\right)!)$. From Lemma 1, we know that $f\left(n\right)!$=$O\left(n^{ϵ}\right)$, for any $ϵ>0$.
• A mask j of the current layer can be combined with a component layout for mask l of the previous layer to form a new component layout for the current layer. With the same mask, l, j can form a new mask corresponding to the undominated vertices of the current layer.
• Every such unique pair of ($lo$, $un$), where $lo$ is component layout and $un$ is mask of undominated vertices, is maintained, and a list of triples r, consisting of triples of the form $(m,s,c)$, is associated with it. Here, m is the current layer mask, s is the minimum cardinality of the sub-solution corresponding to m, and c is the count of s. The number of such tuples, $(lo,un,r)$, is upper bounded by $B_k{2}^{2k}$, where $B_k{2}^k$ is the possible number of unique pairs of $(lo,un)$, and $2^k$ is the possible number of triples that can exist for each pair.
• Starting from the i-th layer, $i>1$, every $2^k$ masks of the current layer and the triple values from the previous layer are used to generate the triples for the current layer.
• For a unique pair $(lo,un)$ in the previous layer, if mask j dominates the undominated vertices of mask $un$, and forms a connected component with the layout, $lo$, then we consider that a sub-solution using mask j is feasible. Here, a mask, j, and a component layout, $lo$, are considered to form a connected component if every component in $lo$ has at least one edge with a node in mask j. Each such check takes $O\left(k^2\right)$ time. So, the total time to determine if a sub-solution with mask j is feasible is $O\left(k^2\right)$.
• If a mask, j, can feasibly give a sub-solution, then it is combined with the component layout, $lo$, of the previous layer to form a new component layout for the current layer corresponding to mask j. This is performed using a DFS which takes $O\left(k^2\right)$ for the given input matrix.
• Mask j is then combined with mask l of the previous layer, corresponding to the pair $(lo,un)$ that is under consideration, to form a mask for the current layer vertices that are not dominated by j or l. This takes $O\left(k^2\right)$ time.
• Using the mask, j, of the current layer and minimum cardinality, s, for the pair $(lo,un)$ of the previous layer, the new cardinality for the sub-solution is computed.
• The count of the new cardinality will be same as that of c of the $(lo,un)$ pair for the previous layer.
• This new pair of the component layout and undominated mask computed for mask j of the current layer are checked with the existing pairs of the current layer to determine if it is unique or not. We maintain the structure of the triples such that an entry can be accessed in $O\left(1\right)$ time, indexed by the pair $(lo,un)$ and the corresponding mask m for the previous and the current layer.
• If it is unique, the triple value, consisting of the newly computed $(lo,un)$ pair and its corresponding triple, consisting of the mask j, respective cardinality and the count, are added as a new triple for the current layer.
• Consider that the current mask j produces the new pair $(lo,un)$ with values $s=s_x$ and $c=c_x$. If the new pair is not unique, then there are three cases. Consider the existing entry of the $(lo,un)$ pair and the corresponding j to have values $s=s_y$ and $c=c_y$.

  (a)

  If $s_y=s_x$, then $c_y\leftarrow c_y+c_x$;

  (b)

  If $s_y>s_x$, then $s_y\leftarrow s_x;c_y\leftarrow c_x$;

  (c)

  If $s_y<s_x$, then no update is required.

• The above procedure is performed until the last layer, where the final solution is computed from the current layer information corresponding to the last layer. Of all the $B_k{2}^k$ pairs for the current layer, a solution is considered to be feasible if the mask for the undominated vertices for any of the $B_k$ component layouts is 0, as this would mean all the vertices are dominated. The  cardinality of MCD is the minimum value among all the feasible solutions. The count is then computed by considering each feasible entry with the minimum cardinality computed above and adding its corresponding count.
• Thus, the solution and the corresponding count of optimal solutions for MCD problem are computed.

For the whole algorithm, we maintained a global structure, as mentioned above. It consisted of a maximum of $O\left(B_k{2}^k\right)$ entries corresponding to unique pairs of $(lo,un)$ and another $2^k$ triples for each such pair. We maintainewa this information for only the previous and the current layers. So, the space used by the data structure is $O\left(B_k{2}^{2k}\right)$. This can be shown to be equal to $O\left(n^{ϵ}\right)$, for any $ϵ>0$, based on the proof for Lemma 1. This space requirement is in addition to the space required by the input graph which is $O\left(nk\right)$. For $k=O\left({\left(\log n\right)}^{\alpha }\right)$, $O\left(nk\right)$ is the dominating term compared to $O\left(n^{ϵ}\right)$. So, the space complexity is $O\left(nk\right)$. The following is the proof for time complexity of the algorithm.

First, an expression for the runtime of the algorithm is derived. The initialization using the first layer takes $O\left(k^2{2}^k\right)$ time. For each layer after the first, the $2^k$ masks of the current layer are combined with the $B_k{2}^k$ pairs of the previous layer. For each pair, a current layer mask is combined with a maximum of $2^k$ masks of the previous layer that generated this pair. Checking the feasibility of a mask of the current layer takes $O\left(k^2\right)$. Computing the new component layout and the new undominated mask takes $O\left(k^2\right)$ each. The undominated mask is calculated for $2^k$ masks of the previous layer for each mask of the current layer. Accessing and updating an entry takes $O\left(1\right)$ time, as mentioned above. This is done for $O(n/k)$ layers. So, the time complexity expression can be written as

$$\begin{array}{cc}\hfill T& =O(\frac{n}{k}{2}^k{B}_k{2}^k(k^2+2^k{k}^2))\hfill \\ & =O(\frac{n}{k}k!2^{2k}\left(2^k{k}^2\right))\because (B_k=O(k!))\hfill \\ & =O(nk{2}^{3k}k!).\hfill \end{array}$$

(1)

If $k=O\left(1\right)$, the time complexity becomes $T=O\left(n\right)$. If we assume the worst case number of nodes in each layer, i.e., $k=f\left(n\right)$, then the corresponding time complexity is $T=O\left(n^{1+ϵ}\right)$. as shown below.

Let $f\left(n\right)={\left(\log n\right)}^{\alpha }\alpha <1$

Let $h\left(n\right)=n^{\gamma }\gamma >0$

From Lemma 1 we have

$$\begin{array}{c}\hfill x!=O\left(n^{\gamma }\right)\mathrm{for}\mathrm{some}\gamma >0,\mathrm{where}x={\left(\log n\right)}^{\alpha }\\ \hfill \Rightarrow f\left(n\right)!=O\left(n^{\gamma }\right)=O\left(h\left(n\right)\right)\end{array}$$

The running time of the algorithm is given by

$$\begin{array}{c}T=O(nk{2}^{3k}f\left(n\right)!)\hfill \\ \le cn\ast k\ast 2^{3k}\ast h\left(n\right)\hfill \\ \le c{n}^{1+\gamma }\ast {\left(\log n\right)}^{\alpha }\ast 2^{3{\left(\log n\right)}^{\alpha }}(\because h\left(n\right)=n^{\gamma })\hfill \end{array}$$

Consider $F\left(n\right)={\left(\log n\right)}^{\alpha }\ast 2^{3{\left(\log n\right)}^{\alpha }}$

Let $g_1\left(n\right)=n^{\delta }$ and $g_2\left(n\right)=n^{\mu }\delta >0,\mu >0$

We know that the logarithmic functions grow slower than the polynomial functions.

$$\begin{array}{c}\Rightarrow {\left(\log n\right)}^{\alpha }\le c{g}_1\left(n\right)\\ \Rightarrow {\left(\log n\right)}^{\alpha }=O\left(n^{\delta }\right)\end{array}$$

Now, we claim that $2^{3{\left(logn\right)}^{\alpha }}\le c{g}_2\left(n\right)$ for some $\alpha <1$, a positive real number c and $n>n_0$, where $n_0$ is some positive intege.

Taking the log of both sides, we get

$$\begin{array}{cc}\hfill \log \left(2^{3{\left(logn\right)}^{\alpha }}\right)& \le \log \left(c{g}_2\left(n\right)\right)\hfill \\ \hfill \Rightarrow 3{\left(\log n\right)}^{\alpha }& \le \log c+\log g_2\left(n\right)\hfill \\ \hfill \Rightarrow 3{\left(\log n\right)}^{\alpha }& \le \mu \log n(\because g_2\left(n\right)=n^{\mu })\hfill \end{array}$$

Since $\alpha <1$, ${\left(\log n\right)}^{\alpha }<\log n$

$$\begin{array}{cc}\hfill \Rightarrow 3{\left(\log n\right)}^{\alpha }& =O\left(\mu \log n\right)\hfill \\ \hfill \Rightarrow 2^{3{\left(logn\right)}^{\alpha }}& \le c{n}^{\mu }\hfill \end{array}$$

Hence, we have proved our claim.

$$\therefore 2^{3{\left(logn\right)}^{\alpha }}=O\left(n^{\mu }\right)$$

From above, we have

$$\begin{array}{cc}\hfill F\left(n\right)& ={\left(\log n\right)}^{\alpha }\ast 2^{3{\left(\log n\right)}^{\alpha }}\hfill \\ \hfill \Rightarrow F\left(n\right)& \le c{n}^{\delta }\ast n^{\mu }\hfill \\ \hfill \Rightarrow F\left(n\right)& \le c{n}^{\delta +\mu }\hfill \\ \hfill \therefore F\left(n\right)& =O\left(n^{\delta +\mu }\right)\delta >0,\mu >0\hfill \end{array}$$

From (1), we get

$$\begin{array}{cc}\hfill T& \le c{n}^{1+\gamma }\ast n^{\delta +\mu }\hfill \\ & \le c{n}^{1+\gamma +\delta +\mu }\hfill \end{array}$$

We can write it as

$$\begin{array}{cc}\hfill T& \le c{n}^{1+ϵ}ϵ=\gamma +\delta +\mu \hfill \end{array}$$

By arbitrarily taking small values for $\mu$, $\delta$ and $\gamma$, $ϵ$ can be any value, such that $ϵ>0$.

$$\begin{array}{c}\hfill \therefore T=O\left(n^{1+ϵ}\right)ϵ>0\end{array}$$

Hence, the theorem is proved. ☐

Theorem 5.

The MCV Algorithm correctly computes a connected VC of minimum cardinality for $L{G}_k$ with a time complexity of $O\left(n^{1+ϵ}\right)$ for any $ϵ>0$ when $k=O{\left(\log n\right)}^{\alpha }$ and $\alpha <1$. The space complexity is $O\left(nk\right)$.

Proof. 

The MCV Algorithm is similar to the MCD Algorithm. A mask, j, of layer i must be a valid VC for layer i. The check takes an additional $O\left(k^2\right)$, though the total time complexity can be proved to be same as that of MCD. So, the proofs of correctness and time complexity follow from the proofs for the same of the MCD Algorithm. Hence, the time complexity is $O\left(n^{1+ϵ}\right)$ for any $ϵ>0$ when the number of vertices in each layer is k, where $k=O\left({\left(\log n\right)}^{\alpha }\right)$ and $\alpha <1$. Similarly, the space complexity can be shown to be $O\left(nk\right)$. ☐

Lemma 2 proves that $\left(\log n\right)!$ is quasi-polynomial. Thus, if $k=\mathsf{\Theta }\left(\log n\right)$ then MCV and MCD are computed in quasi-polynomial time. Proving this is quite straightforward. By substituting $\left(\log n\right)!$ for $k!$ into Equation (1) in Theorem 4, we get a product of a quasi-polynomial factor and a polynomial factor. Thus, the time complexity is quasi-polynomial.

Minor Enhancements

The current layer requires information only from the previous layer. So, only the variables of the current layer, i, and the previous layer, $i-1$, are maintained. In the pseudocode shown for all algorithms, for simplicity, the variables of the current layer are stored at index 1 and the variables of the previous layer are stored at index 0 of the data structure $sol$. When the current layer, i, is completely processed, the variables from index 1 overwrite the corresponding variables in index 0. This can be avoided by alternating the index of current layer between indices 0 and 1, thereby reducing the execution time by a factor of $O\left(1\right)$.

The optimum cardinalities for each of the problems are generated using minimal additional space. For example, the MVC Algorithm employs only $O\left(k{2}^k\right)$ space in addition to the space required by the graph. If, for each mask in each layer, we store the best compatible mask from the previous layer, then we can generate a solution. There are $O(n/k)$ layers, each having $O\left(2^k\right)$ k-bit masks. This requires $O\left(n{2}^k\right)$ space instead of $O\left(k{2}^k\right)$ space. However, if we want to generate all solutions, then for each mask of a given layer, we need to store all compatible masks of its previous layer that yield the optimum value requiring $O\left(n{2}^{2k}\right)$ space.

5. Conclusions

A novel graph class called layered graphs was defined. It includes a subset of bipartite graphs and a subset of trees with n vertices. A layered graph can have exponential number of cycles. The typical restrictions like bipartiteness, planarity and acyclicity on graph classes that admit polynomial time solutions for hard problems are not applicable for this class. The known NP-complete problems were shown to be in class P for these graphs when the layer size is $O\left(\log \right|V\left|\right)$ for MIS, MVC and MDS, and $O\left({\left(\log \right|V\left|\right)}^{\alpha }\right)$, where $\alpha <1$, for MCV and MCD. The count of the corresponding optimal solutions is also computed. We note that the identification of a maximum clique in a layered graph is direct as the inter-layer edges are limited to adjacent layers. Thus, one can independently solve $q-1$ instances of the maximum clique problem on graphs induced by $V_i\bigcup V_{i+1}$ (of size $\le 2k$, each in $O\left(2^{2k}{k}^2\right)$ time) to obtain a maximum clique of $L{G}_k^{n,q}$.

A few applications of layered graphs in computational molecular biology and social networks were addressed in this article. One can explore other problems that can be modeled by layered graphs. The design of larger graph classes (that include layered graphs as a sub-class) that admit polynomial time solutions for the problems studied in this article is an open problem. For example, in a layered graph, the inter-layer edges are restricted to the vertices of adjacent layers. If this restriction is dropped for $O\left(1\right)$ edges originating from each layer, then one obtains a more general graph class. Such graphs can potentially model more scenarios than layered graphs.