Layered graphs: a class that admits polynomial time solutions for some hard problems

TL;DR

This paper introduces layered graphs, a new class where certain NP-hard problems like MIS, MVC, CVC, MDS, and CDS can be solved in polynomial time when each layer has logarithmic size, expanding the scope of efficiently solvable graph problems.

Contribution

The paper defines layered graphs and proves polynomial-time algorithms for classic NP-hard problems on this class, under specific size constraints for layers.

Findings

Polynomial-time algorithms for MIS, MVC, CVC, MDS, and CDS on layered graphs.

Layered graphs with layers of size O(log |V|) generalize known polynomial cases.

Restrictions like bipartiteness or planarity are not required for these results.

Abstract

The independent set on a graph $G=(V,E)$ is a subset of $V$ such that no two vertices in the subset have an edge between them. The MIS problem on $G$ seeks to identify an independent set with maximum cardinality, i.e. maximum independent set or MIS. $V* \subseteq V$ is a vertex cover $G=(V,E)$ if every edge in the graph is incident upon at least one vertex in $V*$. $V* \subseteq V$ is dominating set of $G=(V,E)$ if forall $v \in V$ either $v \in V*$ or $\exists u \in V*$ and $(u,v) \in E$. A connected dominating set, CDS, is a dominating set that forms a single component in $G$. The MVC problem on $G$ seeks to identify a vertex cover with minimum cardinality, i.e. minimum vertex cover or MVC. Likewise, CVC seeks a connected vertex cover (CVC) with minimum cardinality. The problems MDS and CDS seek to identify a dominating set and a connected dominating set respectively of minimum cardinalities. MVC, CVC, MDS, and CDS on a general graph are known to be NP-complete. On certain classes of graphs they can be computed in polynomial time. Such algorithms are known for bipartite graphs, chordal graphs, cycle graphs, comparability graphs, claw-free graphs, interval graphs and circular arc graphs for some of these problems. In this article we introduce a new class of graphs called a layered graph and show that if the number of vertices in a layer is $O(\log \mid V \mid)$ then MIS, MVC, CVC, MDS and CDC can be computed in polynomial time. The restrictions that are employed on graph classes that admit polynomial time solutions for hard problems, e.g. lack of cycles, bipartiteness, planarity etc. are not applicable for this class. \\ Key words: Independent set, vertex cover, dominating set, dynamic programming, complexity, polynomial time algorithms.

Figures

Full text

Layered graphs: a class that admits polynomial time solutions for some hard problems

1,2Bhadrachalam Chitturi

1Department of Computer Science, Amrita Vishwa Vidyapeetham, Amrita University, Amritapuri Campus, Kollam, Kerala 690525, India.

2Department of Computer Science, University of Texas at Dallas, Richardson, Texas 75083, USA.

**Abstract: The independent set on a graph $G=(V,E)$ is a subset of $V$ such that no two vertices in the subset have an edge between them. The MIS problem on $G$ seeks to identify an independent set with maximum cardinality, i.e. maximum independent set or MIS. $V*\subseteq V$ is a vertex cover $G=(V,E)$ if every edge in the graph is incident upon at least one vertex in $V*$. $V*\subseteq V$ is dominating set of $G=(V,E)$ if forall $v\in V$ either $v\in V*$ or $\exists u\in V*$ and $(u,v)\in E$. A connected dominating set, CDS, is a dominating set that forms a single component in $G$. The MVC problem on $G$ seeks to identify a vertex cover with minimum cardinality, i.e. minimum vertex cover or MVC. Likewise, CVC seeks a connected vertex cover (CVC) with minimum cardinality. The problems MDS and CDS seek to identify a dominating set and a connected dominating set respectively of minimum cardinalities. MVC, CVC, MDS, and CDS on a general graph are known to be NP-complete. On certain classes of graphs they can be computed in polynomial time. Such algorithms are known for bipartite graphs, chordal graphs, cycle graphs, comparability graphs, claw-free graphs, interval graphs and circular arc graphs for some of these problems. In this article we introduce a new class of graphs called a layered graph and show that if the number of vertices in a layer is $O(\log\mid V\mid)$ then MIS, MVC, CVC, MDS and CDC can be computed in polynomial time. The restrictions that are employed on graph classes that admit polynomial time solutions for hard problems, e.g. lack of cycles, bipartiteness, planarity etc. are not applicable for this class.

Key words: Independent set, vertex cover, dominating set, dynamic programming, complexity, polynomial time algorithms. **

1 Introduction

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 a 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  [17]. The maximum independent set problem on a general graph is known to be NP-complete [15]. Certain classes of graphs admit a polynomial time solution for this problem. Such algorithms are known for trees and bipartite graphs [1], chordal graphs [2], cycle graphs [3], comparability graphs [6], claw-free graphs [7], interval graphs and circular arc graphs [8]. 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 independent set problem can be solved in linear time [10]. Thus, for several classes of graphs MIS can be efficiently computed.

