A Dynamic Programming Framework for Combinatorial Optimization Problems on Graphs with Bounded Pathwidth

Mugurel Ionut Andreica 1 1Polytechnic University of Bucharest, [email protected]

Abstract -In this paper we present an algorithmic framework for lower the pathwidth, the closer the graph “looks” like a path. A solving a class of combinatorial optimization problems on graphs path decomposition of a graph G is a path D, with nodes D 1, with bounded pathwidth. The problems are NP-hard in general, D2, ..., D P (in the order they lie on the path), having the follow- but solvable in linear time on this type of graphs. The problems ing properties: are relevant for assessing network reliability and improving the • ≥ network’s performance and fault tolerance. The main technique each node D i corresponds to a subset of nv(i) 0 vertices considered in this paper is dynamic programming. of G (we will denote the subset by D i, too) • any two adjacent vertices of the graph G, u and v, be- I. INTRODUCTION long together to at least one subset D i • each vertex u of G belongs to at least one subset Di and Network reliability analysis and the improvement of the if u belongs to two subsets D i and D k, then it also be- network’s performance and fault tolerance are issues of great longs to all the subsets in between D i and D k (the sub- interest to the networking community. Careful network analy- sets which contain a vertex u form a sub-path of D) sis and testing, based on relevant reliability metrics, can point The width of the path decomposition is defined as out network vulnerabilities which could severely impact net- pw D=max{nv(1), …, nv(P)}-1. The minimum value of pw D of work performance, while improving the network’s fault toler- a path decomposition of the graph is called the graph’s path- ance can help eliminate some of these problems. The network width. Finding a path decomposition with minimum width is an can be modeled as an undirected graph, with network nodes as NP-hard problem, but in many practical situations, a decompo- vertices and network links as edges. The vertices and edges sition whose width is bounded by a constant can be easily may have several parameters associated to them, like cost, ra- found. Moreover, some efficient algorithms for finding path dius (in the case of wireless networks), latency, bandwidth and decompositions of small width have been developed [4]. many others. We believe that some of the properties of the cor- The pathwidth concept is strongly related to the notion of responding graph model can be used in order to define effec- treewidth, which was introduced by Robertson and Seymour tive network reliability metrics and for improving the net- [1]. The treewidth captures the degree of similarity of a graph’s work’s performance level and degree of fault tolerance. In this structure to a tree. Many NP-hard problems can be solved in paper, we present efficient algorithms for computing some im- polynomial time on graphs whose pathwidth (or treewidth) are portant properties and solving combinatorial optimization prob- bounded by a constant. These algorithms are usually based on lems for the class of graphs with bounded pathwidth. We focus the dynamic programming technique and have a time complex- here only on the algorithms, whose efficiency is important es- ity of the form O(f(pw)·n), where f(pw) is a function which is pecially in the case of large graphs (like those encountered in exponential in the width of the path decomposition pw, and n is practical situations), and leave other aspects for future work. the number of vertices of the graph. The algorithms make use All these algorithms are presented as part of a generic frame- of a path decomposition of the graph. In order to simplify the work, which can be further extended with algorithms not con- algorithms, we will introduce the concept of nice path decom- sidered in this paper. The rest of the paper is structured as fol- positions. The nodes (subsets) of a nice path decomposition are lows. In Section II we present formal definitions of the con- of the following two types: cepts used in the rest of the paper. In Section III we present a • Introduce node : If D is an introduce node, then generic dynamic programming framework for solving combi- i D = D ∪{x}, where x is a vertex which does not be- natorial optimization problems on graphs with bounded path- i i−1 width. In Section IV we present several clear examples regard- long to D i-1 (the introduced vertex). D 1 is an introduce ing the usage of the framework and in Section V we present node consisting of just one vertex. • = related work. Finally, in Section VI we conclude and mention Forget node : If D i is a forget node, then Di Di−1 {\ x}, directions for future research. where x is a vertex which belongs to D i-1, but not to D i II. GRAPHS WITH B OUNDED P ATHWIDTH (the forgotten vertex). D P is a forget node with nv(P)=0. Any path decomposition can be easily transformed into a The pathwidth of an undirected graph is a number which re- nice path decomposition with O(n) nodes in O(n) time [5]. All flects the resemblance of the graph’s structure to a path – the the algorithms in the subsequent section will consider that a know the index of state S in the array of states (between 1 and nice path decomposition is already known. the total number of states). The most efficient way to do this is to use two hash functions (hash and hash ). hash will generate III. A D YNAMIC P ROGRAMMING F RAMEWORK 1 2 1 a unique hash value for each state S (no collisions are allowed). Dynamic programming algorithms traverse the nodes of the This value will be stored in a hash table, together with the state given nice path decomposition in order and for each node i index. The hash table will use the hash 2 function and permits they compute a table T i. The size of the table T i is exponential some collisions. The pseudocode below illustrates the use of in the number of vertices of the subset D i. Each entry of the this approach. table contains a state S and a value v, i.e. T [S]=v. S is the state i generateStates(i): // generates all the states for node D i of the vertices in D i and is usually composed of one or several stateIndex=0 values for each vertex in D i. v is the value of the optimization for each state S generated do function, restricted to the vertices in h1=hash 1(S) i stateIndex=stateIndex+1 UD = D i U j hashTable[i].put(S, stateIndex) // hashTable[i] uses hash 2() j=1 getStateIndex(S, i) and considering that the vertices in D i are in state S. T i[S] is return hashTable[i].get( hash 1(S)) computed based on the values T i-1[S’], for some states S’ which are compatible with the state S. The definition of state com- Since we are discussing efficiency, we should note that the patibility depends on the actual problem solved (just like the sets of states of two nodes D i and D j will differ only if definition of the state itself). Each state obeys several structural nv(i) ≠nv(j). This suggests that we could generate the states rules, which depend on the problem. We will call the states only for each distinct value of the number of vertices (there are which violate some of these rules intermediate states. These only pw D+1 such values) and not for each node. states will need to be normalized into valid states. The set of all IV. COMBINATORIAL O PTIMIZATION P ROBLEMS valid states of a node D i is called VS i. Within the proposed generic algorithm, we will iterate In this section we will present several combinatorial optimi- zation problems which can be solved using the generic frame- through all the states for node D i-1 and expand these states into work presented in the previous section. The problems have valid states for the node D i. The expansion function will de- pend on the actions that we can perform (which are problem practical applications to network reliability analysis and fault tolerance and performance improvement. dependent) and on node D i’s type (Introduce or Forget node). In the end, the solution will be found in one of the entries of A. Coloring a graph with a fixed number of colors the table T P, considering only states belonging to a subset of We are given a graph G together with a nice path decompo- valid final states . We are only interested in finding the value of sition of the graph. We have to assign to each vertex of the an optimization function, not the states of the graph vertices graph a color from the set {1,2,…,C}, such that any two verti- leading to the optimal value. However, these states can easily ces connected by an edge are assigned different colors. be computed from the tables stored for each node of the path This is one of the simplest problems, in which the function decomposition (by going back from node P to node 1). The which needs to be computed is a binary function. We need to generic dynamic programming algorithm is given below: decide if a coloring exists or not. If it exists, the vertex colors Generic Dynamic Programming Algorithm: can be derived from the tables stored at each node of the path compute T1[S], for all states S in VS 1 decomposition. Furthermore, we can use the solution to this for i=1 to P-1do problem in a binary (or linear) search algorithm, in order to for all states S in VS i+1 do find the minimum number of colors required to color the graph. Ti+1 [S]=uninitialized The state of the vertices of a node D of the path decomposi- for S in VS , such that T [S] ≠uninitialized do i i i tion has the form S=(c , c , …, c ), where ∈ is the for action in setOfActions(i+1) do 1 2 nv(i) ci 1{ ,..., C} th // S’ is an intermediate state (not necessarily valid) color of the i vertex in the subset D i. We will, occasionally, // C is the (new) value of the optimization function denote by S[i] the i th component of the state S. We will con- (S’,C,ok)=expandState (S, i, action ) sider the vertices of a node D i ordered as v i,1 , v i,2 , …, v i,nv(i) . If if ( ok=true ) then Di is an Introduce node, then we will consider that the intro- S’’= normalize (S’ ) duced vertex is v . We will maintain these vertex ordering if (( better (C, T [S’’] )) or ( T [S’’]=unintialized )) then i,nv(i) i+1 i+1 assumptions in all the other problems considered in this sec- Ti+1 [S’’]=C OPT=uninitialized tion. An entry T i[S] has one of the values true or uninitialized , for S in setOfValidFinalStates() do meaning that there exists (does not exist) a coloring of the ver- if ( better (TP[S], OPT )) or ( OPT=uninitialized ) then tices in UD i, such that the vertices in D i are colored according OPT=T P[S] to the state S. Node D 1 contains only a single vertex, so we will return OPT assign T 1[S]=true, for all the states S in VS 1. The set of actions From an implementation point of view, the states for each which can be performed for expanding a state S of the node i node will be generated in an array of states, which can be trav- into a state S’ of the node i+1 depends on the type of the node ersed easily. When reading or writing a value T i[S], we need to Di+1 . If D i+1 is an Introduce node, the set of actions consists of coloring the introduced node in every possible color; if it is a newlabel={0,0,…,0} // K zeroes Forget node, only a “forget” action exists. We will now define for i=1 to K do all the functions required to turn the generic algorithm from if (newlabel[S[i]]=0) then Section II into a solution to the problem. counter=counter+1 newlabel[S[i]]=counter setOfActions(i): S’[i]=newlabel[S[i]] if (Di is an Introduce node ) then return S’ return { (Col, 1), (Col, 2), …, (Col, C) } The normalize function relabels the colors of a state S such else return { Forget } that they obey the structural rule. The number of states is updateCost(S, i, C): // auxiliary function, used by expandState greatly reduced. For instance, for C=7 and a node Di with let S=(c 1, c 2, …, c nv(i) ) nv(i)=9, the number of states is equal to the number of parti- for j=1 to nv(i)-1 do tions of a set with 9 elements into at most 7 parts, which is if (( vi,j and v i,nv(i) are adjacent ) and ( cj=c nv(i) )) then 7 return ( (), 0, false ) 21,110. Before, the number of states was 9 = 4,782,969. return ( S, 1, true ) C. Coloring a graph with a fixed number of colors in order to expandState(S, i, action): minimize penalties due to coloring conflicts if ( Di is an Introduce node ) then This problem is similar to the previous one, except that a (Col, cx)=action // cx is the color assigned to the new vertex valid coloring is not necessarily required. Each graph edge S’=(c , c , …, c , c =cx), where S=(c , c , …, c ) 1 2 nv(i)-1 nv(i) 1 2 nv(i)-1 (u,v) has an associated penalty value pen(u,v) . If the vertices u return updateCost (S’, i, T i-1[S] ) else and v are assigned the same color, then the penalty pen(u,v) will be paid. The optimization function consists of minimizing vi-1,j = the “forgotten” node S’=(c 1, c2, …, cj-1, cj+1 , …, cnv(i-1) ), where S=(c 1, c2,…, cnv(i-1) ) the sum of paid penalties. For this problem, we will keep the return ( S’,1,true ) same state definition as in the previous case, the same sets of normalize(S): actions and the same valid final states. We will have to slightly return S modify the expandState function, by redefining the auxiliary function updateCost , and the better function. Ti[S] now repre- better(cost 1, cost 2): sents the minimum penalty paid such that all vertices in UD i if ( cost 1=1 ) then return true else return false are colored and the vertices in D i are colored according to the state S. T will be initialized with 0 for every possible state. setOfValidFinalStates(): 1 return VS P // all the states of D P are valid final states updateCost(S, i, C): It is obvious that the expandState function is the most impor- C’=C for j=1 to nv(i)-1 do tant one in the algorithm and this will be the case with each if (( adjacent(v ,v )) and ( S[j]=S[nv(i)] )) then problem we will consider. In this function, the selected action i,j i,nv(i) C’=C’+pen(v i,j , v i,nv(i) ) is performed and the validity of the resulting intermediate state return ( S,C’,true ) is checked. The complexity of the algorithm is better(cost , cost ): O((pw+1)·C pw+1 ·P), considering that the path decomposition 1 2 pw+1 if ( cost 1time complexity of the algorithm is linear. No other changes are necessary in order to solve this prob- B. Coloring a graph with a fixed number of colors – improved lem, which has applications to frequency assignment in wire- state definition less networks. If we want to solve a slightly different version of The improvement of the previous solution consists in reduc- the problem, in which we try to minimize the maximum pen- ing the number of states. It is obvious that, given a valid color- alty paid instead of the sum of penalties, we only have to ing of the graph’s vertices, we can relabel the colors differently change the additive operator in the updateCost function with and still get a valid coloring. For instance, if C=3 and we have the max operator ( C’=max{C’, pen(v i,j , v i,nv(i) )} ). A different two vertices a and b colored with colors 3 and 2, respectively, solution to this modified problem consists of binary searching we can relabel the colors such that vertex a is colored with 1 the cost to be paid. When the cost C is fixed, we can ignore all and vertex b is colored with 2. This suggests that the colors of a the edges with a penalty lower than (or equal to) C and we state S should form a partition and obey the following rules: would now have to solve a normal coloring problem. • c =1 1 D. Minimum Path Cover • ∈ + = ci 1{ ,..., mi−1 }1 , where mi−1 max {c j} A path cover of a graph G consists of a union of disjoint 1≤ j≤i−1 paths Path , Path , …, Path , which cover all the vertices of G. With these rules, the state S’ returned by the expandState 1 2 PC More formally: function may not be a valid state. Therefore, we will have to • Path =p , p , …, p , where npv(i) is the number of define the normalize function differently: i i,1 i,2 i,npv(i) vertices on path i and two consecutive vertices p i,j and normalize(S): pi,j+1 are connected by an edge S’=S, where S=(c 1, …, cK) • Each vertex of the graph G belongs to exactly one path counter=0 We are interested in minimizing the number of paths in the // relabel the other endpoint of one of the two paths path cover (PC). Note that this problem contains finding a find k’ such that s k’ =s k Hamiltonian path as a particular case and is NP-hard in gen- if ( k’ exists ) then S’[k’]=s j eral. The state for a node D with nv(i) vertices is defined as S’[j]=S’[k]=0 i return ( S’,T [S]-1, true ) S=(s , s , …, s ). s is the state of the j th vertex of node D i-1 1 2 nv(i) j i else // we tried to connect the endpoints of the same path (considering the same ordering as before). s j can take one of the return ( (), +Infinity, false ) following values: else • sj=-1 implies that vertex v i,j has degree zero in the path vi-1,j = the “forgotten” node cover (it does not have any neighbors) S’=(s 1, s2, …, sj-1, sj+1 , …, snv(i-1) ) return ( S’,T [S],true ) • sj=0 implies that vertex v i,j has degree two in the path i-1 cover (it has two neighbors => it lies inside a path) The normalize function is almost the same as for the previ- • sj>0 implies that v i,j has degree 1 in the path cover and is ous problem, except that all the values s j equal to -1 or 0 are one of two endpoints of a path; s j is the path’s identifier left unchanged. Only the path ids are relabeled, such that they If s j>0, there can be at most one other vertex v i,k with s k=s j form a partition into classes in which every class contains at (the other endpoint of the same path). It is also possible that the most two vertices. The better and setOfValidStates functions other endpoint does not belong to D i (it was “left behind”). In are also maintained. The time complexity of the algorithm is 3 this problem, T i[S] represents the minimum number of paths O(pw ·max{|VS i|}·n), where |VS i| is exponential in pw. which cover all the vertices in UD , considering that the verti- i E. Minimum Cycle Cover ces in D are in state S. The only valid state for D is S=(-1), i 1 A minimum cycle cover has a definition which is almost with T [S]=1. We will define next all the functions required by 1 identical to the minimum path cover, except that it consists of the generic dynamic programming algorithm. cycles, i.e. paths in which the first and last vertex must also be setOfActions(i): connected by an edge (this excludes paths composed of only if ( Di is an Introduce node ) then one or two vertices). There are some minor adjustments which actionSet={ newPath } need to be made. First, T [S] will represent the minimum num- for j=1 to nv(i)-1 do i ber of closed cycles which cover all the vertices in UD i and the if (adjacent(v i,j ,v i,nv(i) )) then = ∪ state of the vertices in D i is S. Furthermore, all the vertices in actionSet actionSet {(extendP ath, v i,j )} UD i\Di belong to an open or closed cycle. Both endpoints of for j=1 to nv(i)-2 do the open cycles (i.e. paths) must belong to D (except when the for k=j+1 to nv(i)-1 do i open cycle contains only one vertex). This changes the state if (adjacent(v i,j , v i,nv(i) ) and adjacent(v i,k , v i,nv(i) )) then = ∪ definition slightly, in the sense that if S=(s 1, …, s nv(i) ) is the actionSet actionSet {(connect Paths, v i,j ,v i,k )} state of the vertices of the node D i and s j>0 for a vertex v i,j , return actionSet there must exist a vertex v with s =s . The set of valid final else return { Forget } i,k k j states contains only one state S final =(0, 0, …, 0), i.e. when there expandState(S, i, action): are no open cycles left. The set of actions for an Introduce let S=(s 1, s 2, …, s nv(i)-1) node is extended in order to contain actions of type (closeCy- if ( Di is an Introduce node ) then cle, v , v ), where v and v must be the two endpoints of an if ( action=newPath ) then i,j i,k i,j i,k S’=(s , …, s , -1) open cycle. The cost value returned by the expandState func- 1 nv(i)-1 tion is always T [S], except when an open cycle is closed, in return (S’, T i-1[S]+1, true) i-1 else if (action=(extendPath, v i,j )) then which case the cost will be T i-1[S]+1. If D i is a Forget node in if ( sj=0 ) then return ( (), +Infinity, false) the expandState function, the algorithm must first verify that else if ( sj>0 ) then the state of the “forgotten” node v i-1,j in S is S[j]=0 (i.e. it is not S’=(s 1, …, sj-1, 0, s j+1 , …, snv(i)-1, s j) the endpoint of an open cycle). If S[j] ≠0 the returned tuple will return ( S’,T i-1[S], true ) be ( (), +Infinity, false ). For lack of space, the described else // s j=-1 changes will not be presented in pseudocode. We draw atten- pid=max{0, s1, s 2, …, s nv(i)-1}+1 tion to the fact the Minimum Cycle Cover contains the Hamil- S’=(s , …, s , pid, s , …, s , pid) 1 j-1 j+1 nv(i)-1 tonian Cycle as a particular case and it is NP-hard in general. return (S’, T i-1[S], true) else F. k-Replica Placement let action=(connectPaths, v i,j , v i,k ) We are given an undirected graph with n vertices together if ((s =-1) and ( s =-1)) then j k with a nice path decomposition with small pathwidth pw. We pid=max{0, s 1, s 2, …, s nv(i)-1}+1 S’=(s , …, s , pid, s , …, s , pid, s , …, s , 0) want to select k distinct vertices of the graph and place a rep- 1 j-1 j+1 k-1 k+1 nv(i)-1 lica of some popular content in them. The cost of selecting a return ( S’,T i-1[S]-1, true ) else if ((sj=-1) and ( sk>0 )) then vertex i is csel(i) . If two vertices u and v which are adjacent to S’=(s 1, …, s j-1, s k, s j+1 , …, s k-1, 0, s k+1 , …, s nv(i)-1, 0) one another are selected, then we will also need to pay a pen- return ( S’,T i-1[S]-1, true ) alty cost pen(u,v) . We are interested in paying the minimum // the case (s j>0) and (s k=-1) is treated in a similar manner total cost for placing the k replicas. The state definition we will else if (( sj>0 ) and ( sk>0 ) and ( sj≠sk)) then S’=(s 1, …, s nv(i)-1, 0) use is the following: for a node D i, a state S has the form (s 1, and connectComponents . When forgetting a vertex v i-1,j , we …, s nv(i) , x), where: must check that at least one other vertex v i-1,k with the same cid • sj=1 if v i,j was selected for placing a replica still exists; otherwise, the connected component of v i-1,j would • sj=0 if v i,j was not selected for placing a replica be “left behind”. The only valid state is the one in which all the • x is the total number of vertices selected (so far) vertices are in the same connected component (all the cids are The set of actions of an Introduce node consists of two ac- 1). T i[S] will represent the maximum total weight of the leaves tions { Select, Do Not Select } and that of a Forget node will be of the connected components, such that very vertex in UD i be- the same as before ( {Forget} ). We will show the main func- longs to a component and the vertices in D i are in state S. We tions required by the framework. The normalize function will will only present the setOfActions and expandState functions, not be presented (because all the intermediate states will be because the others can be derived from the problems presented valid) and the valid final states will be only those with x=k. previously in this section. updateCost(S, i, C): setOfActions(i): C’=C if ( Di is an Introduce node ) then for j=1 to nv(i)-1 do actionSet={ newComponent } for j=1 to nv(i)-1 do if (( adjacent(v i,j , v i,nv(i) ) and ( S[j]=S[nv(i)]=1 )) then if (adjacent(v ,v )) then C’=C’+pen(v i,j , v i,nv(i) ) i,j i,nv(i) = ∪ return ( S,C’,true ) actionSet actionSet {(addAsLe af, v i,j )} expandState(S, i, action): for all sets S={v i,j1 , v i,j2 , …, v i,jk } with k>1 do let S=(s 1, s 2, …, s nv(i)-1, x) if (vi,nv(i) is adjacent to all the vertices in S ) then = ∪ if ( Di is an Introduce node ) then actionSet actionSet {(connect Components , S)} if (action=Select ) then return actionSet if (x=k ) then else return { Forget } return ( (), +Infinity, false ) expandState(S, i, action): S’=(s , s , …, s , 1, x+1) 1 2 nv(i)-1 let S=((cid , deg ), (cid , deg ), …, (cid , deg )) return updateCost (S’, i, T [S]+csel(v )) 1 1 2 2 nv(i)-1 nv(i)-1 i-1 i,nv(i) if ( D is an Introduce node ) then else // action = Do Not Select i if ( action=newComponent ) then S’=(s , s , …, s , 0, x) 1 2 nv(i)-1 newcid=max{cid , …, cid }+1 return ( S’, T [S], true ) 1 nv(i)-1 i-1 S’=((cid , deg ), …, (cid , deg ), (newcid, 0)) else 1 1 nv(i)-1 nv(i)-1 return (S’, T i-1[S]+w(v i,nv(i) ), true) vi-1,j = the “forgotten” node else if (action=(addAsLeaf, v i,j )) then S’=(s 1, s2, …, sj-1, sj+1 , …, snv(i-1) , x) C=w(v i,nv(i) ) return ( S’,T i-1[S],true ) if ( deg j=1 ) then C=C-w(v i,j ) We will use the same better function as in the minimum S’=((cid 1, deg 1), …, (cid j, min{2,deg j+1}, …, (cid j,1)) penalty coloring. The time complexity of the algorithm is return (S’, T i-1[S]+C, true) O(k·2 pw ·n). We can introduce several variations to this prob- else if (action=(connectComponents, SV)) then if ( ∃v v ∈ SV cid = cid ) then lem, like defining penalty or profit values for each pair of adja- i, j , i,k . j k cent vertices (u,v), where u is a selected vertex and v is not. return ( (), -Infinity, false ) These changes would require a different updateCost function. newcid= max {cid } ∈ j vi, j SV

