NP Complete

• P and NP
  • Remember the class P, the set of all problems that can be solved in polynomial time
  • The class NP is the set of all algorithms who's solution can be verified correct in poly nomial time
  • This is not all problems.
    • For example the Halting Problem.
    • Given a program, will it stop or loop forever
    • See This proof
    • For much more information, see an Automata class.
  • In some sense, the set P are easy to solve problems, and the set NP are easy to check problems.
  • P is in NP.
• A side trip, Convex Hull
  • Given a set of n points in 2-space Q, find the smallest convex polygon P for which each point in Q is either on the boundary of P or in it's Interior.
  • Convex vs Concave
  • To compare points
    • Assume all points are unique
    • Find the one that is "lowest-left" (p₀)
    • prefer left first then lower.
    • this is an order N operation
    • Pick the next lowest point (p₁)
    • (p₀p₁) define a ray (or base line)
    • for every other point, (p_n),
    • Remember the cross product between two vectors
    • |a x b| = |a||b| cos(theta)
    • theta is the angle between the two vectors.
    • so (p₀p₁)x (p₀p_n) will give us a measure that we can use to order two points relative to a third.
    • This is a constant time operation.
    • The closer of a set of collinear points can be ignored
    • And we can provide a total ordering on the set of points.
    • Note, this can be done in O(n) time, where n is the number of points.
  • An algorithm for finding the convex hull
    • Grahm's Scan
    • Let |Q| = n
    • Let |P| = h
    • in each case, this is the number of points in the structure
    • This algorithm

      Finds the lowest p0 and p1 as described above.
      Sort all other points baised on their polar angle
      Push the first three points in order onto the stack
      For all other points in order
           Check the angle between pi and the top two points on the stack
           If it is a non left hand turn pop the stack
      	    

    • 
    • A non left hand turn is found by the angle between the rays
    • More than 90 is non left hand.
    • 
    • 
    • 

    • GrahmScan(Q)
      (1) find p0 and p1  as above
      (2) sort Q as above.
      (3)   S.push(p0)
      (4)   S.push(p1)
      (5)   S.push(p2)
      (6)   for i = 3 to n do
      (7)      while S.NextToTop() S.Top and pi make a nonleft turn
      (8)         S.Pop()
      (9)      S.Push(pi)
      	    

    • S contains the convex hull when we are finished.
    • Timing
      • (1) is O(n)
      • (2) is O(n lg n)
      • (6-9) are O(n)
    • Is this as good as we can do?
• Reducibility
  • A problem P is reducible to another problem P' if every instance of P can be mapped to an instance of P'
  • Example Sort n numbers X = (x₀, x₁, ... x_n-1)
    • Let Q = {(x₀,x₀²), (x₁,x₁²), ... (x_n-1,x_n-1²)}
      • X = (3, 1, 5, 2, 4, 0)
      • Q ={(3,9), (1,1), (5,25), (2,4), (4,16), (0,0)}
    • Find the convex hull P of Q
    • 
    • let X' be the 'x' coordinate for each point in P in order
    • X' is the sorted set for X.
    • We have reduced sorting to finding the convex hull
    • In this case, it tells us that we can't find a convex hull faster than we can sort.
  • If we can perform the mapping from P to P' in polynomial time, P is said to be polynomial time reducible to P'
  • Reducibility really says that one problem is as hard as another
  • And if the problem can be done in polynomial time, and the mapping can be done in polynomial time
  • Then the problem can be solved in polynomial time
• NP-Complete
  • A problem L is NP-Complete if
    • L is in NP
    • Every problem in NP can be reduced to L in polynomial time
  • A problem is NP-hard if it satisfies property 2 but not 1
  • 
  • Theorem: If any NP-Complete problem is in P then P=NP and if any NP-Complete problem is shown to not be in P then all problems in NP-Complete are not in P.