Hsiao et al. design an O(n) time algorithm to solve the maximum weight independent set problem on an interval graph with $n$ vertices given its interval representation with sorted endpoints list [12]. Several articles improved the complexity of the exponential algorithms that compute an MIS on a general graph [5, 9]. Lozin and Milanic showed that MIS is polynomially solvable in 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 [13].

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 MVC of $G$ then $\forall e=(u,v)\in E,u\in E\lor v\in E$. 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. CDS problems seek to identify a dominating set and a connected dominating set respectively of minimum cardinality. The MVC, MDS and CDS probelms on a general graphs are known to be NP-complete [15]. Garey and Johnson showed that MVC is one first NP-complete problem [15]. In connected vertex cover (CVC) problem, given a connected graph G, we are required to find vertex cover set $C$ with minimum cardinality such that the induced subgraph G[C] is connected. Garey and Johnson proved that CVC is NP-complete [18]. For trees and bipartite graphs the minimum vertex cover can be identified in polynomial time [20, 21]. Garey and Johnson proved that CVC problem is NP-hard in planar graphs with a maximum degree of 4 [15]. Li et. al. proved that for 4-regular graph CVC problem is NP-hard [19]. It is shown that for series-parallel graphs, which are a set of planar graphs, it shown that minimum vertex cover can be computed in linear time [23].

The minimum dominating set, i.e MDS and the minimum connected dominating set i.e. CDS problems seek to identify a dominating set and a connected dominating set respectively of minimum cardinality. Garey and Johnson showed that MDS on planar graphs with maximum vertex degree 3 and planar graphs that are regular with degree 4 are NP-complete [15]. CDS is NP-complete even for planar graphs that are regular of degree 4 [15]. Bertossi showed that the problem of finding a MDS is NP-complete for split graphs and bipartite graphs [22]. Cockayne et. al. proved that MDS in trees can be computed in linear time [4]. Haiko and Brandstadt showed that MDS and CDS are NP-complete for chordal bipartite graphs [24]. Ruo-Wei et. al. proved that for a given circular arc graph with $n$ sorted arcs, CDS is linear in time and space [25]. Fomin et. al. propose an algorithm with time complexity faster than $2^{n}$ for solving connected dominating set problem [26].

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 QoS constraints is NP-hard [14]. A graph that they call a layered graph is constructed from the given input graph and authors show that hop-constrained minimum spanning tree problem is equivalent to a 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 an algorithm to identify the corresponding minimum vertex cover.

2 Layered Graph

Consider a set of undirected graphs $G_{1},G_{2},\ldots G_{p}$ on the corresponding vertex sets $V_{1},V_{2},\ldots V_{p}$ and the edge sets $E_{1},E_{2},\ldots E_{p}$ 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$ whose layer number $i$ is $G_{i}$. Note that for any given $i$, $E_{ij}$ where $j=i+1$ can be $\phi$ and $\forall_{l\notin\{i-1,i+1\}}E_{il}=\phi$. Every vertex within a given layer gets a label from $(1,2,3,\ldots,k)$. Thus, $V_{i}\in\{V_{i1},V_{i2},\ldots V_{ik}\}$. Note that $V_{ix}$ is the vertex number $x$ in layer $i$. However, in layer $i$ the vertex number $x$ need not exist. Further, if $(V_{ix},V_{i+1~{}y})\in E_{i~{}i+1}$ then it follows that vertex $x$ is present in layer $i$ and vertex $y$ is present in layer $i+1$.

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

• •

The size of all graphs is restricted such that $\mid V_{i}\mid\leq k$ then a k-restricted layered graph i.e. $LG_{kr}$ is obtained. $LG_{kr}^{q}$ denotes an $LG$ with $q$ layers. $LG_{kr}^{q,n}$ denotes an $LG_{kr}^{q}$ with $n$ vertices.

• •

If $\forall_{t}$ for $V_{it}$ the only permissible edges are $(V_{it},V_{jt})$ where $j\in\{i-1,i+1\}$ then a linear layered graph i.e. $LLG$ is obtained. $LLG_{kr}$ denotes an $LLG$ that is k-restricted. $LLG_{kr}^{q}$ denotes an $LLG_{kr}$ with $q$ layers. $LG_{kr}^{q,n}$ denotes an $LLG_{kr}^{q}$ with $n$ vertices.

• •

If every $G_{i}$ is required to be 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.

This article primarily studies $LG_{kr}$ where every vertex within a given layer gets a label from $(1,2,3,\ldots k)$. The results being general are applicable for $LLG$, $SLG$ and any combination thereof. Clearly, CDS, CVC are well defined only on $SLG$; further, the entire $G$ must be a single component. The recursive process of generating a hypercube of dimension $n+1$ i.e. $H_{n+1}$ from two copies of $H_{n}$ consists of creating the inter-$H_{n}$ edges $\forall_{i}~{}(v_{1i},v_{2i})$ where $v_{1i}$ and $v_{2i}$ are the corresponding vertices from the first copy of $H_{n}$ and the second copy of $H_{n}$ respectively. Thus, the inter-layer edges of $LLG$ are in fact akin to a subset of inter-$H_{n}$ edges because an inter-$H_{n}$ edge exists between every pair of corresponding edges. However, in an $LLG$ the successive layers need not have all allowed edges; moreover, $\mid V_{i}\mid$ and $\mid V_{i+1}\mid$ need not be identical.

