a. Arrange algorithm complexities: O(n), O(n²), O(n!

), O(log(n)), O(2^n), O(n *

log(n))
Answer: The complexities in increasing order are:
1. O(log(n))
2. O(n)
3. O(n * log(n))
4. O(n²)
5. O(2^n)
6. O(n!)
b. An algorithm performs n iterations, where each iteration involves a
constant time operation. What is the time complexity of this algorithm?
Justify your answer.
Answer: The time complexity is O(n) because the algorithm performs n
iterations, and each iteration takes constant time. Multiplying constant time by
n gives a linear time complexity.
c. Define Big Omega notation and explain how it is used to describe the lower
bound of an algorithm's running time.
Answer: Big Omega (Ω) notation represents the lower bound of an algorithm's
running time. It gives the best-case scenario or the minimum time the
algorithm will take for the largest input size. Formally, if an algorithm takes at
least f(n) time for sufficiently large n, then the time complexity is said to be
Ω(f(n)).
d. What is the relationship between Big O, Big Omega, and Big Theta
notations? Provide examples where each of these notations are used.
Answer:
• Big O (O): Represents the upper bound (worst-case scenario). Example:
For an algorithm that takes at most O(n²) time.
• Big Omega (Ω): Represents the lower bound (best-case scenario).
Example: An algorithm that always takes at least Ω(n) time.
 • Big Theta (Θ): Represents both the upper and lower bounds, meaning
the algorithm's running time grows at the same rate both in the best and
worst cases. Example: Merge Sort is Θ(n * log(n)).
e. Define Big Theta notation and explain its significance in representing both
the upper and lower bounds of an algorithm. Provide an example.
Answer: Big Theta (Θ) notation represents both the upper and lower bounds
of an algorithm’s time complexity. It means the running time of the algorithm
will always grow at the same rate as f(n) for large n, both in the best and worst
cases. Example: Merge Sort has a time complexity of Θ(n * log(n)), meaning it
will always take n * log(n) time regardless of the input.
f. How does Big Theta differ from Big O and Big Omega notations in terms of
algorithm analysis? What is the impact of input size on them?
Answer:
• Big O gives the worst-case complexity.
• Big Omega gives the best-case complexity.
• Big Theta provides a precise description of the running time, bounding it
from both above and below. The input size impacts the notations by
determining the growth rate of the algorithm. Larger input sizes magnify
the differences between the notations (e.g., O(n²) will eventually be
slower than O(n log n)).
g. Define the terms "best-case", "worst-case" and "average-case" time
complexities. How do these relate to Big O, Big Omega, and Big Theta?
Answer:
• Best-case time complexity: The minimum time the algorithm takes for
an input. This corresponds to Big Omega (Ω).
• Worst-case time complexity: The maximum time the algorithm takes for
an input. This corresponds to Big O (O).
• Average-case time complexity: The expected time for an algorithm on a
randomly chosen input. This may not have a simple notation and is
typically analyzed using probabilistic methods.
• Big O focuses on worst-case, Big Omega on best-case, and Big Theta
represents the overall time complexity for both.
h. Explain the best, worst, and average case time complexity for Merge Sort.
Answer:
• Best-case: O(n log n) (occurs when the array is already sorted or nearly
sorted).
• Worst-case: O(n log n) (Merge Sort always takes the same time, even for
the worst input).
• Average-case: O(n log n) (due to its divide-and-conquer nature, it always
splits the array in half).
i. In the case of Quick Sort, explain how the worst-case time complexity can
be avoided with a good choice of pivot. What are the best, worst, and
average case complexities?
Answer:
• Best-case: O(n log n) (when the pivot divides the array in half).
• Worst-case: O(n²) (occurs when the pivot is always the smallest or
largest element, causing unbalanced partitions).
• Average-case: O(n log n) (with a good pivot, Quick Sort divides the array
evenly on average). Choosing a good pivot (e.g., using the median of
three elements or randomizing) can help avoid the worst-case
complexity.
n. Analyze the time complexity of Heap Sort in the best, worst, and average
cases.
Answer:
• Best-case: O(n log n) (the time complexity is the same regardless of the
input since the heap structure always requires log n time for insertion
and deletion).
• Worst-case: O(n log n) (similar to best-case, as the heap's operations do
not depend on input order).
• Average-case: O(n log n) (again, the heap operations remain consistent
regardless of the input).
o. What does the class P represent in computational complexity, and why are
problems in this class considered efficiently solvable?
Answer: Class P represents problems that can be solved in polynomial time.
These problems are considered efficiently solvable because their time
complexity grows at a manageable rate (e.g., O(n), O(n²), O(n log n)) as the
input size increases. Problems in P can be solved in a reasonable amount of
time, even for large inputs.
p. Define NP (Non-deterministic Polynomial Time) problems. Provide an
example of a well-known problem that belongs to NP.
Answer:
NP problems are decision problems for which a proposed solution can be
verified in polynomial time by a deterministic Turing machine. These problems
are not necessarily solvable in polynomial time, but if a solution is provided, it
can be checked quickly (in polynomial time).
Example: The Travelling Salesman Problem (TSP) is a well-known NP problem.
Given a set of cities and the distances between them, the task is to determine
the shortest possible route that visits each city exactly once and returns to the
origin city. While finding the optimal solution is difficult, verifying a proposed
route's length is relatively easy.

