UNIT-1

Short Answer Questions

1) Define asymptotic notations and list different types.

Asymptotic notations are used to describe the behavior of functions as the input size
approaches infinity. These notations help in analyzing the efficiency of algorithms by providing
a way to compare their growth rates.

Types of Asymptotic Notations:

1. Big O Notation (O):

o Definition: Represents the upper bound of an algorithm's running time, showing
the worst-case scenario.
o Example: O(n) – The running time grows linearly with the input size.
2. Omega Notation (Ω):
o Definition: Represents the lower bound, showing the best-case scenario for an
algorithm's running time.
o Example: Ω(n) – The running time is at least linear.
3. Theta Notation (Θ):
o Definition: Represents a tight bound, meaning the algorithm's running time grows
at the same rate for both worst-case and best-case scenarios.
o Example: Θ(n) – The running time grows linearly with the input size in both cases.
4. Little o Notation (o):
o Definition: Represents an upper bound that is not tight; the algorithm’s running
time grows strictly slower than the function.
o Example: o(n²) – The running time grows strictly slower than quadratic time.
5. Little ω Notation (ω):
o Definition: Represents a lower bound that is not tight; the algorithm’s running
time grows strictly faster than the function.
o Example: ω(n) – The running time grows strictly faster than linear time.

2) What is a B-Tree? Explain its applications.

Definition: A B-Tree is a self-balancing search tree where each node can have more than two
children. It ensures efficient searching, insertion, and deletion operations.

Database Indexing: B-Trees are used to create indexes in databases for fast retrieval of data.
They allow efficient searching, insertion, and deletion operations.

File Systems: In file systems like NTFS, B-Trees are used to store directory structures and
file metadata, enabling efficient access to files.
 Multi-Level Indexing: B-Trees are used in multi-level indexing for quick access to large
datasets, such as in search engines and large-scale databases.

Data Compression: B-Trees are applied in data compression algorithms, helping in efficient
storage and retrieval of compressed data.

3) What is an AVL tree? Explain its applications.

An AVL tree is a self-balancing binary search tree (BST), where the difference in height
between the left and right subtrees of any node (called the balance factor) is at most 1. This
ensures that the tree remains balanced, providing O(log n) time complexity for search, insert,
and delete operations.

Applications of AVL Tree:

1. Searching and Sorting: AVL trees are used in dynamic searching and sorting
operations where data needs to be quickly inserted, deleted, or searched, such as in
database indexing.
2. Priority Queues: Used in implementing priority queues to ensure efficient insertion and
deletion of elements based on priority.
3. Memory Management: AVL trees are used in memory management algorithms, such as
in free list management to keep track of available memory blocks.
4. Maintaining Sorted Data: Applied in applications where the data is constantly
changing, like in file systems that need efficient data retrieval and updates.

4) Compare B-Trees and AVL Trees.

Feature B-Tree AVL Tree
Multi-level search tree where nodes
Binary search tree with only two children
Structure can have multiple keys and
per node.
children.
Balanced by ensuring that all leaf Balanced by ensuring the height difference
Balancing
nodes are at the same level. between left and right subtrees is at most 1.
Primarily used in applications requiring
Mainly used in databases and file
Use Case fast dynamic searches, like in-memory
systems for efficient data retrieval.
searches.
Time O(log n) for search, insert, and
O(log n) for search, insert, and delete.
Complexity delete.
Each node can store multiple keys Each node stores a single key and has two
Node Size
and child pointers. child pointers.
Space Less space-efficient due to larger
More space-efficient compared to B-Trees.
Efficiency nodes.
 5) What is the balance factor in AVL trees? Give an example.

Balance Factor is the difference in height between the left and right subtrees of a node in an
AVL tree.

Balance Factor=Height(Left Subtree)−Height(Right Subtree)\text{Balance Factor} =

\text{Height(Left Subtree)} - \text{Height(Right
Subtree)}Balance Factor=Height(Left Subtree)−Height(Right Subtree)

For an AVL tree to remain balanced, the balance factor of every node must be -1, 0, or +1.

30

/ \

20 40

10

 Node 30: Left height = 2, Right height = 1 → Balance Factor = 2 - 1 = +1

 Node 20: Left height = 1, Right height = 0 → Balance Factor = +1
 Node 10 and 40: No children → Balance Factor = 0