The complete graph on $k$ vertices is known as a clique on $k$ vertices and it is denoted by $K_{k}$. Consider a graph $G$ formed from several copies of $K_{k}$ say $G_{1},G_{2},\ldots G_{p}$ where in addition to the edges that exist in each of $G_{i}$ an edge is introduced between every pair $u,v$: $u\in G_{i}$ and $v\in G_{i+1}$. We denote this particular graph $G$ that has $p$ layers with $K_{k}^{p}$. The class of k-restricted layered graphs are in fact subgraphs of $K_{k}^{p}$. Thus, we call $K_{k}^{p}$ as full $LG_{kr}^{p,n}$. Likewise, a $LLG$ that is defined on $p$ 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 as a full $LLG_{kr}^{p,n}$. The number of layers in $LG_{kr}$ i.e. $q$ is bounded by $n/k\leq q\leq n$. Likewise, the number of connected components in this graph lie in $[1,2,3\ldots n]$. Recall that for any given $i$, $E_{i~{}i+1}$ can be $\phi$; that is the adjacent layers need not have any inter-layer edges among them.

A subgraph of $G$ induced by vertices $u_{1},u_{2},\ldots u_{i}$ consists of all vertices $u_{1},u_{2},\ldots u_{i}$ and all the edges defined on them. We design an algorithms that computes the cardinality of a MVC, CDS and CDS of any subgraph of $K_{k}^{p}$ i.e. $LG_{kr}^{q,n}$ with polynomial time complexity when $k=O(\log n)$. Moreover, we compute the number of MISs, MVCs, CDSs and CDSs in $LG_{kr}^{q,n}$. The worst case time complexity analysis which shows that these problems can be solved in polynomial time for $k=O(\log n)$ holds for all these problems even though the time complexities are not identical when the parameter $k$ is considered.

CDS problem is meaningful only for $CLG$. However, CVC problem does not require $CLG$ because in the layers with no edges a vertex need not be selected. If every layer has at least one edge then CVC also requires $CLG$.

3 Algorithm

Consider a layered graph with $q$ layers i.e. $LG_{kr}^{q,n}$ with layers $(1,2,3,\ldots,q)$. We design a generic dynamic programming algorithm for all the problems. The CDS is applicable only when $G$ is connected; thus, for these versions we are restricted to $CLG$. The specific details pertaining to each problem are elucidated. The layers are processed sequentially from the first to the last. Let $S=\bigcup_{j=1}^{q}V*_{j}$ be a candidate solution for a problem where $V*_{j}$ denotes the set of nodes that are chosen from layer $j$. The candidate sub-solutions or simply $css$ for layer $i$ and layers $1\ldots i$ are denoted as $css_{i}$ and $ccss_{i}$ respectively where $cccs$ denotes a combined candidate sub-solution for the first $i$ layers. Likewise, $css_{i,j}$ and $ccss_{i,j}$ denote particular instances where the solution chosen in layer $i$ equals $j$ i.e. $j$ is a $k$-bit variable that we call mask that denotes the chosen vertices. Further, $ccss_{i,j}$ potentially denotes several candidate sub-solutions of vertices from the first $i$ layers where $j$ is the mask corresponding to the layer $i$. We in general do not even store all these vertex sets but only the cardinality of the best option(s), such cardinality is called an optimum value. This is stored in the variable $mask_{i,j}$ and the number of solutions that yield the optimum value when the mask for layer $i$ is $j$ is stored in $count_{i,j}$.

The current layer requires the information only from the previous layer. So, only the variables of the current layer and the previous layer are maintained. The index 0 refers to the variables of the previous layer and index one refers to the same of the current layer. When the information for the index one is completely computed then it is overwritten onto the corresponding variables of index zero; the variables with index one are zeroed out and the next layer is processed (which becomes the current layer). This is a standard technique. Further, the overwriting of variables can be avoided by alternately assigning layers 1 and 0 as the current layer (the other becomes the corresponding previous layer). By employing extra space we can easily keep track of all possible solutions. However, we employ only $O(k2^{k})$ space (for domination problems we employ $O(k2^{2k})$ space ) in addition to the space required by the graph. If we employ $O(n2^{k})$ space ( for domination problems, $O(n2^{2k})$ space) where for each mask in each layer we store a best compatible mask from the previous layer then we can additionally generate a solution. However, if we want to generate all solutions then for each mask of a given layer we need to store all compatible masks of the previous layer that yield the optimum value. This further increases the space requirement.

