CSE373: Data Structures & Algorithms

Lecture 22: The P vs. NP question,

NP-Completeness
Lauren Milne
Summer 2015
 Admin

• Homework 6 is posted
– Due next Wednesday
– No partners
 Algorithm Design Techniques
• Greedy
– Shortest path, minimum spanning tree, …
• Divide and Conquer
– Divide the problem into smaller subproblems,
solve them, and combine into the overall solution
– Often done recursively
– Quick sort, merge sort are great examples
• Dynamic Programming
– Brute force through all possible solutions, storing solutions to
subproblems to avoid repeat computation
• Backtracking
– A clever form of exhaustive search
 Backtracking: Idea
• Backtracking is a technique used to solve problems with a large
search space, by systematically trying and eliminating possibilities.
• A standard example of backtracking would be going through a
maze.
– At some point, you might have two options of which direction to go:
Portion A
Junction
Portion B
 Backtracking
o n
ti
One strategy would be to try going through Junc
Portion A of the maze.
If you get stuck before you find your Portion B
way out, then you "backtrack" to the
junction.

Portion A
At this point in time you know that Portion A
will NOT lead you out of the maze,
so you then start searching in Portion B
 Backtracking
• Clearly, at a single junction you
could have even more than 2
choices.

• The backtracking strategy says to try

each choice, one after the other,
t io n
– if you ever get stuck, "backtrack" to the
u nc
junction and try the next choice. J C
B
• If you try all choices and never A
found a way out, then there IS no
solution to the maze.
 Backtracking (animation)

dead end
?
dead end
dead end
?
start ? ? dead end
dead end
?
success!
 Backtracking
• Dealing with the maze:
– From your start point, you will iterate through each possible
starting move.
– From there, you recursively move forward.
– If you ever get stuck, the recursion takes you back to where
you were, and you try the next possible move.

• Make sure you don't try too many possibilities,

– Mark which locations in the maze have been visited already
so that no location in the maze gets visited twice.
– If a place has already been visited, there is no point in trying
to reach the end of the maze from there again.
 Backtracking

The neat thing about coding up backtracking is

that it can be done recursively, without having
to do all the bookkeeping at once.
– Instead, the stack of recursive calls does most of
the bookkeeping
– (i.e., keeps track of which locations we’ve tried so
far.)
On to Complexity theory!
 The $1M question
The Clay Mathematics Institute
Millennium Prize Problems

1. Birch and Swinnerton-Dyer Conjecture

2. Hodge Conjecture
3. Navier-Stokes Equations
4. P vs NP
5. Poincaré Conjecture
6. Riemann Hypothesis
7. Yang-Mills Theory
 The P versus NP problem (informally)

Can every problem whose solution can be quickly

verified by a computer also be quickly solved by a
computer?
 What is an efficient algorithm?

Is an O(n) algorithm efficient?

How about O(n log n)? polynomial time

O(n2) ? O(nc) for some

constant c
O(n10) ?

O(nlog n) ?

O(2n) ? non-polynomial
time
O(n!) ?
The Class P (polynomial time)

Binary Search

Dijkstra’s Algorithm

Breadth-First Search

P Sorting Algorithms
NP (Nondeterministic Polynomial Time)

Hamilton Cycle

NP Sudoku

Binary Search
SAT
P Dijkstra’s Algorithm

Breadth-First Search …
Sorting Algorithms
…
 The P versus NP problem

Is one of the biggest open problems in computer

science (and mathematics) today

It’s currently unknown whether there exist polynomial

time algorithms for NP-complete problems
– We know P  NP, but does P = NP?
– People generally believe P ≠ NP, but no proof yet

What do these NP problems look like?

Sudoku

3x3x3
Sudoku

3x3x3
Sudoku

4x4x4
Sudoku

4x4x4
 Sudoku

Suppose you have an algorithm

S(n) to solve n x n x n

V(n) time to verify the solution

Fact: V(n) = O(n2 x n2)

Question: is there some

constant such that
S(n) = O(nconstant)?
...

nxnxn
 Sudoku

P vs NP problem

