On Approximating Degree- Bounded Network Design Problems Xi a - PowerPoint PPT Presentation

On Approximating Degree- Bounded Network Design Problems Xi a ngyu Guo joint work with Guy Korts a rz, Bundit L a ekh a nukit, Shi Li, D a niel V a z, a nd Ji a yi Xi a n Aug 17, 2020

Network Design Problems • Input: an graph c ∈ ℝ E G = ( V , E ) with edge cost ≥ 0 • Output: A min-cost subgraph of S G satisfying certain requirements: • Connectivity requirement • Minimum spanning tree • Minimum Steiner tree • Minimum k -edge-connected subgraph • Degree bound d ∈ ℝ V ≥ 0 deg S ( v ) ≤ d v , ∀ v ∈ V : • This talk: degree-bounded Directed Steiner Tree (DB-DST) and degree-bounded Group Steiner Tree on trees (DB-GST-on-trees)

Degree-bounded DST r Input: directed graph G = ( V , E ) with • edge cost c ∈ ℝ E d ∈ ℝ V , degree bound , ≥ 0 ≥ 0 • root r ∈ V k , terminals K ⊆ V , Output: min-cost tree T ⊆ G rooted at s.t. r • contain r → t path for every t ∈ K , • ∀ v ∈ T deg + , T ( v ) ≤ d v K

Degree-bounded DST r Input: directed graph G = ( V , E ) with • edge cost c ∈ ℝ E d ∈ ℝ V , degree bound , ≥ 0 ≥ 0 • root deg + T ( v ) ≤ d v r ∈ V k , terminals K ⊆ V , Output: min-cost tree T ⊆ G rooted at s.t. r • contain r → t path for every t ∈ K , • ∀ v ∈ T deg + , T ( v ) ≤ d v K

Related work • Degree-bounded network design in undirected graphs • (1, d v + 1) -apx for DB-MST [Singh-Lau’07] • (2, min{ d v + 3,2 d v + 2}) -apx for DB-Steiner forest [Lau-Zhou’15, Louis-Vishnoi’09] • Directed Steiner Tree: Ω (log 2 − ϵ k ) • -hard [Halperin-Krauthgamer’03] • k ϵ -apx in polynomial time [Zelikovsky’97] O ( log log k ) log 2 k -apx in quasi-polynomial time [Grandoni-Laekhanukit-Li’19][Ghuge- • Nagarajan’19]

Our result ( O (log n log k ), O (log 2 n )) Main Theorem . There’s a randomized -bicriteria approx algorithm for the degree-bounded directed Steiner tree (DB-DST) n O (log n ) problem, with running time. • First non-trivial approximation for the DB-DST problem. ( Ω (log 2 − ϵ k ), Ω (log n )) • Close to the lower bound • Based on rounding a novel LP formulation. • Can handle other constraints: e.g., length bound, buy-at-bulk

Degree-bounded GST-on-trees Input: undirected tree G = ( V , E ) rooted at r ∈ V , with • edge cost c ∈ ℝ E d ∈ ℝ V , degree bound ≥ 0 ≥ 0 O 1 : • k terminal groups O 1 , O 2 , …, O k ⊆ V . O 2 : r O 3 : Output: min-cost tree T ⊆ G s.t. O 4 : • contains a path from to every terminal group, r • ∀ v ∈ T , deg T ( v ) ≤ d v .

Degree-bounded GST-on-trees Input: undirected tree G = ( V , E ) rooted at r ∈ V , with • edge cost c ∈ ℝ E d ∈ ℝ V , degree bound ≥ 0 ≥ 0 O 1 : • k terminal groups O 1 , O 2 , …, O k ⊆ V . O 2 : r O 3 : Output: min-cost tree T ⊆ G s.t. O 4 : • contains a path from to every terminal group, r • ∀ v ∈ T , deg T ( v ) ≤ d v .

• Why study GST-on-trees? Ω (log 2 − ϵ n ) • Source for the -hardness of DST [Halperin-Krauthgamer’03] • Our DB-DST alg converts the input to a GST-on-trees instance • Our result: A polynomial-time ( O (log n log k ), O (log n )) -apx algorithm for DB-GST-on-trees • (almost) tight on both the cost ratio and degree violation ( O (log n log k ), O (log 2 n )) • Improves upon the -apx of [Kortsarz-Nutov’20]

Rest of the talk The main algorithm for the DB-DST result: 1. Encoding DSTs • Encoding as a decomposition tree • From decomposition trees to state trees 2. Handling degree bound 3. Rounding

Preprocessing • Make every terminal a leaf: v cost = 0 v ∈ K v v cost = 0 v • Make every vertex have out-degree v ≤ 2

Decomposition Tree r G ( : terminal )

Decomposition Tree r T 1 T Balanced Partition Thm For any -vertex binary tree that’s not n T or , we can split it into two subtrees T 1 and T 2 such that r ′ • T 1 ∪ T 2 = T | T 1 | , | T 2 | < 2 • 3 n + 1 T 2 • | T 1 ∩ T 2 | = 1 , ( : terminal )

Decomposition Tree r { r , a , b , c , d , e , f , g , h , i , j } T a { r , a , b , c , d , e , j } { e , f , g , h , i } d O (log n ) c b e j { d , e , j } { r , a , b , c , d } { e , f , i } { f , g , h } f i { r , a , d } { a , b , c } g h decomposition tree of T ( : terminal )