q. Define NP-Hard problems and explain how they differ from NP-Complete
problems.
Answer:
NP-Hard problems are at least as hard as the hardest problems in NP. These
problems may not necessarily belong to NP, meaning their solutions may not
be verifiable in polynomial time. However, if any NP-Hard problem can be
solved in polynomial time, then all NP problems can be solved in polynomial
time.
NP-Complete problems, on the other hand, are both in NP and are NP-Hard. In
other words, NP-Complete problems are the hardest problems in NP, and if one
NP-Complete problem can be solved in polynomial time, all NP problems can
be solved in polynomial time.

c. Discuss the time complexity of a typical Brute Force algorithm and its
limitations when dealing with large input sizes.
Answer:
The time complexity of a typical Brute Force algorithm is usually O(n^k), where
n is the input size and k is a constant that depends on the problem. Brute Force
algorithms try all possible solutions and check each one. For large input sizes,
this approach becomes infeasible because the time complexity grows rapidly.
Limitations: When dealing with large inputs, Brute Force algorithms become
very slow and inefficient due to the exponential or polynomial growth in the
number of possibilities that need to be checked. This makes them impractical
for large-scale problems.

j. Explain dynamic programming for Fibonacci series, multi-stage graph

problem, chain matrix multiplication. Use suitable example and analyze time
complexity of each of them.
Answer:
1. Fibonacci series (Dynamic Programming):
In Dynamic Programming, we store the results of subproblems to avoid
redundant calculations. The recursive formula for Fibonacci is:
F(n) = F(n-1) + F(n-2)
Instead of recomputing the values for each recursive call, we store them
in a table.
Time complexity: O(n) because we only calculate each Fibonacci number once.
2. Multi-stage Graph Problem (Shortest Path):
In the multi-stage graph problem, the goal is to find the shortest path
from the source to the destination. We solve this by breaking down the
problem into stages, solving each subproblem optimally and using the
results to construct the solution.
Example: Finding the shortest path in a directed graph. At each node, we store
the minimum distance to the destination, and then calculate it iteratively for
each node.
Time complexity: O(V + E), where V is the number of vertices and E is the
number of edges.
3. Chain Matrix Multiplication:
Given a chain of matrices, the objective is to find the most efficient way
to multiply them together. The problem is broken into subproblems
 where each subproblem computes the minimum number of
multiplications needed to multiply a subset of matrices.
Example: For matrices A1, A2, A3, ..., An, the goal is to find the optimal way to
parenthesize the product to minimize the number of scalar multiplications.
Time complexity: O(n^3), where n is the number of matrices.

k. Explain backtracking for complexity of each of them. N-Queen problem.