All balance factors are within [-1, 0, +1], so it's a valid AVL tree.

Long Answer Questions

1) Explain the concept of algorithm analysis and its importance. Discuss different types of
complexities involved.
2) Describe the time and space complexity analysis of algorithms. How are Big O, Big Theta,
and Big Omega used to express complexity?
3) What are AVL trees? Explain the process of insertion and deletion in AVL trees with
examples.
An AVL tree defined as a self-balancing Binary Search Tree (BST) where the
difference between heights of left and right subtrees for any node cannot be more than one.

The difference between the heights of the left subtree and the right subtree for any node is
known as the balance factor of the node.
The AVL tree is named after its inventors, Georgy Adelson-Velsky and Evgenii Landis,
who published it in their 1962 paper “An algorithm for the organization of information”.

Example of AVL Trees:

The above tree is AVL because the differences between the heights of left and right
subtrees for every node are less than or equal to 1.

Operations on an AVL Tree:

1. Insertion: After performing insertion operation on AVL tree, the balance factor of
each node is checked.
There are following two cases possible-
Case-01:
After the operation, the tree is balanced. In this case, the AVL tree is considered to be
balanced. The operation is concluded.
Case-02:
After the operation, the tree is imbalanced. In this case, the AVL tree is considered to be
imbalanced. Rotations are then performed to balance the tree.
Cases Of Imbalance And Their Balancing Using Rotation
Operations- Case-01:
2. Deletion: After performing deletion operation on AVL tree, the balance factor of
each node is checked and rebalanced if required.

3. Searching: It is similar to performing a search in BST

Advantages Of AVL Trees
 It is always height balanced.
 Height Never Goes Beyond LogN, where N is the number of nodes.
 It give better search than compared to binary search tree.
 It has self balancing capabilities.

Time Complexities:
Construct an AVL Tree with the following elements

21, 26, 30, 9, 4, 14, 28, 18,15,10, 2, 3, 7

4)What are B-Trees? Discuss the creation, insertion, and deletion operations of B-Trees
and their applications.
B-trees are self-balancing tree data structures that are commonly used in databases
and file systems. They are optimized for storing and retrieving large amounts of data on
disk, where disk access is much slower than memory access.

Here's a breakdown of the key aspects of B-trees:

Structure:

Nodes: B-trees consist of nodes, each of which can hold multiple keys and pointers to
child nodes.

Keys: Keys within a node are stored in sorted order.

Children: The number of child nodes a node has is always one more than the number
of keys it contains.

Root: The topmost node of the tree.

Internal Nodes: Nodes between the root and leaf nodes.

Leaf Nodes: Nodes at the bottom level of the tree, holding the actual data entries.

Properties:

 Balanced:

All leaf nodes are at the same level, ensuring consistent performance for all operations.

 Minimum Degree (t):

A B-tree is defined by its minimum degree, which specifies the minimum number
of keys each node (except the root) must contain.

 Maximum Keys:

Each node can hold a maximum of 2t-1 keys.

Advantages:

 Efficient Disk Access:

B-trees minimize the number of disk accesses required for search, insertion, and deletion
operations.

 High Performance:

Their balanced structure guarantees logarithmic time complexity for these operations,
making them suitable for large datasets.

 Dynamic:

B-trees adapt gracefully to data modifications, making them useful for dynamic
environments.

Applications:

 Databases:

B-trees are widely used as the underlying data structure for indexing in relational databases.

 File Systems:

Many file systems use B-trees to manage the directory structure and file location
information.

Properties of B Tree

The following are some important properties of a B Tree:

1. Every node has at most m children, where m is the order of the B Tree.
2. A node having K children consists of K-1 keys.
3. Every non-leaf node, excluding the root node, must have at least [m/2] child nodes.
4. The root node must have at least two children if it is not the leaf node.
5. Unlike the other trees, the height of a B Tree increases upwards toward the
root node, and the insertion happens at the leaf node.
6. The Time Complexity of all the operations of a B Tree is O(log?n), where 'n' is
the number of data elements present in the B Tree.

The following is an example of a B Tree of order 4:

Let us now learn how the insertion works in a B Tree.