Decomposition Tree • An encoding of feasible DSTs • Well-structured: O (log n ) -depth full binary tree • Goal: fi nd the decomposition tree encoding the optimal DST

Decomposition Tree • An encoding of feasible DSTs • Well-structured: O (log n ) -depth full binary tree • Goal: fi nd the decomposition tree encoding the optimal DST state State tree: a more succinct (but lossy) encoding

State Tree r decomposition tree T { e , f , g , h , i } all vertices in the subtree a d { e , f , i } { f , g , h } c b e j state tree root of the subtree f i + ( e , { e }) portals of the subtree g h ( e , { f , e }) ( f , { f }) ( : terminal )

State Tree { r , a , b , c , d , e , f , g , h , i , j } ( r , { r }) { r , a , b , c , d , e , j } { e , f , g , h , i } ( r , { r , e }) ( e , { e }) { r , a , b , c , d } { d , e , j } { e , f , i } { f , g , h } ( r , { r , d }) ( d , { d , e }) ( e , { e , f }) ( f , { f }) { r , a , d } { a , b , c } ( a , { a }) ( r , { r , a , d }) state tree of T decomposition tree of T

Obs: every node of the optimal state tree has at most O (log n ) portals Proof: r ′ • Consider partitioning a subtree with state ( r ′ , S ) S

Obs: every node of the optimal state tree has at most O (log n ) portals Proof: r ′ • Consider partitioning a subtree with state ( r ′ , S ) S 1 • Suppose we partition it at vertex r ′ ′ and get two r ′ ′ subtrees ( r ′ , S 1 ) and ( r ′ ′ , S 2 ) • Will introduce one new portal ( r ′ ′ ) in each partition • Recall the root state is ( r , { r }) , and the state tree is of S 2 depth O (log n ) . QED

Properties of the optimum state tree • Root: state ( r , { r }) • Depth: O (log n ) • Simple state: state | S | ≤ O (log n ) ∀ ( p , S ) in the tree, Key idea: we can “enumerate” such state trees in quasi-polynomial time

G G p p S 1 p ′ S S 2 • Question : Number of possible ways to partition a state ( p , S ) ? • Ans = #{ choices of p ′ × } #{ choice of ( S 1 , S 2 ) } 2 | S | ≤ | V | × 2 O (log n ) ≤ n × = poly( n )

• Def: Let T ∘ be the union of all possible state trees rooted at ( r , { r }) with depth O (log n ) . T ∘ = poly( n ) O (log n ) = n O (log n ) • Size of T ∘ ( r , { r }) … … virtual node : way of partitioning a state ( p , S ) O (log n ) ( p ′ , ( S 1 , S 2 )) …… …… ( p , S 1 ) ( p ′ , S 2 ) … … … … … … … …

• The optimal state tree is a subtree of T ∘ • For every v ∈ T ∘ x v := 1 v , let [ in the optimal state tree] • Can be captured by a LP of size ≤ poly(size( T ∘ )) = n O (log n ) ∑ x o c ( o ) , min x ∈ [0,1] V ∘ o : base state ∑ x q = x p , ∑ x o ≤ x p , ∀ p ∈ T ∘ , t ∈ K (2) ∀ state node p (1) q : child of p o : base state involving t o is descendant of p ∑ x o = 1, ∀ virtual node q , p child of q x p = x q , (3) ∀ t ∈ K (4) o : base state involving t

Handling the degree bound • What about the degree bound? • Ans: add degree information to states State node root of the subtree ( r ′ , S , ρ S ) + Virtual node set of portals new portal + + ( r ′ ′ , ( S 1 , S 2 ), ρ r ′ ′ ) out-degree of each portal portal set partition + out-degree of the new portal ( r ′ ′ , S 2 , ρ S 2 ) ( r ′ , S 1 , ρ S 1 )

Handling the degree bound • Question : Number of possible ways to partition a state ( p , S , ρ S ) ? • Ans = #{ choices of p ′ × } #{ choice of ( S 1 , S 2 ) × } #{ choices of } ρ p ′ 2 | S | ≤ | V | × × d p ′ 2 O (log n ) ≤ n × × n = poly( n ) T ∘ ≤ poly( n ) O (log n ) = n O (log n ) • Size of

• Recursive rounding • Let { x v } v ∈ T ∘ be the LP solution p Alg round( p ) • if p is state node: …… …… ‣ pick child q of p with probability x q / x p ‣ return { p } round( q ) ∪ • else if p is a virtual node: ‣ return { p } round(left child of p ) round(right child of p ) ∪ ∪ • else return { p }

• Recursive rounding • Let { x v } v ∈ T ∘ be the LP solution p Alg round( p ) • if p is state node: q …… …… ‣ pick child q of p with probability x q / x p ‣ return { p } round( q ) ∪ • else if p is a virtual node: ‣ return { p } round(left child of p ) round(right child of p ) …… …… ∪ ∪ • else return { p }

• Recursive rounding • Let { x v } v ∈ T ∘ be the LP solution p Alg round( p ) • if p is state node: q …… …… ‣ pick child q of p with probability x q / x p ‣ return { p } round( q ) ∪ • else if p is a virtual node: ‣ return { p } round(left child of p ) round(right child of p ) …… …… ∪ ∪ • else return { p } ……