BITS, PILANI – K. K.

BIRLA GOA CAMPUS

Design & Analysis of Algorithms

(CS F364)

Lecture No. 16

1
 Class P
Informal discussion
The class P consists of those problems that are solvable
in polynomial time.
More specifically, they are problems that can be solved
in time O(nk) for some constant k, where n is the size of
the input to the problem.
Most of the problems we have examined are in class P
 Class NP
Consider Hamiltonian cycle problem
Given a directed graph G = (V, E) a ‘certificate’ is a
sequence v = (v1 ,v2 ,v3 ,…..v|V|) of |V| vertices.
We can easily check/verify in polynomial time if v is an
Hamiltonian cycle or not.
Consider the problem of 3-CNF Satisfiability
A certificate here is an assignment of values to the
variables.
We can easily check/verify in polynomial time
whether the assignment satisfies the boolean formula.
 Class NP
The class NP consists of those problems that are
verifiable in polynomial time.
Already observed that Hamiltonian Cycle Problem &
3-CNF Satisfiability problem are in class NP.
Note
If a problem is in P then we can solve it in polynomial
time & so given a certificate it is verifiable in
polynomial time
Therefore P  NP
The open question is whether P ⊂ NP?
 Class NP-Complete
A problem is in the class NPC (referred as NP-Complete) if
1. It is in NP
2. Is as ‘hard’ as any problem in NP
Note
Most computer scientists believe that NP-complete
problems are intractable.
Because, if any NP-complete problem can be solved in
polynomial time then every problem in NP has a
polynomial time algorithm.
- We will prove this later
 NPC
Technique to show that the problem is NP-complete:
Different than what we have been doing:
We are not trying to prove the existence of polynomial
time algorithm
Instead we are trying to show that no efficient or
polynomial time algorithm is likely to exist.
Three key ideas needed to show problem is NPC
1. Decision problem vs. Optimization problem
2. Reductions
3. First NP-complete problem
Decision problem vs. Optimization problem
Remark: An optimization problem usually has a
corresponding decision problem.
Usually easily defined with the help of a bound on the value
of feasible solutions

Example
Optimization problem: Minimum Spanning Tree
Given a weighted graph find a minimum spanning tree (MST)
of G
Decision problem: Decision Spanning Tree (DST)
Given a weighted graph and an integer k, does G have a
spanning tree of weight at most k?
Decision problem vs. Optimization problem
Observe, if one can solve an optimization problem (in
polynomial time), then one can answer the decision
version (in polynomial time)
Example: If we know how to solve MST we can solve DST
which asks if there is an Spanning Tree with weight at
most k.
How?
First solve the MST problem and then check if the MST
has cost k.
If it does, answer Yes.
If it doesn’t, answer No
Decision problem vs. Optimization problem

Observe, if optimization problem is easy then the

decision version is easy.
Alternately
If we give evidence that a decision problem is hard then
we give evidence that its corresponding optimization
problem is hard.
This is important observation for us.
 Reduction
Let us consider a decision problem A
We want to solve it in polynomial time
Suppose we already know how to solve another decision
problem B in polynomial time
Additionally we also have a procedure/algorithm that
transforms any instance x of A into some instance y of B
with the following properties:
• The transformation takes polynomial time
• Answer for x is YES if and only if the answer for y is also
YES
Such a procedure is called a polynomial time reduction
algorithm .
It helps us to solve problem A in polynomial time.
 Reduction
Pictorial Representation
yes
yes
Instance x Polynomial time Instance y Polynomial time
of A reduction algorithm of B algorithm to decide B no no

Polynomial time algorithm to decide A

1. Given an instance x of A, use polynomial time reduction

algorithm to transform it to an instance y of problem B
2. Run the polynomial time decision algorithm for B on the
instance y
3. Use the answer for y as the answer for x
 Reduction
Using reduction idea to prove a decision problem is
hard.
Suppose we have to prove that no polynomial time
algorithm can exist for a decision problem B.
Suppose we have a decision problem A for which we
already know that no polynomial time algorithm can
exist.
Suppose further we have a polynomial time reduction
algorithm transforming instances of A to instances of B.
By contradiction we can prove that no polynomial time
algorithm can exist for B.
 Reduction
Suppose otherwise, i.e., suppose that B has a
polynomial time algorithm .
Then as observed earlier, we would have a polynomial
time algorithm for A, which is a contradiction.
 1st NP-Complete Problem