Insertion Operation in a B Tree

Insertion of a data element in a B Tree contains two main events:

1. Searching for the appropriate node where the element will be inserted.
2. Splitting of the node, if required.

The Insertion Operation always follows the Bottom-Up approach.

Step 1: If the Tree is empty, a root node is allocated, and we will insert the key.

Step 2: We will then update the allowed number of keys in the node.

Step 3: We will then search for the appropriate node for the insertion of the element.

Step 4: If the node is filled, we will follow the steps shown below.

Step 4.1: Insert the data elements in ascending order.

Step 4.2: Once the data elements exceed their limit, we will split the node at the median.

Step 4.3: We will then push the median key upwards, making the left keys the left
child nodes and the right keys the right child nodes.

Step 5: If the node is not full, we will follow the below step
 Let us understand the steps mentioned above with the illustrations shown below.

Suppose that the following are some data elements that need to be inserted in a B Tree:
7, 8, 9, 10, 11, 16, 21, and 18.

1. Since the maximum degree of a node in the tree is 3; therefore, the maximum number
of keys per node will be 3 - 1 = 2.

2. We will start by inserting data element 7 in the empty tree.

3. We will insert the next data element, i.e., 8, into the tree. Since 8 is greater than 7,
it will be inserted to the right of 7 in the same node.

4. Similarly, we will insert another data element, 9, into the tree on the same to the
right of 8. However, since the maximum number of keys per node can only be 2, the node
will split, pushing the median key 8 upward, making 7 the key of the left child node and
9 the key of the right child node.

5. We will insert the next data element, i.e., 10, into the tree. Since 10 is greater than
9, it will be inserted as a key on the right of the node containing 9 as a key.
6. We will now insert another data element, 11, into the tree. Since 11 is greater than
10, it should be inserted to the right of 10. However, as we know, the maximum number
of keys per node cannot be more than 2; therefore, 10 being the median, will be pushed to
the root node right to 8, splitting 9 and 11 into two separate nodes.

7. We will now insert data element 16 into the tree. Since 16 is greater than 11, it will
be inserted as a key on the right of the node consisting of 11 as a key.

8. The next data element that we will insert into the tree is 21. Element 21 should be
inserted to the right of 16; however, it will exceed the maximum number of keys per node
limit. Therefore, a split will occur, pushing the median key 16 upward and splitting the
left and right keys into separate nodes. But this will again violate the maximum number
of keys per node limit; therefore, a split will once again push the median key 10 upward a
root node and make 8 and 11 its children.
9. At last, we will insert data element 18 into the tree. Since 18 is greater than 16 but
less than 21, it will be inserted as the left key in the node consisting of 21.

10. Hence the resulted B Tree will be as shown below:

Deletion from a B-tree

Deleting an element on a B-tree consists of three main events: searching the node where
the key to be deleted exists, deleting the key and balancing the tree if required.

While deleting a tree, a condition called underflow may occur. Underflow occurs when a
node contains less than the minimum number of keys it should hold.

The terms to be understood before studying deletion operation are:

Inorder Predecessor

The largest key on the left child of a node is called its inorder predecessor.

Inorder Successor

The smallest key on the right child of a node is called its inorder successor.

Deletion Operation

Before going through the steps below, one must know these facts about a B tree of

degree m. A node can have a maximum of m children. (i.e. 3)

A node can contain a maximum of m - 1 keys. (i.e. 2)

A node should have a minimum of ⌈m/2⌉ children. (i.e. 2)

A node (except root node) should contain a minimum of ⌈m/2⌉ - 1 keys. (i.e. 1)
There are three main cases for deletion operation in a B

tree. Case I

The key to be deleted lies in the leaf. There are two cases for it.

The deletion of the key does not violate the property of the minimum number of
keys a node should hold.

In the tree below, deleting 32 does not violate the above properties.
The deletion of the key violates the property of the minimum number of keys a node
should hold. In this case, we borrow a key from its immediate neighboring sibling node
in the order of left to right.

First, visit the immediate left sibling. If the left sibling node has more than a minimum
number of keys, then borrow a key from this node.

Else, check to borrow from the immediate right sibling node.