G. Maximum Leaf Weighted Spanning Tree S’=((cid 1,deg 1), …, (cid nv(i)-1, deg nv(i)-1), (newcid, 2)) We are given an undirected graph G with n>1 vertices and a C=0 nice path decomposition of G. Each vertex i has an associated for j=1 to nv(i)-1 do weight w(i). We want to find a spanning tree of G such that the if (v i,j in SV) then total weight of the leaves (vertices of degree 1) of the spanning if (deg j=1) then C=C+w(v i,j ) tree is maximum. This is a more general version of the well- S’[j]=(newcid, min{2, deg j+1}) else if ( ∈ ∈ ) then known Maximum Leaf Spanning Tree problem, which is NP- cid j {cid k | vi,k SV } hard in general. The states for a node D i have the following S’[j]=(newcid, deg j) return (S’, T [S]-C, true) form ((cid 1, deg 1), (cid 2, deg 2), …, (cid nv(i) , deg nv(i) ). cid j is the i-1 else identifier of the connected component to which vertex v i,j be- vi-1,j = the “forgotten” node longs. deg j is the degree of vertex v i,j in its connected compo- if ( ¬(∃v − .k ≠ j ∧ cid = cid ) ) then nent. We are only interested in the values 0, 1 and 2 (if v i,j has i ,1 k k j degree greater than 2, we will keep its value at 2). All the con- return ( (), -Infinity, false ) nected components are trees. The identifiers of the connected S’=((cid 1,deg 1),…,(cid j-1,deg j-1),(cid j+1 ,deg j+1 ),…,(cid nv(i)-1,deg nv(i)-1) components form a partition, so they must obey the same rules return ( S’,T i-1[S],true ) as in the coloring problems presented previously. Every con- Using similar state definitions, we can solve other spanning nected component must have at least one representative vertex tree problems, like finding a spanning tree with the maximum in the set of vertices of the currently processed node i (i.e no degree at most Q. In this case, we only need to solve a decision connected component is “left behind”). When introducing a problem (like the first coloring problem we presented) and the node, the actions are of three types: newComponent , addAsLeaf degree values in a state S would range from 0 to Q. Of course, J. Optimizations for Partial Grid Graphs we would need to reject states in which the degree of some A (m,n) grid graph has m xn vertices arranged on m rows and vertex exceeds Q. Using the decision function in a binary (or n columns. Each vertex is adjacent to at most four other verti- linear) search procedure, we can solve the well-known Mini- ces (on the rows above and below and the columns to the left mum Degree Spanning Tree problem. and to the right). Such graphs appear, for instance, in processor interconnection networks. A partial (m,n) grid graph is a (m,n) H. Minimum Weighted Maximal Matching grid graph in which some of the vertices and some of the edges A matching is a set of pairs of adjacent vertices, such that may be missing. These graphs have their pathwidth bounded by each vertex belongs to at most one pair. Given a weight w(u,v) min{m,n}. Let’s assume that one of the dimensions is bounded for each edge (u,v) of the graph, the weight of the matching is by a constant (without loss of generality, we will assume this the sum of the weights of the edges composing it. A matching dimension is n). A path decomposition with pathwidth n can be is maximal if no other edge can be added to the matching. A easily obtained by ordering the vertices from the first to the last minimum weighted matching is a maximal matching with row and, for each row, from the first to the last column and minimum weight. In order to find such a matching, we will use introducing (and forgetting) the vertices in this order. More- states of the form (s , …, s ) for a node D , where s is either 1 nv(i) i j over, the vertices within a node D are ordered using the same 1 or 0 (vertex v belongs to the matching or not). When intro- i i,j criterion. Partial grid graphs are planar graphs and because of ducing a vertex at a node D , the actions are of two types: ( Add, i this, the number of states in the dynamic programming algo- v ), meaning that the introduced vertex is added to the match- i,j rithm can be reduced by making use of the Catalan property ing together with one of its neighbors v with s =0 and ( Do Not i,j j (mentioned in [9]). Let’s consider the minimum path (cycle) Add ). When forgetting a vertex v , the algorithm must check i-1,j cover problem. If a state S of a node D contains both endpoints that all the neighbors v of this vertex in the last node D i i-1,k i-1 of two different paths, then let’s assume that v and v (aDominating Set are just a few examples. Some of Algorithms,” LNCS 4596, pp. 15-27, 2007. them can be solved using state definitions and sets of actions very similar to the ones we presented in this section, but for others, the sets of states and actions are more complicated.

V. RELATED W ORK Graphs with bounded pathwidth and more generally, with bounded treewidth, have been studied intensively during the last two decades, because of their applications in many fields [1, 4, 5, 8]. Frameworks for algorithms on graphs with bounded pathwidth (treewidth) were proposed in [6, 7]. In [6], a frame- work for solving any problem expressible in monadic second order logic is presented. This framework generates the entire algorithm for solving a problem, but the constant factors of these algorithms are very large. In [7], a framework for net- work reliability problems based on a model with vertex and edge failure probabilities is presented. Problems related to minimum path and cycle covers were treated in [2,3].

VI. CONCLUSIONS AND FUTURE WORK In this paper we presented a dynamic programming frame- work for solving combinatorial optimization problems on graphs with bounded pathwidth. The framework is general enough to fit many important network optimization problems, which have applications in network reliability analysis and in the improvement of performance and fault tolerance. Com- pared to other existing frameworks, some problem-specific details, like state definitions and action sets are left to the pro- grammer (solution developer). This makes the development of solutions to problems more difficult, but it also allows for op- timizations which might not have been possible otherwise. As future work, we established two directions. The first is related to embedding the solutions of some problems which fit the proposed framework into techniques for improving the per- formance, fault tolerance and reliability of networks. The se- cond research direction refers to extending the framework to the more general class of graphs with bounded treewidth.

REFERENCES [1] N. Robertson, D., Seymour, “Graph Minor II. Algorithmic aspects of tree width,” J. Algorithms , vol. 7, pp. 309-322, 1986. [2] D. Z., Chen, R., Fleischer, J., Li, H., Wang, H., Zhu, “Traversing the Machining Graph,” in Proc. of the European Symposium on Algorithms, LNCS 4168, pp. 220-231, 2006.