Key step in using reduction is to start with a already
known NP-Complete problem.
We need a ‘first’ NP-Complete problem.
The problem we shall use is the Circuit-Satifiability.
 Notation & Terminology
Abstract problem
An abstract problem Q is a binary relation on a set I of
problem instances and a set S of problems solutions.
The Shortest-Path problem statement is:
Given an undirected graph G= (V,E) and two vertices u, v ∈
V, find the shortest path between u and v.
Each instance is a triple <G, u, v> and the corresponding
solution is the shortest path (v1,v2,...,vk)
Since shortest paths are not necessarily unique, a given
problem instance may have more than one solution.
 Abstract Problem
Since for NP Completeness, we are interested in
Decision Problems.
An abstract decision problem is a function that maps
the instance set to the solution set {0, 1}
The decision problem version of Shortest-path can be
written as follows.
The Path-problem statement is:
Given an undirected graph G= (V,E), two vertices u, v ∈
V, and a non-negative integer k, is there a path
between u and v with length at most k?
 Abstract Problem
The abstract decision problem is represented by the function :
Path: I → {0,1}

If i = < G,u,v,k > ∈ I then

Path(i) = 1, if there exists a path between u and v with length at most k

0, otherwise
 Encodings
In order to solve a problem by computer, instances must be
represented in a way the computer understands.
An encoding of a set I of abstract objects is a mapping e from I to
a set of strings over an alphabet Σ.
If Σ = {0, 1} we can use the standard binary encoding
e : I → Σ*
We know how to map graphs, programs as binary strings.
A problem whose instance set is the set of strings over Σ is a
concrete problem.
We can use encodings to map an abstract problem to a concrete
problem
 Encodings
We say that an algorithm solves a concrete problem in O(T(n))
time if when it is provided a problem instance i of length n=|i|,
the algorithm can produce the solution in at most O(T(n)) time.
For an instance i ∈ I, the length of i, denoted by |i|, is the
number of symbols in e(i).
Using the binary encoding,|0|= 1,|1|= 1,|2|= 2,|3|= 2,|4|= 3,
etc.
The length of an instance of the concrete problem depends
heavily on the encoding used. Some encodings are polynomially
related, so the polynomial-time solvability for problems using
one encoding extends to the other.
There are some possible “expensive” encodings, but we will rule
them out.
We will use the binary encoding as the standard one.
 Encodings
We say that an algorithm solves a concrete problem in
O(T(n)) time if when it is provided a problem instance i of
length n=|i|, the algorithm can produce the solution in at
most O(T(n)) time.
For an instance i ∈ I, the length of i, denoted by |i|, is the
number of symbols in e(i).
Using the binary encoding,|0|= 1,|1|= 1,|2|= 2,|3|=
2,|4|= 3, etc.
We will use the binary encoding as the standard one.
 Formal Language Framework
The formal-language framework allows us to define algorithms
for concrete decision problems as “machines” that operate on
languages.
An alphabet Σ is any finite set of symbols.
A language L over Σ is any set of strings made up of symbols
from Σ.
We denote the empty string by , and the empty language by ∅.
The set/language of all strings over Σ is denoted by Σ*.
So, if Σ = {0,1}, then Σ* = {, 0, 1, 00, 01, 10, 11, 000,...} is the set
of all binary strings.
Every language L over Σ is a subset of Σ*.
 Operations on Languages

Union of L1 and L2 : L1 ∪ L2
Intersection of L1 and L2: L1 ∩ L2
Complement of L: = Σ*− L
Concatenation of L1 and L2:
L1L2 = {x1x2 : x1 ∈ L1 and x2 ∈ L2}
Kleene star of L :
L* = {} ∪ L∪ L^2 ∪ L^3 ∪...where L^k = LL...L, k times.
 Formal Language Framework
Consider the concrete problem corresponding to the
problem of deciding whether a natural number is prime.
Using binary encoding, Σ = {0,1}, this concrete problem is a
function:
Prime: {0,1}* → {0,1} with
Prime(10) = Prime(11) = Prime(101) = Prime(111) = 1
Prime(0) = Prime(1) = Prime(100) = Prime(110) = 0
We can associate with Prime a language LPRIME
corresponding to all strings s over {0,1} with Prime(s) = 1:
LPRIME = {10,11,101,111,1011,1101,...}
Sometimes it’s convenient to use the same name for
the concrete problem and its associated language :
Prime = {10,11,101,111,1011,1101,...}