In the tree below, deleting 31 results in the above condition. Let us borrow a key
from the left sibling node.
If both the immediate sibling nodes already have a minimum number of keys, then merge
the node with either the left sibling node or the right sibling node. This merging is done
through the parent node.

Deleting 30 results in the following case.

Case II

If the key to be deleted lies in the internal node, the following cases occur.

The internal node, which is deleted, is replaced by an inorder predecessor if the left child
has more than the minimum number of keys.
The internal node, which is deleted, is replaced by an inorder successor if the
right child has more than the minimum number of keys.

If either child has exactly a minimum number of keys then, merge the left and the
right children.

After merging if the parent node has less than the minimum number of keys
then, look for the siblings as in Case I.
 Case III

In this case, the height of the tree shrinks. If the target key lies in an internal node, and
the deletion of the key leads to a fewer number of keys in the node (i.e. less than the
minimum required), then look for the inorder predecessor and the inorder successor. If
both the children contain a minimum number of keys then, borrowing cannot take
place. This leads to Case II(3) i.e. merging the children.

Again, look for the sibling to borrow a key. But, if the sibling also has only a minimum
number of keys then, merge the node with the sibling along with the parent. Arrange
the children accordingly (increasing order).

6) Explain the advantages of AVL Trees and B-Trees over other tree data structures in
terms of searching, insertion, and deletion operations.
 UNIT-2

Short Answer Questions

1) Define Min Heap and Max Heap with examples.

Min Heap and Max Heap:

A Heap is a complete binary tree that satisfies the heap property.

 Min Heap: In a Min Heap, the parent node is always smaller than its child nodes.
Example:

10
/ \
20 30
/ \
40 50

Here, 10 is the smallest element at the root.

 Max Heap: In a Max Heap, the parent node is always larger than its child nodes.
Example:

50
/ \
30 40
/ \
10 20

Here, 50 is the largest element at the root.

2) What are priority queues? Mention their applications.

Priority Queues:

A Priority Queue is a special type of queue in which each element is associated with a
priority, and elements are served based on their priority — higher priority elements are
served before lower priority ones, regardless of their insertion order.

Applications of Priority Queues:

 1. CPU Scheduling in operating systems
2. Dijkstra’s Algorithm for shortest path
3. Huffman Coding in data compression
4. Job Scheduling in printers or task managers

3) Differentiate between BFS and DFS in graph traversal.

Feature BFS (Breadth-First DFS (Depth-First

Search) Search)
Traversal Order Level-wise Depth-wise
Data Structure Used Queue Stack or Recursion
Finds shortest path (in May not find shortest
Shortest Path
unweighted) path
Memory Usage Memory Usage Memory Usage
4) What are connected and biconnected components in graphs?

Connected Component:
A connected component is a part of an undirected graph in which every pair of vertices is
connected by a path, and which is connected to no additional vertices in the graph.

Example:
In the graph below:

Component 1: A — B — C
Component 2: D — E

There are two connected components: {A, B, C} and {D, E}.

Biconnected Component:
A biconnected component is a maximal subgraph where removing any single vertex
does not disconnect the subgraph.
It has no articulation points (vertices whose removal increases the number of connected
components).

Example:

A
/\
B—C
 This is a biconnected component because removing any one vertex still keeps the graph

connected.

5) Define Divide and Conquer with an example.

Divide and Conquer:

Divide and Conquer is a problem-solving technique where a problem is:

1. Divided into smaller subproblems

2. Each subproblem is solved recursively
3. The solutions are combined to get the final result

Example:
Merge Sort Algorithm

 Divide: Split the array into two halves

 Conquer: Recursively sort each half
 Combine: Merge the sorted halves

For array [8, 4, 7, 2] →

Divide: [8, 4] and [7, 2]
Sort: [4, 8] and [2, 7]
Merge: [2, 4, 7, 8]

Long Answer Questions

1) What is a Heap? Explain the difference between Min Heap and Max Heap. Discuss
the insertion and deletion operations in heaps.
2) How do you represent a graph? Explain the adjacency matrix and adjacency list
representations of a graph.
3) Discuss the basic search and traversal techniques in graphs (BFS and DFS). How
are connected and biconnected components identified?
4) Explain the Divide and Conquer method. Provide detailed steps for Quick Sort and
Merge Sort algorithms.
5) What is the Convex Hull problem? Explain the solution to the Convex Hull problem
using Divide and Conquer technique.
 UNIT-3