We say that $css_{i,j}$ and $ccss_{i-1,l}$ are compatible if $css_{i,j}\bigcup ccss_{i-1,l}\in ccss_{i,j}$. That is the union of $css_{i,j}$ and $ccss_{i-1,l}$ yields a $ccss$ for the first $i$ layers. Note that compatibility is determined by $css_{i,j}$ and $css_{i-1,l}\in ccss_{i-1,l}$ and the vertices chosen by $ccss_{i-1,l}$ in the earlier layers is irrelevant. This is a key feature.

3.1 Input

The Input consists of $LG_{kr}^{q,n}$ that is specified in terms of $M_{1},\ldots,M_{q}$ and $I_{1},\ldots,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}$. The rows $1,2,\ldots k$ of $I_{i}$ correspond to the vertices $V_{i1},V_{i2},\ldots V_{ik}$ and the columns $1,2,\ldots k$ of $I_{i}$ are the vertices $V_{i+1~{}1},V_{i+1~{}2},\ldots V_{i+1~{}k}$. 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}[a]=1\iff$ an edge between $a\in V_{i},a\in V_{i+1}$ exists. The boolean valued function compatible is called to determine whether candidate sub-solutions (of the current layer and the subgraph induced up to the previous layer) can be combined; here the layer number $i$ is implicit. For each mask $j$ of a given layer $i$ a function $valid(i,j)$ determines if $j$ is a feasible option for layer $i$. The helper function $cardinality(j)$ returns the number of bits that are set in the binary representation of some mask $j$.

All algorithms consist of the following sequence of computational tasks.

• •

Repeat (i) and (ii) for all layers $1\ldots 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 $css_{i,j}\bigcup ccss_{i-1,l}$ in $mask_{i,j}$ and the count of $ccss_{i,j}$ in $count_{i,j}$. Corresponding to each $css_{i,j}$ if $2^{k}$ additional variables are present then update them (e.g. DS problems).

• •

(iii) Summarize: Layer $q:$ execute (i) and (ii). Identify the optimum cardinality among $\forall_{j}mask_{q,j}$ and the corresponding count.

Each problem has specific characteristics. The compatibility criteria and other specifics for each of the problems is elucidated below.

3.2 MIS

Consider the structure of a MIS on $LG_{kr}^{q,n}$ 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 IS. Let $G_{1}$ be the subgraph of $LG_{kr}^{q,n}$ induced by $V^{1}=\bigcup_{j=1}^{i}V_{j}$ and let $G_{2}$ be the subgraph of $LG_{kr}^{q,n}$ 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=1+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 the cardinality of an IS of $G$ is $\mid M_{1}\mid+\mid M_{2}\mid$ when there is no edge crossing $C$. Note that the only edges that can go across the cut are $E_{i~{}i+1}$. Thus, the cardinality of MIS of $LG_{kr}^{q,n}=max(\forall_{E^{C}=\phi}\mid M_{1}\mid+\mid M_{2}\mid)$.

• •

$feasible(j)$: 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(j)+mask_{i-1,l}>mask_{i,j})$ $mask_{i,j}\leftarrow cardinality(j)+mask_{i-1,l}$.

• •

Summarize: Let $opt\leftarrow max(\forall_{j}mask_{q,j})$;$count\leftarrow 0$; $\forall_{j}~{}if(mask_{q,j}=opt)count\leftarrow count+count_{q,j}$; Return $(opt,count_{q,j}))$

3.3 MVC and CVC

Consider the VC $V^{*}=\bigcup_{j=1}^{j=q}V^{*}_{i}$ of $LG_{kr}^{q}$ where $V^{*}_{i}$ denotes the set of vertices in $V^{*}$ from layer $i$. Clearly, $V^{*}_{i}$ is a VC for layer $i$. $V^{*}_{i}$ depends only on $V^{*}_{i-1}$ and $V^{*}_{i+1}$.

Consider two adjacent layers $p$ and $p+1$. $V^{*}_{p}\bigcup V^{*}_{p+1}$ must cover all edges inter-layer edges between layers $p$ and $p+1$. Specifically, $V^{*}=\bigcup_{j=1}^{j=p+1}V^{*}_{i}$ must cover all edges in the corresponding induced subgraph including $E_{p~{}p+1}$. Similar constraints hold for CMVC. Additionally the induced subgraph of $V^{*}$ must be a single connected component.

• •

$feasible(j)$: the mask $j$ must denote a VC for $G_{i}$. For CVC $j$ must be connected.

• •

$compatible(j,l)$: the union of two VCs must be a VC for edges in $G_{i},G_{i+1}$ and $E_{i,j}$ .

• •

Extension: if$(cardinality(j)+mask_{i-1,l}<mask_{i,j})$ $mask_{i,j}\leftarrow cardinality(j)+mask_{i-1,l}$. For CVC masks $j$ and $l$ must have at least on edge in between.

• •

Summarize: Let $opt\leftarrow min(\forall_{j}mask_{q,j})$;$count\leftarrow 0$; $\forall_{j}~{}if(mask_{q,j}=opt)count\leftarrow count+count_{q,j}$; Return $(opt,count)$

3.4 MDS and CDS

