Download presentation

Presentation is loading. Please wait.

Published byAnis Cummings Modified about 1 year ago

1
CHAPTER 11 Coping with NP-completeness

2
Algorithm Largest Independent Set This algorithm returns α(G), the size of a largest independent set in G = (V, E). Input Parameter: G = (V, E) Output Parameters: None largest_independent_set(G) { if (E == Ø) return |V| else { pick first v V such that N(v) ≠ Ø G 1 = G - {v} G 2 = G - {v} - N(v) k 1 = largest_independent_set(G 1 ) // assume v not in independent set k 2 = largest_independent_set(G 2 ) // assume v in independent set return max(k 1, k 2 + 1) }

3
Algorithm Satisfiability This algorithm takes as an input a formula in CNF in which every clause contains at most three literals and returns true if and only if is satisfiable.

4
Input Parameter: ϕ Output Parameters: None 3_satisfiability( ϕ ) { if ( ϕ does not contain any clauses) return ϕ // ϕ is the logical constant true or false if ( ϕ contains a clause with one literal a) { ϕ = ϕ [a → true] // a has to be true return 3_satisfiability( ϕ ) } if ( ϕ contains a clause with two literals a, b) { ϕ 1 = ϕ [a → false][b → true] ϕ 2 = ϕ [a → true] return 3_satisfiability( ϕ 1 )||3_satisfiability( ϕ 2 ) } if ( ϕ contains a clause with three literals a, b, c) { ϕ 1 = ϕ [a → false][b → false][c → true] ϕ 2 = ϕ [a → false][b → true] ϕ 3 = ϕ [a → true] return 3_satisfiability( ϕ 1 ) || 3_satisfiability( ϕ 2 ) || 3_satisfiability( ϕ 3 ) }

5
Algorithm Randomized st-Connectivity This algorithm takes as an input a graph G = (V, E) and two vertices s, t V. It returns true with probability one if there is a path from s to t; if there is no path from s to t, it fails to terminate. Input Parameters: G, s, t Output Parameters: None randomized_st_connectivity(G, s, t) { vertex = s while (vertex != t) vertex = random vertex from N(vertex) return true }

6
Algorithm Randomized Hamiltonian Path This algorithm takes as input a graph G and searches for a Hamiltonian path. It returns true if it finds a Hamiltonian path and false otherwise. randomized_hamiltonian_path(G) { v 0 = random vertex in G i = 0 do { N = N(v i ) - {v 0,..., v i-1 } // N contains those neighbors of v i (the current last // vertex of the path) that are not already on the path if (N ≠ Ø) { i = i + 1 v i = random vertex in N } else if (v j N(v i ) for some 0 = j < i - 1) (v 0,..., v i ) = (v 0,..., v j, v i,..., v j+1 ) else return false } while (i != |V| - 1) return true }

7
Algorithm Next Fit This algorithm computes an assignment b of n items with sizes s[1],..., s[n] (0, 1] into bins and returns the number k of bins it used. Input Parameter: s Output Parameters: None next_fit(s) { n = s.last k = 1 // current bin size = 0 //accumulated size of items in current bin for i = 1 to n if (size + s[i] = 1) { b[i] = k // enough room to add item i to bin k size = size + s[i] } else { k = k + 1 b[i] = k size = s[i] } return k }

8
Algorithm First Fit This algorithm computes an assignment b of n items with sizes s[1],..., s[n] (0, 1] into bins and returns the number k of bins it used.

9
Input Parameter: s Output Parameters: None first_fit(s) { n = s.last k = 1 // number of bins used c[k] = 0 // c[i] is the total size of items in bin i for i = 1 to n { j = 1 while (c[j] + s[i] > 1) { j = j + 1 if (j > k) { // open new bin k = j c[k] = 0 } // add item i to bin j b[i] = j c[j] = c[j] + s[i] } return k }

10
Algorithm First Fit Decreasing This algorithm computes an assignment b of n items with sizes s[1],..., s[n] (0, 1] into bins and returns the number k of bins it used. Input Parameter: s Output Parameters: None first_fit_decreasing(s) { s.sort(>) // sort s in decreasing order return first_fit(s) }

11
Algorithm Greedy Coloring This algorithm takes as an input a graph G = (V, E) and constructs a coloring of the vertices of the graph such that no two adjacent vertices have the same color. Input Parameter: G = (V,E) Output Parameters: None greedy_coloring(G) { n = |V| C = {1,...,n} // set of colors for each v V color v with smallest color in C not used by any vertex in N(v) }

12
Algorithm Wigderson Coloring This algorithm takes as input a 3-colorable graph G = (V, E) and constructs a coloring of the vertices of the graph such that no two adjacent vertices have the same color.

13
Input Parameter: G = (V,E) Output Parameters: None wigderson_coloring(G) { n = |V| color_count = 0 while (V contains a vertex of degree at least √n) { pick v of degree at least √n G = (N(v),E) two_color(G,color_count) //move on to next set of colors color_count = color_count + 2 G = G - N(v) } greedy_coloring(G, color_count) // see new implementation below } greedy_coloring(G,c) { n = |V| C = {c,...,c + n} // set of colors for each v V color v with smallest color in C not used by any vertex in N(v) }

14
Algorithm Vertex Cover This algorithm determines whether a graph G = (V,E) has a vertex cover of size at most k. Input Parameter: G = (V,E) Fixed Parameter: k Output Parameters: None vertex_cover(G,k) { if ((k == 0) || (E == Ø)) return E == Ø else { pick first e = (u,v) in E G 1 = (V-{u}, E-{(u,w) | w V}) G 2 = (V-{v}, E-{(v,w) | w V}) return vertex_cover(G 1, k-1) || vertex_cover(G 2, k-1) }

15
Algorithm Vertex Cover, Improved This algorithm determines whether a graph G = (V,E) has a vertex cover of size at most k.

16
Input Parameter: G = (V,E) Fixed Parameter: k Output Parameters: None improved_vertex_cover(G,k) { m = 0 V’ = Ø for each v in V if (larger_degree(G,v,k)) m = m + 1 else // collect vertices of degree V’ = V’ {v} // at most k in V’ if (m > k) return false // compute G’ E’ = {(u,v) | (u,v) E and (u,v) V} G’ = (V,E) // remove isolated vertices from G’ for each v in V if (isolated(G’,v)) G’ = G’ - {v} if (|V‘| > 2k(k - m)) // in this case there cannot be return false // a k - m vertex cover return vertex_cover(G’,k - m) }

17
Algorithm Queens This algorithm finds a solution to the n-queens problem, which is stored in the array q. Input Parameter: n Output Parameter: q queens(n,q) { do { q.random_permutation() do { swaps = 0 // initialize counter for each i,j {1,..., n} if (queen in column i or j under attack) if (swapping queens in column i and j reduces collisions) { q.swap(i,j) swaps = swaps + 1 } } while (swaps > 0) } while (there are collisions in q) }

18
Local Search Heuristic This algorithm tries to improve an initial random guess by making local changes selected from a set of operations T. The function eval evaluates the goodness of a solution. local_search() { c = random element of the search space do { changed = false for each T T { c’ = T(c) Δ = eval(c) - eval(c’) if (Δ < 0) { c = c’ changed = true } } while (changed) output c }

19
Iterated Local Search Heuristic This algorithm runs a local search heuristic repeatedly from random starting points. T is the set of local operations allowed. The function eval evaluates the goodness of a solution. iterated_local_search() { do { changed = false c = random element of the search space do { for each T T { c’ = T(c) Δ = eval(c) - eval(c’) if (Δ < 0) { c = c’ changed = true } } while (changed) } while (eval(c) is not acceptable) output c }

20
Algorithm Independent Set Search This algorithm searches for a large independent set in the input graph G.

21
Input Parameter: G = (V,E) Output Parameters: None independent_set_search() { do { I = random subset of V do { changed = false c = random element of the search space do { for each T T { I’ = I Δ {v} // Δ as symmetric difference Δ = eval(I) - eval(I’) if (Δ < 0) { I = I’ changed = true } } while (changed) } while (eval(I) is not acceptable) output I }

22
Input Parameter: G = (V,E) Output Parameters: None sa_independent_set_search() { I = random subset of V n = 0 do { n = n + 1 T = T(n) // set current temperature for each v V { I’ = I Δ {v} // Δ as symmetric difference Δ = eval(I) - eval(I’) if ((Δ < 0) || (random() < p(T,Δ)) { I = I’ } } while (eval(I) is not acceptable) output I } Independent Set Search through Simulated Annealing

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google