Your SlideShare is downloading. ×
  • Like
  • Save
Chap11alg
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply
Published

 

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
172
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
0
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. CHAPTER 11 Coping with NP-completeness
  • 2. Algorithm 11.1.4 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 11.1.11 3-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 11.2.1 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 11.2.4 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 11.3.8 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 11.3.13 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 11.3.16 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 11.3.19 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 11.3.23 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 11.4.4 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 11.4.7 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 ‘| > 2 k ( k - m )) // in this case there cannot be return false // a k - m vertex cover return vertex_cover( G ’, k - m ) }
  • 17. Algorithm 11.5.5 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 11.5.7 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. Independent Set Search through Simulated Annealing 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 }