Short Answer Questions

1) What is the Greedy Method?

The greedy method is useful for the problems which cannot be divisible. The Greedy
Method is a problem-solving approach used in algorithm design where the solution is
built step-by-step, making the best possible (greedy) choice at each step, with the hope
that these local optimal choices will lead to a globally optimal solution.
Examples of Greedy Method:

Ex-1: Find the maximum value of the function z = 3x + 4y subjected to 0 ≤ x ≤ 1 and -1

≤ y ≤ 1.

Sol: Assume input set as (x, y) = {(0, -1), (0, 0), (0, 1), (1, -1), (1, 0), (1, 1), (2, 2), (3, 3),
(4, 4)}

 In Greedy method, we will apply constraints for input set, then some of the inputs may be
eliminated from the input set.
 The remaining inputs are known as feasible solutions.
 Next, from feasible solutions, take one input at a time and check whether the input leads
to optimal solution or not.

2) Define the Knapsack Problem.

The Greedy Method is used to solve the Fractional Knapsack Problem by selecting
items based on the highest profit-to-weight ratio.

Example Table:
Item Profit (P) Weight (W) P/W (Profit/Weight)
1 60 10 6.0
2 100 20 5.0
3 120 30 4.0
Knapsack Capacity = 50 kg
Greedy Selection Steps:

 Take Item 1 (10 kg) → Profit = 60

 Take Item 2 (20 kg) → Profit = 100
 Take 20 kg of Item 3 (out of 30 kg) → Profit = (20/30) × 120 = 80
 Total Profit = 60 + 100 + 80 = 240

3) What is a Minimum Cost Spanning Tree (MST)?

A Minimum Cost Spanning Tree (MST) is a way to connect all the vertices (nodes) in a
graph using the least total cost.

 It includes all the vertices.

 It does not have any cycles (no loops).
 It uses minimum number of edges = (n − 1), where n is the number of vertices.
 Among all possible trees, it gives the lowest total weight (cost).

Example:
If cities are connected by roads with different costs, MST gives the cheapest way to
connect all cities.

4) State Dijkstra’s algorithm and its purpose.

Purpose:
Dijkstra’s algorithm is used to find the shortest path from a starting node to all other
nodes in a weighted graph (with non-negative weights).

Dijkstra’s Algorithm Steps:

1. Start with the source vertex. Set its distance as 0 and all others as infinity (∞).
2. Visit the nearest vertex that is not yet visited.
3. Update the distances of its neighboring vertices.
4. Repeat the process for the next nearest vertex.
5. Continue until all vertices are visited.

It helps in navigation apps, network routing, and many real-life shortest path problems.

5) What is Dynamic Programming? Give an example.

Dynamic Programming (DP) is a method used to solve complex problems by

breaking them into smaller sub-problems, solving each sub-problem only once, and storing
their results for future use.

It avoids repeating the same calculations, so it saves time and improves efficiency.
Example:
Fibonacci Series using DP
F(0) = 0, F(1) = 1
F(n) = F(n−1) + F(n−2)

Instead of calculating F(n−1) and F(n−2) again and again, we store the results in an array and
reuse them.

Long Answer Questions

1) What is the Greedy method? Discuss the Job Sequencing with deadlines problem
and its solution using the Greedy approach.
Greedy Method:

The greedy method is useful for the problems which cannot be divisible. The
terminologies used in the greedy method are:

1. Objective Function:

The problems that can be solved using Greedy method have 'n' inputs and a set of
constraints. This is called as objective function.

2. Feasible Solutions:

 Any input that satisfies the constraints of an objective function is called a feasible
solution.
 We need to find a feasible solution that either maximizes or minimizes a given objective
function.

3. Optimal Solution:

 It is a feasible solution that either maximizes or minimizes the function; this is called an
optimal solution.
 Some problems consider maximum value as an optimal solution.
Ex: Problems related to find the profit value expect maximum value as output.
 Some problems consider minimum value as an optimal solution.
Ex: Problems related to find the distance between two points expect minimum value as
output.
 Examples of Greedy Method:

Ex-1: Find the maximum value of the function z = 3x + 4y subjected to 0 ≤ x ≤ 1 and -1

