The document describes several algorithms related to NP-complete problems and approximation algorithms. It includes algorithms for problems such as the largest independent set problem, 3-satisfiability, vertex cover, graph coloring, bin packing, and more. For each algorithm, it provides the input, output, and high-level steps of the algorithm.

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 }