Use suitable example and analyze time solved this question in details.
Answer:
Backtracking is a general algorithmic technique for solving optimization
problems, where we incrementally build candidates for the solution and
discard those that fail to satisfy the problem’s constraints. It involves exploring
all possible solutions and backtracking when we encounter a dead-end.
N-Queen Problem:
In the N-Queen problem, we are given an N x N chessboard, and we need to
place N queens on the board such that no two queens threaten each other (no
two queens can share the same row, column, or diagonal).
Approach:
1. Place a queen in the first column of the first row.
2. Move to the next row and place the queen in a valid column.
3. Continue placing queens row by row.
4. If at any point we cannot place a queen, we backtrack by removing the
last placed queen and try a different column.
5. Repeat the process until all queens are placed.
Time complexity:
The worst-case time complexity of the backtracking algorithm for the N-Queen
problem is O(N!) because in the worst case, for each row, we try placing the
queen in all N columns and backtrack when necessary.
Example:
For N = 4, the algorithm tries all possible placements of queens. It starts with
. Define the TSP and explain why it is an NP-hard problem:
• Definition: The Traveling Salesman Problem (TSP) asks for the shortest
possible route that visits each city once and returns to the starting city.
Given a set of cities and the distances between them, the goal is to find
the minimum distance that allows visiting all cities exactly once and
returning to the origin city.
• NP-hard explanation: TSP is classified as NP-hard because no known
algorithm can solve it in polynomial time for all cases. It is a
combinatorial optimization problem, and the solution space grows
factorially as the number of cities increases (since there are n! possible
routes). Verifying a given solution (checking if a given tour is valid and
has the shortest length) can be done in polynomial time, but finding the
optimal solution takes exponential time, making it NP-hard.
b. Discuss the brute force approach for solving TSP and explain its time
complexity:
• Brute Force Approach: The brute force approach involves generating all
possible permutations of the cities, calculating the distance for each
permutation, and then selecting the one with the shortest total distance.
This guarantees the correct solution but is inefficient for large numbers
of cities.
• Time Complexity: Since there are n cities, the number of possible
permutations is n! (factorial). For each permutation, the distance must
be calculated, which takes O(n) time. Therefore, the total time
complexity of the brute force approach is O(n * n!), which is very slow
for large n.
c. Explain the branch-and-bound technique for solving TSP. How does it
improve over the brute force method? Illustrate with a simple example:
• Branch-and-Bound Technique: Branch-and-bound is a more efficient
method to solve TSP by systematically exploring subsets of solutions. It
works by "bounding" (i.e., calculating lower bounds) the potential
solutions and pruning branches of the search tree that cannot lead to an
optimal solution. This reduces the number of permutations that need to
be considered, as branches that exceed the current best solution are
discarded early.
 • Improvement over Brute Force: Branch-and-bound reduces the search
space by using bounds (such as the minimum cost of a tour) to prune
suboptimal solutions, leading to a faster solution compared to brute
force.
• Example: Let's say there are 4 cities: A, B, C, D.
o Brute force would check all 4! = 24 possible routes.
o Branch-and-bound would compute a lower bound for each branch
(e.g., using minimum edge costs) and prune branches that cannot
result in a better solution than the best found so far.
v. Job Scheduling with Deadlines and Profits
a. Describe the dynamic programming approach to solve the job scheduling
problem with deadlines and profits:
• Dynamic Programming Approach: The job scheduling problem can be
solved by sorting jobs based on their profits in descending order and
then scheduling each job in the latest available time slot before its
deadline. The dynamic programming approach focuses on finding the
optimal subset of jobs that maximizes profit while respecting the
deadlines.
• Steps:
1. Sort the jobs in decreasing order of profit.
2. For each job, find the latest available time slot before its deadline
and schedule it if the slot is available.
3. Use dynamic programming to maintain the maximum profit
obtainable by scheduling jobs up to the current job.
b. How do you handle conflicts between jobs that cannot be scheduled due to
their deadlines?
• Conflict Handling: If two jobs conflict because their deadlines overlap,
the job with the lower profit can be discarded in favor of the higher-
profit job, assuming both jobs cannot be scheduled in the available time
slots. The dynamic programming approach will automatically select the
jobs that maximize profit while satisfying the constraints.
c. Analyze the time complexity of the dynamic programming approach:
 • Time Complexity: Sorting the jobs takes O(n log n), and for each job,