Let the MDS on $LG_{kr}^{q,n}$ say $V^{*}=\bigcup_{j=1}^{q}V^{*}_{j}$ where $V^{*}_{j}$ are the vertices in this MDS from layer $j$. Clearly, $V^{*}_{j}$ need not be a DS of layer $j$ because the $V_{j}$ can be dominated from any of $V^{*}_{j-1},V^{*}_{j},V^{*}_{j+1}$. It follows that $V^{*}_{p}\bigcup V^{*}_{p+1}$ must dominate all vertices in layers $p$. Specifically, the inclusion of $V^{*}_{q}$ in $V^{*}$ must ensure the domination of $V_{q-1}\bigcup V_{q}$.

Consider $mask=j$ in layer $i$. Say, $css_{i,j}\bigcup ccss_{i-1,l}$ dominates layer $i-1$. However, this particular union of vertices leaves certain vertices in layer $i$ undominated. The number of such choices are $2^{k}$; each choice is denoted by a k-bit variable that we call mask, here, a mask of exclusion. Further, when one processes layer $i+1$ this information is significant. We show that $O(2^{k})$ triples stored for each mask of a given layer suffice to compute MDS (CDC) of $LFG_{kr}$. We aim to show that for a chosen mask $j$ in layer $i$ it suffices to store $2^{k}$ triples of the form $(m_{x},s_{x},c_{x})$. Here $m_{x}$ is the mask of the vertices that are not dominated in layer $i$, $s_{x}$ is the cardinality of the vertices chosen so far and $c_{x}$ is the number of choices corresponding to $m_{x}$ for a particular $j$ in layer $i$. The particular mask in the previous layer that is the cause for a particular triple in the current layer need not be carried forward. So, for MDS and CDS $mask_{i,j}$ indicates an array of $2^{k}$ triples $\forall_{x}(x,s_{x},c_{x})$ where $x$ is the mask of undominated vertices of layer $i$; $s_{x},c_{x}$ are the respective size and count.

Let mask $j$ is chosen in layer $i$ it potentially be combined with every mask ( $O(2^{k})$ masks) of the previous layer. Thus, potentially ($O(2^{k})$) triples need be stored. Further, the total number of triples of the form $(m_{x},s_{x},c_{x})$ is $\Omega(n.2^{k})$ because $m_{x}$ can potentially assume any of $0\ldots 2^{k}-1$, $s_{x}$ is $O(n)$ and $c_{x}$ can in fact be exponential in $n/k$. Here we make the following critical observations.

• •

Let the chosen mask for layer $i$ is $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 $S$.

• •

In $S$ for any two triples with the same mask we need only retain the triples with the least size. The other triples cannot lead to an optimum 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}~{}css(i,j)$. We store the information of only two layers. Thus, the space complexity is $O(k2^{2k})$

• •

Thus, for a chosen mask for layer $i$ potentially $2^{2k}$ triples of previous layer must be processed. That is, for all masks of layer $i$, $2^{3k}$ triples of previous layer must be processed.

• •

Consider the 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(k^{2})$. This needs to be computed only once. Subsequently, for each triples stored corresponding to $l$ in layer $i-1$ we need only check if the undominated vertices are a subset of $B$ in $O(k)$ time. Thus, $O(k2^{k})$ is the dominating term in the time complexity yielding $O(k2^{2k})$ for all masks of the previous layer. So, for all masks of the current layer the time complexity is $O(k2^{3k})$. Thus, the time complexity of the algorithm is $O(n/kk2^{3k})=O(n2^{3k})$.

Similar constraints hold for CMDS. Additionally the induced subgraph of $V^{*}$ must be a single connected component. Thus, $\forall_{p}\bigcap V^{*}_{p}$ is connected. The time and space complexities are identical.

• •

$feasible(j)$: For CMDS $j$ must be connected. For MDS any $j$ is valid.

• •

$compatible(j,l)$: the union must dominate all vertices of $V_{i-1}$. For CDC masks $j$ and $l$ must have at least on edge in between.

• •

Extension: Performed as per critical observations listed above. The choice of the final layer must ensure that the final layer is dominated.

• •

Summarize: Let $opt\leftarrow min(\forall_{j}\forall_{d}size_{q,j,d})$;$count\leftarrow 0$; $\forall_{j}\forall_{d}if(size_{q,j,d}=opt)count\leftarrow count+ccount_{q,j,d}$; Return $(opt,count)$

3.5 Algorithm Compatible

The function compatible receives two masks denoting chosen vertices from layers $i$ and $i+1$. If the vertices in layer $i+1$ dominate the so far undominated vertices in layer $i$ then the function returns true. Otherwise, it returns false.

Algorithm Compatible

1:Input: $LG_{kr}$, $j$, $l$, and $I$.        //The function call: $compatible(j,l)$. $j$: Mask for layer $i$.

2:Output: 0 (incompatible) or 1 (compatible). //$l$: Mask for layer $i+1$. $I$ denotes matrix for $E_{i~{}i+1}$.

3:                                      // $bit_{c}(i)$ returns true if bit $c$ is set in $i$ else returns false.