≤ y ≤ 1.

Sol: Assume input set as (x, y) = {(0, -1), (0, 0), (0, 1), (1, -1), (1, 0), (1, 1), (2, 2), (3, 3),
(4, 4)}

 In Greedy method, we will apply constraints for input set, then some of the inputs may be
eliminated from the input set.
 The remaining inputs are known as feasible solutions.
 Next, from feasible solutions, take one input at a time and check whether the input leads
to optimal solution or not.

2) Explain the 0/1 Knapsack problem. How can the Greedy method be used to solve
this problem

3) Describe the process of finding the Minimum Cost Spanning Tree using Prim’s and
Kruskal’s algorithm.

4) What is Dynamic Programming? Explain the All-Pairs Shortest Paths problem and
the solution using Dynamic Programming.
5) Explain the Bellman-Ford algorithm and its application to find the shortest paths
from a single
source in a graph with negative weights.

UNIT-4

Short Answer Questions

1) What is backtracking? Give an example.

Backtracking is a method used to solve problems step-by-step, and if a step leads to

a wrong solution, it goes back (backtracks) and tries a different option.

It is useful for solving problems with multiple possible solutions, like puzzles or
combinations.

Example:
N-Queens Problem
Place N queens on an N×N chessboard such that no two queens attack each other.
Backtracking tries placing a queen in one row, and if it causes a conflict later, it removes the
queen and tries another position.

2) State the 8-Queens problem.

The 8-Queens problem is a puzzle where you need to place 8 queens on a chessboard
of size 8x8 such that no two queens can attack each other. This means that no two queens
can be on the same row, same column, or on the same diagonal.

Simple Example:

 You place one queen per row.

 Each queen must be placed in a column where it is not in the same vertical line as another
queen and must not share any diagonal with another queen.

Here's a very simple solution for the 8-Queens problem: Q . . . . . . .

....Q...

......Q.

..Q.....

.....Q..

...Q....

.Q......

.......Q

In this example, you can see that:

 Each row has exactly one queen.

 Each column has exactly one queen.
 No two queens are on the same diagonal.

3) Explain the graph coloring problem in backtracking. Define the Travelling

Salesperson Problem (TSP) in Branch and Bound.
The Graph Coloring Problem is about assigning colors to the vertices of a graph such
that no two adjacent vertices have the same color. The objective is to minimize the number
of colors used while ensuring that no two connected vertices share the same color.
 Backtracking is a method used to solve this problem by trying different color assignments
and backtracking when a conflict arises (i.e., when two adjacent vertices have the same
color). If a color assignment works, the process continues; otherwise, the algorithm tries
another option.
Example: For a simple graph with 3 vertices connected in a line, we can color them with
two colors, such as:
Vertex 1: Color 1
Vertex 2: Color 2
Vertex 3: Color 1

In this example, no two adjacent vertices have the same color, solving the problem
with 2 colors.

The Travelling Salesperson Problem (TSP) is a classic optimization problem

where a salesperson must visit a set of cities exactly once and return to the starting city,
while minimizing the total distance traveled.

Aspect Backtracking Branch & Bound The

Definition Solves problems Solves optimization problems
incrementally, backtracking by eliminating suboptimal
when a solution fails. paths using bounds.
Approach Depth-first search, exploring Depth-first and breadth-first
one solution at a time. search, with bounds to prune
unpromising paths.
Efficiency Can explore many More efficient, prunes
unnecessary paths. unpromising branches early.
Typical Use Cases N-Queens, Sudoku, Graph TSP, Knapsack problem,
Coloring. Integer programming.
Solution Guarantee Finds a solution, but not Guarantees the optimal
necessarily the best. solution (min or max).
Branch and Bound method is used to solve this problem by systematically exploring all
possible routes and "bounding" (eliminating) paths that are unlikely to lead to the optimal
solution. The algorithm divides the problem into smaller subproblems (branching) and uses
bounds to prune paths that are not promising, reducing the number of possible solutions to
explore.

Example: If a salesperson needs to visit cities A, B, and C, the Branch and Bound method
would evaluate all possible routes, calculate lower bounds for each path, and eliminate routes
that exceed the shortest known path