checking the availability of a time slot can take O(n) in the worst case.
Therefore, the time complexity of the dynamic programming approach is
O(n^2), where n is the number of jobs.
x. Traveling Salesman Problem (TSP)
a. Define the TSP and explain why it is an NP-hard problem:
• Definition: The Traveling Salesman Problem (TSP) asks for the shortest
possible route that visits each city once and returns to the starting city.
Given a set of cities and the distances between them, the goal is to find
the minimum distance that allows visiting all cities exactly once and
returning to the origin city.
• NP-hard explanation: TSP is classified as NP-hard because no known
algorithm can solve it in polynomial time for all cases. It is a
combinatorial optimization problem, and the solution space grows
factorially as the number of cities increases (since there are n! possible
routes). Verifying a given solution (checking if a given tour is valid and
has the shortest length) can be done in polynomial time, but finding the
optimal solution takes exponential time, making it NP-hard.
b. Discuss the brute force approach for solving TSP and explain its time
complexity:
• Brute Force Approach: The brute force approach involves generating all
possible permutations of the cities, calculating the distance for each
permutation, and then selecting the one with the shortest total distance.
This guarantees the correct solution but is inefficient for large numbers
of cities.
• Time Complexity: Since there are n cities, the number of possible
permutations is n! (factorial). For each permutation, the distance must
be calculated, which takes O(n) time. Therefore, the total time
complexity of the brute force approach is O(n * n!), which is very slow
for large n.
c. Explain the branch-and-bound technique for solving TSP. How does it
improve over the brute force method? Illustrate with a simple example:
• Branch-and-Bound Technique: Branch-and-bound is a more efficient
method to solve TSP by systematically exploring subsets of solutions. It
 works by "bounding" (i.e., calculating lower bounds) the potential
solutions and pruning branches of the search tree that cannot lead to an
optimal solution. This reduces the number of permutations that need to
be considered, as branches that exceed the current best solution are
discarded early.
• Improvement over Brute Force: Branch-and-bound reduces the search
space by using bounds (such as the minimum cost of a tour) to prune
suboptimal solutions, leading to a faster solution compared to brute
force.
• Example: Let's say there are 4 cities: A, B, C, D.
o Brute force would check all 4! = 24 possible routes.
o Branch-and-bound would compute a lower bound for each branch
(e.g., using minimum edge costs) and prune branches that cannot
result in a better solution than the best found so far.

a. Define a multi-stage graph and explain how the stages are organized.
A multi-stage graph is a directed graph where the vertices are divided into
several stages, and edges only connect vertices between consecutive stages.
The vertices are organized into stages such that stage 1 is the starting stage,
stage 2 is the intermediate stage, and the final stage is the destination. The
edges in the graph represent transitions from one stage to the next.
b. Describe the dynamic programming approach to solving the shortest path
problem in a multi-stage graph. Provide the recurrence relation used in this
approach.
The dynamic programming approach to solving the shortest path problem in a
multi-stage graph works by solving subproblems in a bottom-up manner,
starting from the destination and working towards the source. The key idea is
to compute the shortest path to the destination for each vertex, considering
the paths through the next stage.
Recurrence Relation: Let d(v)d(v)d(v) represent the shortest path distance
from vertex vvv to the destination vertex. The recurrence relation is:
d(v)=min⁡(v,u)∈E(w(v,u)+d(u))d(v) = \min_{(v, u) \in E} (w(v, u) +
d(u))d(v)=min(v,u)∈E(w(v,u)+d(u))
Where:
• V is the current vertex,
• u is a vertex in the next stage,
• w(v,u) is the weight of the edge from vvv to uuu,
• d(u) is the shortest path distance from vertex uuu to the destination.
Base Case: For the destination vertex, d(destination)=0d(destination) =
0d(destination)=0, as there is no cost to reach the destination.
• d(A)=min⁡(w(A,C)+d(C))=min⁡(3+1)=4d(A) = \min(w(A, C) + d(C)) =
\min(3 + 1) = 4d(A)=min(w(A,C)+d(C))=min(3+1)=4
• d(B)=min⁡(w(B,C)+d(C))=min⁡(2+1)=3d(B) = \min(w(B, C) + d(C)) =
\min(2 + 1) = 3d(B)=min(w(B,C)+d(C))=min(2+1)=3
Step 4: Compute the distance for the source vertex.
• d(S)=min⁡(w(S,A)+d(A),w(S,B)+d(B))=min⁡(2+4,1+3)=4d(S) = \min(w(S,
A) + d(A), w(S, B) + d(B)) = \min(2 + 4, 1 + 3) =
4d(S)=min(w(S,A)+d(A),w(S,B)+d(B))=min(2+4,1+3)=4
Step 5: Shortest path from source to destination: The shortest path from SSS
to TTT has a total cost of 4.
Thus, the shortest path is:
• S→B→C→TS \to B \to C \to TS→B→C→T with a total cost of 4.
This demonstrates how the dynamic programming method works step by step.