Does there exist an algorithm

for solving n x n x n Sudoku
that runs in time p(n) for some
polynomial p( ) ?
...

nxnxn
 The P versus NP problem (informally)

Can every problem whose solution can be verified

in polynomial time by a computer also be solved
in polynomial time by a computer?
 To check if a problem is in NP
• Phrase the problem as a yes/no question
– If we can prove any yes instance is correct (in
polynomial time), it is in NP
– If we can also answer yes or no to the
problem (in polynomial time) without being
given a solution, it is in P
 The Class P
The class of all sets that can be
verified in polynomial time.
AND
The class of all decision
problems that can be
Binary Search
decided in polynomial time.
Dijkstra’s Algorithm

Breadth-First Search

P Sorting Algorithms
 NP
The class of all sets that
can be verified in
Hamilton Cycle polynomial time.

NP Sudoku

Binary Search
SAT
P Dijkstra’s Algorithm

Breadth-First Search …
Sorting Algorithms
…
 Sudoku
Input: n x n x n sudoku instance

Output: YES if this sudoku has a solution

NO if it does not

The Set “SUDOKU”

SUDOKU = { All solvable sudoku instances }
 Hamilton Cycle
Given a graph G = (V,E), is there a cycle that
visits all the nodes exactly once?

YES if G has a Hamilton cycle

NO if G has no Hamilton cycle

The Set “HAM”

HAM = { graph G | G has a Hamilton cycle }
 Circuit-Satisfiability
Input: A circuit C with one output

Output: YES if C is satisfiable

NO if C is not satisfiable

AND NOT
The Set “SAT”
SAT = { all satisfiable circuits C }
AND
 Verifying Membership

Is there a short “proof” I can give you to verify that:

G  HAM?
G  Sudoku?
G  SAT?

Yes: I can just give you the cycle, solution, circuit

 The Class NP
The class of sets for which there exist
“short” proofs of membership
(of polynomial length)
that can “quickly” verified
(in polynomial time).

Fact: P  NP

Recall: The algorithm doesn’t have to find the proof; it just needs to be
able to verify that it is a “correct” proof.
 Summary: P versus NP
NP: “proof of membership” in a set can be verified in
polynomial time.

P: in NP (membership verified in polynomial time)

AND membership in a set can be decided in polynomial time.

Fact: P  NP
Question: Does NP  P ?
i.e. Does P = NP?
People generally believe P ≠ NP, but no proof yet
Why Care?
NP Contains Lots of Problems
We Don’t Know to be in P

Classroom Scheduling
Packing objects into bins
Scheduling jobs on machines
Finding cheap tours visiting a subset of cities
Finding good packet routings in networks
Decryption
…

OK, OK, I care...

 How could we prove that NP = P?

We would have to show that every set in NP has a

polynomial time algorithm…

How do I do that?
It may take a long time!
Also, what if I forgot one of the sets in NP?
 How could we prove that NP = P?

We can describe just one problem L in NP, such that if

this problem L is in P, then NP  P.

It is a problem that can capture all other problems in NP.

The “Hardest” Set in NP

We call these problems NP-complete

Theorem [Cook/Levin]

SAT is one problem in NP, such that if we can show SAT

is in P, then we have shown NP = P.

SAT is a problem in NP that can capture all other

languages in NP.

We say SAT is NP-complete.

 Poly-time reducible to each other
Answer Takes polynomial time

Instance of Map instance of Y

into instance of X
problem Y

Oracle for Oracle for

Answer
problem Y problem X

can be reduced can be reduced

(in polytime to) (in polytime to)
an instance of an instance of
Any problem in NP SAT Sudoku

hence SAT is hence Sudoku

NP-complete is NP-complete
NP-complete: The “Hardest” problems in NP

Sudoku Clique
SAT Independent-Set
3-Colorability HAM
These problems are all “polynomial-time equivalent”
i.e., each of these can be reduced to any of the others
in polynomial time

If you get a polynomial-time algorithm for one,

you get a polynomial-time algorithm for ALL.
(you get millions of dollars, you solve decryption, … etc.)