1. Measure and Conquer Exact algorithm for Minimum Dominating Set Presenter: Fenghui Zhang CPSC 669,TAMU 09/16/2005 F.V. Fomin, F. Grandoni and D. Kratsch *If you don’t have TexPoint installed, you may want to try the pdf version of this file.

2. Outline Introduction Background Basic Idea The Algorithm The Analysis Conclusion

3. Introduction – Exact algorithms Dealing with NP-hard problems Sometimes approximation just does not work Theoretical interests – How small can the constant on the upper bounds of some NP-hard problem be? – 2 O(n) v.s. 2 o(n) – 2 0.0001n v.s. 2 n/log n

4. Introduction – What is MDS? MDS (Minimum Dominating Set) – Given a graph G(V,E), find the minimum dominating set (A subset D of V such that any vertex in V is either in D or connected to at least one vertex in D).

5. Introduction – Why MDS? Network monitoring – Suppose you have a network to manage, each workstation is able to monitor its neighbors, you want to setup monitoring program on minimum number of stations to be able to look after every one of the nodes.

6. Introduction – Why MDS? Ad hoc network power saving protocol – In an ad hoc network, the power supply of each node is limited. The energy cost of a sleeping node is much smaller and an active node can wake the sleeping ones up if they are in range. At a moment, what is the minimum number of nodes that has to be alive such that each node is still reachable?

7. Background MDS is NP-hard It is hard to approximate – (1+clog n) Lower bound of  * (C n ) where C is a constant number – there is no such algorithm unless something really surprise happened

8. Background Why does it seem that my program is always way faster than the upper bound my algorithm has? Anything wrong? Exact algorithms of running time O(2 cn ) – 2 0.955n, Fomin et al, 2004 – 2 0.919n, Randerath & Schiermeyer, 2004 – 2 0.850n, Grandoni, 2004 – 2 0.610n : Poly-space, this paper – 2 0.598n : Exp-space, this paper

9. Basic Idea What is the point? – All previous approaches were trying to improve the upper bound by adding more technique complexity to the algorithms. – Fomin et al proposed this Measure and Conquer technique, focusing on measuring the algorithms more carefully to achieve better bound.

10. Basic Idea – Bounded Search Tree Many algorithms’ analysis are done based on bounded search trees – Each sub-tree is a different probe – Each leaf is a solution – The size of the search tree is then the complexity of the algorithm

11. Basic Idea – Bounded Search Tree Suppose the worst branch of a BST is: – T(n)=2T(n/2)+C – Then we know that the size of the tree is: – T(N)=O * (log n) What about T(n)=T(n-4)+T(n-1)? – T(n)<1.3803 n where 1.3803 is the unique positive root of (x 4 -x 3 -1=0)

12. Basic Idea – Measure and Conquer Instead of using the number of the vertices in the graph as a measure, subtle properties are taken into consideration – For MDS, degree-1 vertices and degree-0 vertices are good – Degree-2 vertices are not that good, but not bad either – Why should they be taken as the same as a degree-10 vertex?

13. Basic Idea – Measure and Conquer Weighted problem size – a simple example on MDS – Each vertex of degree-i has weight w i 2 [0,1] – K(G) =  v2 V w d(v) – K(G) · |V(G)| – Let w 2 =0, if all vertices in G are of degree-2, then K(G)=0 The problem can be solved in P-time.

14. Basic Idea – Measure and Conquer What is the vertices are not all of degree-2? – For example there are one degree-3 vertex You simply branch on this degree-3 vertex and the residue graph become degree-2 bounded graph, you are done Each branch of your algorithm bring your graph to a better position in sense of solving the problem