4:Case MIS:                        // Input: two valid MISs of two adjacent layers

5:if $independent(j,l)$ then   // $independent(j,l)$: for any $a,b:$ $bit_{a}(j)$ and $bit_{b}(l)$:

6:    return 1;                     //if $I[a][b]=1$ return 0; otherwise return 1; $O(k^{2})$ algorithm.

7:else

8:    return 0;                   //$\exists$ a pair of vertices across the layers joined with an edge.

9:end **if

**

10:Case MVC:                      // Input: two VCs of two adjacent layers

11:if $cover(j,l)$ then            // $cover(j,l)$: $\forall_{a,b}$ where $I[a][b]=1$: $a\land j>0$ or $b\land l>0$

12:    return 1;                    // then return 1; otherwise return 0; $O(k^{2})$ algorithm.

13:else

14:    return 0;

15:end **if

**

16:Case CMVC:                      // Input: two CVCs of two adjacent layers

17:if $ccover(j,l)$ then             // $ccover(j,l)$: $\forall_{a,b}$ where $I[a][b]=1$: $a\land j>0$ or $b\land l>0$

18:    return 1;                      // and $\exists_{c,d}:I[c][d]=1\land bit_{c}(j)\land bit_{d}(l)$

19:else                                // then return 1; otherwise return 0; $O(k^{2})$ algorithm.

20:    return 0;

21:end **if

**

22:Case MDS:                      // Input: two masks of two adjacent layers,

23:if $dom(j,l)$ then             // $dom(j,l)$: $D\leftarrow css_{i,j}\bigcup css_{i+1,l}\bigcup Adj(css_{i,j})\bigcup Adj(css_{i+1,l})$

24:    return 1;                   // $i<q-1$: if $V_{i}\subseteq D$ then return 1; otherwise return 0;

25:else                             // $i=q-1$: if $V_{i}\bigcup V_{i+1}\subseteq D$ then return 1; otherwise return 0;

26:    return 0;                  //$V_{i}$ or $V_{i}\bigcup V_{i+1}$ is not dominated. $O(k^{2})$ algorithm.

27:end if                         // $Adj(V)$ is the set of all vertices neighboring any vertex in $V$

28:Case CDS:                   // Input: two masks of two adjacent layers,

29:                                // $\exists_{c,d}:I[c][d]=1\land bit_{c}(j)\land bit_{d}(l)$

30:if $dom(j,l)$ then          // $dom(j,l)$: $D\leftarrow css_{i,j}\bigcup css_{i+1,l}\bigcup Adj(css_{i,j})\bigcup Adj(css_{i+1,l})$

31:    return 1;                // $i<q-1$: if $V_{i}\subseteq D$ then return 1; otherwise return 0;

32:else                         // $i=q-1$: if $V_{i}\bigcup V_{i+1}\subseteq D$ then return 1; otherwise return 0;

33:    return 0;              //$V_{i}$ or $V_{i}\bigcup V_{i+1}$ is not dominated. $O(k^{2})$ algorithm.

34:end if                     // $Adj(V)$ is the set of all vertices neighboring any vertex in $V$

3.6 Algorithm Generic Optimum

The algorithms for all the problems on $LG_{kr}$ is similar. We give a generic dynamic programming based algorithm. Some specific instances are shown in the Appendix. Initialization: $\forall i~{}mask_{0i}=mask_{1i}=0$; $\forall i~{}count_{0i}=count_{1i}=0$; $mask_{ij}:$ The minimum value of an vertex cover up to layer $i$ where the chosen vertices of the layer $i$ are given by the binary value of $j$. $count_{ij}:$ the number of ways the $j^{th}$ mask in layer $i$ yields the corresponding minimum value. The time complexity for MIS, MVC and CVC is $O(nk2^{2k})$ and the space complexity is $O(k2^{k})$. The time complexity for MDS and CDS is $O(n2^{3k})$ and the space complexity is $O(k2^{2k})$.

Algorithm Generic Optimum

Input: $LG_{kr}^{q,n}$

Output: The cardinality and the count for the resp. problem.

for  ($i=$0,…,$2^{k}-1$)  do

    if  $is(i)$ for layer 1 then

          $count_{0i}=1;mask_{0i}=1;$ // 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 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

$best\leftarrow 0;sum\leftarrow 0;$

for (i=0,….$2^{k}-1$) do

    Identify $opt$, the cardinality of the optimum solution.

end for

for ($i=0,....2^{k}-1$) do

    Compute $count$, the count of optimum solutions.

end for

$return(opt,count)$

4 Correctness and complexity

The correctness is shown for MIS and MVC problems. The time complexities are identical and the analysis is given for MVC. The proofs of correctness for the remaining problems are similar. The time complexity for domination problems was presented earlier.

Theorem 1

Algorithm correctly computes the MIS on $LG_{kr}^{q,n}$.