4) What is the difference between backtracking and Branch & Bound?

 Long Answer Questions

1) What is Backtracking? Discuss the general method of backtracking and its

application to the 8-Queens problem.
2) Explain the Sum of Subsets problem and how backtracking is used to solve it.
3) How Graph Coloring is approached using backtracking? Explain the solution
approach and its complexity.
4) What is the 0/1 Knapsack problem and how is it solved using Backtracking?
5) Explain the concept of Branch and Bound. How is it applied to solve the Traveling
Salesperson Problem (TSP)?

UNIT-5

Short Answer Questions

1) Define NP-Hard and NP-Complete problems.

NP-Hard:

Definition: A problem is NP-Hard if it is at least as difficult as the hardest problems in NP.

Solving an NP-Hard problem efficiently would also help solve all NP problems, but NP-
Hard problems may not be in NP.

Example: Halting Problem – It is NP-Hard, but not in NP.

NP-Complete:

Definition: A problem is NP-Complete if it is both in NP and as difficult as any other

problem in NP. If we find an efficient solution to one NP-Complete problem, we can solve
all NP problems efficiently.

Example: Traveling Salesman Problem (TSP) – It is NP-Complete because it is in NP

and as difficult as any NP problem.

2) What is Cook’s theorem?

3) Cook's Theorem states that the Boolean satisfiability problem (SAT) is NP-complete.
This means that SAT is the first problem proven to be as difficult as all problems in NP. If
we can solve SAT in polynomial time, we can solve all NP problems in polynomial time.
4) Example: Consider a logical expression like:
(A OR B) AND (NOT A OR C) AND (B OR NOT C)
5) The SAT problem asks if there exists a way to assign true/false values to the variables A,
B, and C such that the entire expression is true. If we can find a solution to this expression,
we’ve solved the SAT problem.
6) Cook's Theorem shows that if we can find a polynomial-time solution to SAT, we can
solve all other NP problems in polynomial time.

7) Define the Clique Decision Problem (CDP).

The Clique Decision Problem (CDP) asks whether a given graph contains a clique of a
specific size. A clique is a subset of vertices in a graph such that every two distinct
vertices are connected by an edge.

Formally:

 Given a graph G and a number k, the problem is to determine if there exists a clique of
size k in G.

Example:

 Graph: A graph with 5 vertices (A, B, C, D, E) where the edges are:

A-B, A-C, B-C, C-D, D-E, A-D.
 Clique of size 3: A possible clique is {A, B, C} since all three vertices are connected.

8) What is the Chromatic Number Decision Problem (CNDP)?

The Clique Decision Problem (CDP) asks whether a given graph contains a clique of a
specific size k. A clique is a subset of vertices in which every two distinct vertices are
connected by an edge.

Formally: Given a graph G and an integer k, the problem is to determine whether there exists
a clique of size k in G.

Example:
For a graph with vertices A, B, C, D, and edges A-B, A-C, B-C, C-D, and D-E, a clique of
size 3 would be {A, B, C}, since all three vertices are connected to each other.

9) Explain the difference between P, NP, NP-Hard, and NP-Complete classes.

P (Polynomial Time):
Problems that can be solved in polynomial time (efficiently).
Example: Sorting, searching.
 NP (Nondeterministic Polynomial Time):
Problems for which a solution can be verified in polynomial time, but finding the
solution may take longer.
Example: Sudoku, graph coloring.

NP-Hard:
Problems that are at least as hard as the hardest NP problems. Not necessarily in NP and
may not have a verifiable solution.
Example: Halting problem.

NP-Complete:
Problems that are both in NP and as hard as any NP problem. If one NP-Complete
problem is solved in polynomial time, all NP problems can be solved in polynomial time.
Example: Traveling Salesman Problem (TSP).

Long Answer Questions

6) What are NP-Hard and NP-Complete problems? Explain the difference between
these two classes with examples.
7) Explain Cook’s theorem and its significance in the theory of NP-completeness.
8) Discuss the Clique Decision Problem (CDP) and its relation to NP-Hard problems.
9) How is the Chromatic Number Decision Problem (CNDP) related to graph coloring
and NP-Hard problems?
10) Explain the Job Shop Scheduling problem in the context of NP-Hard problems.
How is it classified, and what are its practical applications?