15. The algorithm - preparation MSC (Minimum Set Cover) – Given a collection of sets S={s 1,s 2,…,s n }, find the minimum number of sets A in S such that the union of all sets in A satisfies [ s i 2 A s i =[ s i 2 S s i. – Also well known NP-hard problem – Equivalent to MDS in some sense

16. The algorithm - preparation The Straightforward reduction – For each v, s v ={v}[ N(v) where N(v) is the set of v’s neighbors – S={s v |v2 V(G)} – Set covers of S are 1:1 mapped to dominating sets of G – If we can solve MSC, then we can find a solution for MDS in the same amount of time

17. The algorithm - preparation Properties of minimum set cover problem – If v is contained in only one s i 2 S, then s i is in every set cover of S – If s i µ s j (s i,s j 2 S), then there exists a set cover which does not contain s i – If every one of the set S contains exactly two elements, we can find the minimum set cover in polynomial time. Reduces to maximum matching

18. The algorithm – minimum set cover int msc(S){ – If(|S|=0) return 0; – If(9 s, r2 S, sµ r) return msc(del(r,S)); – If(9 u2 U u contained in exact one set s) return 1+msc(del(r,S)); – s = the largest set in S; – If(|s|=2)return poly-msc(S); – Return min{msc(S-{s}), 1+msc(del(s,S))}; }

19. The algorithm – minimum set cover What does del(r,S) do? – When we actually put r into the set cover – Removes all elements r from the universe, i.e. any set that contains them – At last, take out all the empty sets

20. The analysis – give it a try Let k(S)=|S|+|U|, U=[ s2 S s If s is the set we are branching on, we know |s|¸ 3 – If we take s in, we reduce |S| by 1 and |[ s2 S s| by at least 3 – If we take s out, we reduce |S| by 1 – Therefore T(k)· T(k-1) + T(k-4) – T(k)<1.3803 k ' 2 0.465(|S|+|U|) – And we know that |S|+|U|· 2n, here goes the first result: O * (2 0.93n )

21. The analysis – Now we are on to something Instead of treating each set and each element all the same, we put weights on them – w i : Set’s weight related to its size – v j : Element’s weight related to its frequency Let n i be the number of sets of size i, m j be the number of vertices are covered by j sets – K(S) =  i¸ 1 w i n i +  j¸ 1 v j n j,

22. The analysis – Decide weights Assuming w i =v i =1 for i=1 or i¸ 6 – Why? Due to the complexity to do the next step 0·  w i ·  w i-1 for i¸ 2 where  w i =w i -w i-1 Then we can play with the rest to get the best branch, some math (numerical methods we don’t want to discuss here) involves: iWiWi ViVi 20.37740.3996 30.75480.7677 40.90950.9300 50.97640.9856

23. The analysis – the recursions We don’t have to worry about those s whose size are larger than 8 since they are no worse than that of 7. When all s got size ·2, then we are done We enumerate all cases for 3· |S|· 7 and we got – O * (2 0.305(|S|+|U|) )· O * (2 0.610n )

24. The analysis – exp-space alg. In many recursive algorithms, we do repeating jobs when the instance get small Remembering all the small cases will help to save some time, cost more space though O * (2 0.598n ) can be achieved by doing so Of course this running time will be a upper bound for MDS as well

25. The analysis – Lower bound of the algorithm What ever weights we pick there is a lower bound of  (2 n/3 ) – Proved by giving a worst case example Thus the result shown in this paper is not bad at all. Yet there is no doubt that it can be further improved.

26. Conclusions A brand new analyzing method Not intend to make your program faster, only to know better Potentially most branch search tree based algorithms apply – Vertex Cover, Independent Set, 3SAT, etc.

27. Homework Describe MDS as an optimization problem in the form Dr. Chen taught in the class. Try to explain in your words why reducing MDS to MSC helped make the analysis better.

28. References – Fedor V. Fomin, Fabrizio Grandoni and Dieter Kratsch, “Measure and Conquer: Domination – A Case Study”, ICALP 2005

29. The End Thank you very much! Discussions are welcome, I can be reached at – fhzhang@cs.tamu.edu fhzhang@cs.tamu.edu – HRBB 315D