Proof: Consider the structure of MIS on $LG_{kr}^{q,n}$. Let $G_{1}$ be the subgraph of $LG_{kr}^{q,n}$ induced by $V^{1}=\bigcup_{j=1}^{i}V_{j}$ and let $G_{2}$ be the subgraph of $LG_{kr}^{q,n}$ induced by $V^{2}=\bigcup_{j=i+1}^{q}V_{j}$. Consider the IS of $G$. Let $M_{1}$ and $M_{2}$ be the independent sets 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 an IS of $G$ is $\mid M_{1}\mid+\mid M_{2}\mid$ when there is no edge crossing $C$. Note that the only edges that can go across the cut are $E_{i~{}i+1}$. Thus, the cardinality of MIS of $LG_{kr}^{q,n}=max(\forall_{E^{C}=\phi}\mid M_{1}\mid+\mid M_{2}\mid)$. This, is exactly being computed. The theorem follows. Another proof that can be given for this theorem is based on mathematical induction on subgraphs induced by the first $i$ layers. Likewise, $count_{ij}$ gives the number of ways an independent set of maximum cardinality that can be formed when the vertices chosen in the layer $i$ are given by $j$. Thus, $count_{qj}$ corresponding to the maximum value of $mask_{qj}$ yields the total number of MISs.$\square$

Theorem 2

Algorithm correctly computes the MVC on $LG_{kr}^{q,n}$.

Proof: Consider the structure of MVC on $LG_{kr}^{q,n}$. Let $G_{1}$ be the subgraph of $LG_{kr}^{q,n}$ induced by $V^{1}=\bigcup_{j=i}^{i}V_{j}$ and let $G_{2}$ be the subgraph of $LG_{kr}^{q,n}$ induced by $V^{2}=\bigcup_{j=i+1}^{q}V_{j}$. Consider the 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 an VC of $G$ is $\mid M_{1}\mid+\mid M_{2}\mid$ when every edge crossing $C$ is covered by either $M_{1}$ or $M_{2}$. Note that the only edges that can go across the cut are $E_{i~{}i+1}$. Thus, the cardinality of MVC of $LG_{kr}^{q,n}=min(\forall_{E^{C}=\phi}\mid M_{1}\mid+\mid M_{2}\mid)$. This, is exactly being computed. The theorem follows. Another proof that can be given for this theorem is based on mathematical induction on subgraphs induced by the first $i$ layers. Likewise, $count_{ij}$ gives the number of ways an vertex cover of minimum cardinality that can be formed when the vertices chosen in the layer $i$ are given by $j$. Thus, $count_{qj}$ corresponding to the minimum value of $mask_{qj}$ yields the total number of MVCs. $\square$.

Theorem 3

Algorithm MVC on $LG_{kr}^{q,n}$ runs in polynomial time in $n$ when $k=O(\log n)$. The space required is $O(k^{2})$.

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_{i~{}i+1}$ is given. Likewise, we assume that the 0-1 adjacency matrix $M_{i}$ for each of $G_{i}$ are given. Recall that $LG_{kr}^{q,n}$ was formed from $G_{1},G_{2},\ldots 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+1~{}j}$.

• •

The initialization step requires $O(2^{k})$ time.

• •

Given a mask for layer $i$ it can be determined if it is a valid VC in $O(k^{2})$ time with $M_{i}$. That is, for any two $M_{i}[a][b]$ that is set the mask should have either bit $a$ or bit $b$ set.

• •

Given two masks $mask1,mask2$ for layers $i,i+1$ respectively and $I_{i}$ it can be directly determined if their union is a VC of a subgraph induced by $\bigcup_{i}^{i+1}V_{j}$ of $LG_{kr}^{q,n}$ in $O(k^{2})$ 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(k^{2}2^{k})$ time is required. For all masks of the current layer $O(k^{2}2^{2k})$ time is required. For all layers, the time required is maximized when each layer has $k$ vertices yielding $O(n/kk^{2}2^{2k})$ = $O(nk2^{2k})$ time.

The time complexity is clearly exponential in $k$; however, if $k=O(1)$ the time complexity is $O(n)$. The time complexity remains polynomial when $k=O(\log n)$. The space required is $O(k2^{k})$ because for two layers we store $4.2^{k}$ mask and count variables each of size $k$. $\square$

5 Conclusions

A new large class of graphs called layered graphs have been defined. These graphs can have exponential number of cycles. This class includes a subset of bipartite graphs and a subset of trees on $n$ vertices. The restrictions that are employed on graph classes that admit polynomial time solutions for hard problems, e.g. lack of cycles, bipartiteness, planarity etc. are not applicable for this class. The computation of hard problems on these graphs along with the count of the corresponding optimum solutions is shown to be in $P$ when layer size is $O(\log\mid V\mid)$.

6 Acknowledgments

Authors thank Amma for her guidance. This article is based on technical report UTDCS-02-17.

7 Appendix

The generic algorithm was presented earlier. Here, we state two specific algorithms for MIS and MVC respectively.

Algorithm MIS

Input: $LG_{kr}^{q,n}$

Output: The cardinality of MIS and the count of the maximum independent sets.

Initialization: $\forall i~{}mask_{0i}=mask_{1i}=0$;

