Scott Perryman Jordan Williams

 NP-completeness is a class of unsolved decision problems in Computer Science.  A decision problem is a YES or NO answer to an algorithm that has two possible outputs.(ie Is this path optimal?)  NP is NOT Non-Polynomial, it is Non- deterministic Polynomial.  A decision problem is NP-complete if it is classified as both NP and NP-Hard.  They can be verified quickly in polynomial time (P), but can take years to solve as their data sets grow.

 Was introduced by Stephen Cook in 1971 at the 3rd Annual ACM Symposium on Theory of Computing  His paper, The complexity of theorem-proving procedures, started the debate whether NP-Complete problem could be solved in polynomial time on a deterministic Turing machine.  This debate has led to a $1 million reward from the Clay Mathematics Institute for proving that NP-Complete problems can be solved in polynomial time so that P=NP or disproving it thus P≠NP.

 Approximation: Find the most optimal solution…almost.  Heuristic: An algorithm that works in many cases, but there is no proof that it is both always fast and always has a correct answer.  Parameterization: If certain parameters of the input are constant, you can usually find a faster algorithm.  Restriction: By reducing the structure of the input to be less complex, faster algorithms are usually possible.  Randomization: Use randomness to reduce the average running time, and allow some small possibility of failure.

 Using a list of cities and the distances between each pair of cities find the shortest route by going to each city and returning to the original.  The decision version of the problem, when given a tour length L, decide whether the graph has any tour shorter than L, is NP-complete.  Optimal solution would be to travel to each city only once without any big “jumps”  Brute force runtime = O(n!)

 Heuristic algorithm  Starting node could be random or same every time  Finds the node with the least weight from the starting node and goes there  Repeats from that node until back to start  Not guaranteed to be the best solution but runs relatively quickly  Runtime of O(n 2 )

Best Solution found Starting Map

Initialization c← 0 Cost ← 0 visits ← 0 e = 1 /* pointer of the visited city */ For 1 ≤ r ≤ n Do { Choose pointer j with minimum = c (e, j) = min{c (e, k); visits (k) = 0 and 1 ≤ k ≤ n } cost ← cost + minimum - cost e = j C(r) ← j C(n) = 1 cost = cost + c (e, 1)

 Given a set of items with a weight and a value, determine which items you should pick that will maximize the value while staying within the weight limit of your knapsack (a backpack).  The optimal solution is the highest value that will “fit” in the knapsack  Brute force runtime = O(2 n )

 Starts with the last item in the list and removes it if over capacity  Recurses through every item and adds to knapsack based on Value and if there is still room  Works for item duplicates  Runtime = O(kn) where k is capacity

INTEGER-KNAPSACK(Weight,Value,Item,Capacity) { If Item = 0 then return 0 else if (Capacity – Weight[Item] < 0) return INTEGER-KNAPSACK(Weight,Value,Item-1,Capacity) else a = INTEGER-KNAPSACK(Weight,Value,Item-1,Capacity) b = INTEGER-KNAPSACK(Weight,Value,Item-1,Capacity) return max(a,b) }

 Given a set of integers, does this set contain a non-empty subset which has a sum of zero  Given this set  Would be true because  A variation would be for the subset sum to equal some integer n  Brute force runtime = O(2 n n)

 Algorithm trims itself down to remain running in polynomial time  Set for finding a certain sum  A list U consists of numbers lists T and S have in common  Return True if list S has a number that is both smaller than total sum but grater than the total negative sum

a list S contains one element 0. for i = 1 to N T =a list of x i + y, for all y in S U = T ⋃ S sort [U] //sorts where U[0] is smallest delete S[] y = U[0] S.push(y) for z = 0 to U.size() //eliminate numbers close to one another //and throw out elements greater than s if (y + cs/N < z ≤ s) y = z S.push(z) if S contains a number between (1 − c)s and s return true Else return false

 NP-complete problems are pushing the limits of our computing power  The limits of NP-completeness are set based on the question of whether P=NP or P≠NP  If one problem can be solved quickly then they all can be solved quickly.

 Some areas of cryptography, such as public key cryptography, which rely on being hard, would be broken easily  The other six millennial problems could instantly be solved.  Transportation become more efficient thanks to easy path finding.  Operations research and protein structures in biology would be easy to solve  Any yes/no question could be answered by machine, not by a person, as long as the polynomial constant factor of the algorithms is low, not, for example, n 1000

 Currently believed to be true, based on years of research and the lack of an effective algorithm  Hard problems couldn’t be solved efficiently, so Computer Scientists would be focused on developing only partial solutions.  This result still leaves open the average case complexity of hard problems in NP.

 Applets/TSP/notspcli.htm Applets/TSP/notspcli.htm  problem/fulltext problem/fulltext      Computers and Intractability: A Guide to the Theory of NP-Completeness. New York: W.H. Freeman. ISBN 