$\forall i~{}count_{0i}=count_{1i}=0$;

//$mask_{ij}:$ The maximum value of an independent set up to layer $i$ where the chosen

//vertices of the layer $i$ are given by the binary value of $j$.

//$count_{ij}:$ the number of ways the $j^{th}$ mask in layer $i$ yields the corresponding maximum value.

//$is(j)$ is a boolean function that returns true if the vertex assignment in the current layer

//corresponding to the binary value of $j$ forms an IS. Otherwise it returns false.

//$\land$ is the bitwise AND operator.

//$cardinality(j)$ is the number of bits that are set in the binary representation of $j$.

// For each $mask_{ij}$ one $k$-bit variable that remembers the mask of the layer $i-1$ that

// yielded $mask_{ij}$ will help in constructing MISs. Union of such masks (1/layer) is an MIS.

// This will require $O(n/k2^{k})$ additional space. Current version needs only $O(2^{k})$ space.

for  ($i=$0,…,$2^{k}-1$)  do

    if  $is(i)$ for layer 1 then

          $count_{0i}=1;mask_{0i}=1;$ // No. of valid ISs of layer 1

    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 current layer

         if $is(j)$ then //$j$ is valid

             $size\leftarrow 0$

             for $(l=0,...,2^{k}-1)$  do //Masks of previous layer

                 if  $((mask_{0l}>0)\land(compatible(j,l)))$  then //$mask_{0l}=0\rightarrow$Invalid IS

                     if  $(cardinality(j)+mask_{0l}>size)$ then // Better IS for the current mask

                         $size=cardinality(j)+mask_{0l};$

                     end if

                 end if

                 $mask_{1j}\leftarrow size$

             end for//Masks of previous layer

             for $(l=0,...,2^{k}-1)$ do //Masks of previous layer

                 if ($size=cardinality(j)+mask_{0l};$) then //Instance of max

                     $count_{1j}\leftarrow count_{1j}+count_{0l};$ // Count corr. to max wrt mask=$j$

                 end if

             end for//Masks of previous layer

         end if// $j$ is valid

    end for//For all masks of current layer

    $\forall x~{}count_{0x}\leftarrow count_{1x};mask_{0x}\leftarrow mask_{1x};count_{1x}\leftarrow mask_{1x}\leftarrow 0$;

end for//For layers 2 through maximum

$best\leftarrow 0;sum\leftarrow 0;$

for (i=0,….$2^{k}-1$) do

    if $mask_{1i}>best$ then //Get the max value of $\forall_{i}mask_{pi}$

         $best=mask_{1i};$

    end if

end for

for ($i=0,....2^{k}-1$) do

    if $mask_{1i}=best$ then //Corr. to the best value of $MIS(LG_{kr}^{q,n})$

         $sum\leftarrow sum+count_{1i};$ //Get the count of MISs

    end if

end for

$return(best,sum)$ //MIS cardinality and the count of such MISs

Algorithm MVC

Input: $LG_{kr}^{q,n}$

Output: The cardinality and the count for the resp. problem.

for  ($i=$0,…,$2^{k}-1$)  do

    if  $is(i)$ for layer 1 then

          $count_{0i}=1;mask_{0i}=1;$ // No. of valid VCs of layer 1

    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 current layer

         if $is(j)$ then //$j$ is valid

             $size\leftarrow 0$

             for $(l=0,...,2^{k}-1)$  do //Masks of previous layer

                 if  $((mask_{0l}>0)\land(compatible(j,l)))$  then //$mask_{0l}=0\rightarrow$Invalid VC

                     if  $(cardinality(j)+mask_{0l}<size)$ then // Better VC for the current mask

                         $size=cardinality(j)+mask_{0l};$

                     end if

                 end if

                 $mask_{1j}\leftarrow size$

             end for//Masks of previous layer

             for $(l=0,...,2^{k}-1)$ do //Masks of previous layer

                 if ($size=cardinality(j)+mask_{0l};$) then //Instance of max

                     $count_{1j}\leftarrow count_{1j}+count_{0l};$ // Count corr. to max wrt mask=$j$

                 end if

             end for//Masks of previous layer

         end if// $j$ is valid

    end for//For all masks of current layer

    $\forall x~{}count_{0x}\leftarrow count_{1x};mask_{0x}\leftarrow mask_{1x};count_{1x}\leftarrow mask_{1x}\leftarrow 0$;

end for//For layers 2 through maximum

$best\leftarrow 0;sum\leftarrow 0;$

for (i=0,….$2^{k}-1$) do

    if $mask_{1i}<best$ then //Get the max value of $\forall_{i}mask_{pi}$

         $best=mask_{1i};$

    end if

end for

for ($i=0,....2^{k}-1$) do

    if $mask_{1i}=best$ then //Corr. to the best value of $MVC(LG_{kr}^{q,n})$

         $sum\leftarrow sum+count_{1i};$ //Get the count of MVCs

    end if

end for

$return(best,sum)$ //MVC cardinality and the count of such MVCs