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

), O(log(n)), O(2^n), O(n * • Big Theta (Θ): Represents both the upper and lower bounds, meaning h. Explain the best, worst, and average case time complexity for Merge Sort.
log(n)) the algorithm's running time grows at the same rate both in the best and
Answer:
worst cases. Example: Merge Sort is Θ(n * log(n)).
Answer: The complexities in increasing order are:
• Best-case: O(n log n) (occurs when the array is already sorted or nearly
e. Define Big Theta notation and explain its significance in representing both
1. O(log(n)) sorted).
the upper and lower bounds of an algorithm. Provide an example.
2. O(n) • Worst-case: O(n log n) (Merge Sort always takes the same time, even for
Answer: Big Theta (Θ) notation represents both the upper and lower bounds
the worst input).
3. O(n * log(n)) 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 • Average-case: O(n log n) (due to its divide-and-conquer nature, it always
4. O(n²)
cases. Example: Merge Sort has a time complexity of Θ(n * log(n)), meaning it splits the array in half).
5. O(2^n) will always take n * log(n) time regardless of the input. i. In the case of Quick Sort, explain how the worst-case time complexity can
6. O(n!) f. How does Big Theta differ from Big O and Big Omega notations in terms of be avoided with a good choice of pivot. What are the best, worst, and
b. An algorithm performs n iterations, where each iteration involves a algorithm analysis? What is the impact of input size on them? average case complexities?
constant time operation. What is the time complexity of this algorithm? Answer: Answer:
Justify your answer.
• Big O gives the worst-case complexity. • Best-case: O(n log n) (when the pivot divides the array in half).
Answer: The time complexity is O(n) because the algorithm performs n
• Big Omega gives the best-case complexity. • Worst-case: O(n²) (occurs when the pivot is always the smallest or
iterations, and each iteration takes constant time. Multiplying constant time by
largest element, causing unbalanced partitions).
n gives a linear time 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 • Average-case: O(n log n) (with a good pivot, Quick Sort divides the array
c. Define Big Omega notation and explain how it is used to describe the lower
determining the growth rate of the algorithm. Larger input sizes magnify evenly on average). Choosing a good pivot (e.g., using the median of
bound of an algorithm's running time.
the differences between the notations (e.g., O(n²) will eventually be three elements or randomizing) can help avoid the worst-case
Answer: Big Omega (Ω) notation represents the lower bound of an algorithm's slower than O(n log n)). complexity.
running time. It gives the best-case scenario or the minimum time the
g. Define the terms "best-case", "worst-case" and "average-case" time n. Analyze the time complexity of Heap Sort in the best, worst, and average
algorithm will take for the largest input size. Formally, if an algorithm takes at
complexities. How do these relate to Big O, Big Omega, and Big Theta? cases.
least f(n) time for sufficiently large n, then the time complexity is said to be
Ω(f(n)). Answer: Answer:
d. What is the relationship between Big O, Big Omega, and Big Theta • Best-case time complexity: The minimum time the algorithm takes for • Best-case: O(n log n) (the time complexity is the same regardless of the
notations? Provide examples where each of these notations are used. an input. This corresponds to Big Omega (Ω). input since the heap structure always requires log n time for insertion
and deletion).
Answer: • Worst-case time complexity: The maximum time the algorithm takes for
an input. This corresponds to Big O (O). • Worst-case: O(n log n) (similar to best-case, as the heap's operations do
• Big O (O): Represents the upper bound (worst-case scenario). Example:
not depend on input order).
For an algorithm that takes at most O(n²) time. • Average-case time complexity: The expected time for an algorithm on a
randomly chosen input. This may not have a simple notation and is • Average-case: O(n log n) (again, the heap operations remain consistent
• Big Omega (Ω): Represents the lower bound (best-case scenario).
typically analyzed using probabilistic methods. regardless of the input).
Example: An algorithm that always takes at least Ω(n) time.
• Big O focuses on worst-case, Big Omega on best-case, and Big Theta o. What does the class P represent in computational complexity, and why are
represents the overall time complexity for both. problems in this class considered efficiently solvable?

Answer: Class P represents problems that can be solved in polynomial time. Answer: where each subproblem computes the minimum number of
These problems are considered efficiently solvable because their time The time complexity of a typical Brute Force algorithm is usually O(n^k), where multiplications needed to multiply a subset of matrices.
complexity grows at a manageable rate (e.g., O(n), O(n²), O(n log n)) as the n is the input size and k is a constant that depends on the problem. Brute Force
Example: For matrices A1, A2, A3, ..., An, the goal is to find the optimal way to
input size increases. Problems in P can be solved in a reasonable amount of algorithms try all possible solutions and check each one. For large input sizes,
parenthesize the product to minimize the number of scalar multiplications.
time, even for large inputs. this approach becomes infeasible because the time complexity grows rapidly.
Limitations: When dealing with large inputs, Brute Force algorithms become Time complexity: O(n^3), where n is the number of matrices.
p. Define NP (Non-deterministic Polynomial Time) problems. Provide an
very slow and inefficient due to the exponential or polynomial growth in the
example of a well-known problem that belongs to NP.
number of possibilities that need to be checked. This makes them impractical
Answer: for large-scale problems. k. Explain backtracking for complexity of each of them. N-Queen problem.
NP problems are decision problems for which a proposed solution can be Use suitable example and analyze time solved this question in details.
verified in polynomial time by a deterministic Turing machine. These problems Answer:
are not necessarily solvable in polynomial time, but if a solution is provided, it j. Explain dynamic programming for Fibonacci series, multi-stage graph Backtracking is a general algorithmic technique for solving optimization
can be checked quickly (in polynomial time). problem, chain matrix multiplication. Use suitable example and analyze time problems, where we incrementally build candidates for the solution and
Example: The Travelling Salesman Problem (TSP) is a well-known NP problem. complexity of each of them. discard those that fail to satisfy the problem’s constraints. It involves exploring
Given a set of cities and the distances between them, the task is to determine all possible solutions and backtracking when we encounter a dead-end.
Answer:
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 1. Fibonacci series (Dynamic Programming): N-Queen Problem:
route's length is relatively easy. In Dynamic Programming, we store the results of subproblems to avoid In the N-Queen problem, we are given an N x N chessboard, and we need to
redundant calculations. The recursive formula for Fibonacci is: place N queens on the board such that no two queens threaten each other (no
F(n) = F(n-1) + F(n-2) two queens can share the same row, column, or diagonal).
q. Define NP-Hard problems and explain how they differ from NP-Complete Instead of recomputing the values for each recursive call, we store them Approach:
problems. in a table.
1. Place a queen in the first column of the first row.
Answer: Time complexity: O(n) because we only calculate each Fibonacci number once.
NP-Hard problems are at least as hard as the hardest problems in NP. These 2. Move to the next row and place the queen in a valid column.
2. Multi-stage Graph Problem (Shortest Path):
problems may not necessarily belong to NP, meaning their solutions may not 3. Continue placing queens row by row.
In the multi-stage graph problem, the goal is to find the shortest path
be verifiable in polynomial time. However, if any NP-Hard problem can be
from the source to the destination. We solve this by breaking down the 4. If at any point we cannot place a queen, we backtrack by removing the
solved in polynomial time, then all NP problems can be solved in polynomial
problem into stages, solving each subproblem optimally and using the last placed queen and try a different column.
time.
results to construct the solution.
NP-Complete problems, on the other hand, are both in NP and are NP-Hard. In 5. Repeat the process until all queens are placed.
other words, NP-Complete problems are the hardest problems in NP, and if one Example: Finding the shortest path in a directed graph. At each node, we store
Time complexity:
NP-Complete problem can be solved in polynomial time, all NP problems can the minimum distance to the destination, and then calculate it iteratively for
The worst-case time complexity of the backtracking algorithm for the N-Queen
be solved in polynomial time. each node.
problem is O(N!) because in the worst case, for each row, we try placing the
Time complexity: O(V + E), where V is the number of vertices and E is the queen in all N columns and backtrack when necessary.
number of edges.
c. Discuss the time complexity of a typical Brute Force algorithm and its Example:
limitations when dealing with large input sizes. 3. Chain Matrix Multiplication: For N = 4, the algorithm tries all possible placements of queens. It starts with
Given a chain of matrices, the objective is to find the most efficient way
to multiply them together. The problem is broken into subproblems
. Define the TSP and explain why it is an NP-hard problem: • Improvement over Brute Force: Branch-and-bound reduces the search • Time Complexity: Sorting the jobs takes O(n log n), and for each job,
space by using bounds (such as the minimum cost of a tour) to prune checking the availability of a time slot can take O(n) in the worst case.
• Definition: The Traveling Salesman Problem (TSP) asks for the shortest
suboptimal solutions, leading to a faster solution compared to brute Therefore, the time complexity of the dynamic programming approach is
possible route that visits each city once and returns to the starting city.
force. O(n^2), where n is the number of jobs.
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 • Example: Let's say there are 4 cities: A, B, C, D. x. Traveling Salesman Problem (TSP)
returning to the origin city.
o Brute force would check all 4! = 24 possible routes. a. Define the TSP and explain why it is an NP-hard problem:
• NP-hard explanation: TSP is classified as NP-hard because no known
o Branch-and-bound would compute a lower bound for each branch • Definition: The Traveling Salesman Problem (TSP) asks for the shortest
algorithm can solve it in polynomial time for all cases. It is a
(e.g., using minimum edge costs) and prune branches that cannot possible route that visits each city once and returns to the starting city.
combinatorial optimization problem, and the solution space grows
result in a better solution than the best found so far. Given a set of cities and the distances between them, the goal is to find
factorially as the number of cities increases (since there are n! possible
the minimum distance that allows visiting all cities exactly once and
routes). Verifying a given solution (checking if a given tour is valid and v. Job Scheduling with Deadlines and Profits
returning to the origin city.
has the shortest length) can be done in polynomial time, but finding the a. Describe the dynamic programming approach to solve the job scheduling
optimal solution takes exponential time, making it NP-hard. • NP-hard explanation: TSP is classified as NP-hard because no known
problem with deadlines and profits:
algorithm can solve it in polynomial time for all cases. It is a
b. Discuss the brute force approach for solving TSP and explain its time • Dynamic Programming Approach: The job scheduling problem can be combinatorial optimization problem, and the solution space grows
complexity: solved by sorting jobs based on their profits in descending order and factorially as the number of cities increases (since there are n! possible
• Brute Force Approach: The brute force approach involves generating all then scheduling each job in the latest available time slot before its routes). Verifying a given solution (checking if a given tour is valid and
possible permutations of the cities, calculating the distance for each deadline. The dynamic programming approach focuses on finding the has the shortest length) can be done in polynomial time, but finding the
permutation, and then selecting the one with the shortest total distance. optimal subset of jobs that maximizes profit while respecting the optimal solution takes exponential time, making it NP-hard.
This guarantees the correct solution but is inefficient for large numbers deadlines.
b. Discuss the brute force approach for solving TSP and explain its time
of cities. • Steps: complexity:
• Time Complexity: Since there are n cities, the number of possible 1. Sort the jobs in decreasing order of profit. • Brute Force Approach: The brute force approach involves generating all
permutations is n! (factorial). For each permutation, the distance must
2. For each job, find the latest available time slot before its deadline possible permutations of the cities, calculating the distance for each
be calculated, which takes O(n) time. Therefore, the total time
and schedule it if the slot is available. permutation, and then selecting the one with the shortest total distance.
complexity of the brute force approach is O(n * n!), which is very slow
This guarantees the correct solution but is inefficient for large numbers
for large n. 3. Use dynamic programming to maintain the maximum profit of cities.
c. Explain the branch-and-bound technique for solving TSP. How does it obtainable by scheduling jobs up to the current job.
• Time Complexity: Since there are n cities, the number of possible
improve over the brute force method? Illustrate with a simple example: b. How do you handle conflicts between jobs that cannot be scheduled due to permutations is n! (factorial). For each permutation, the distance must
• Branch-and-Bound Technique: Branch-and-bound is a more efficient their deadlines? be calculated, which takes O(n) time. Therefore, the total time
method to solve TSP by systematically exploring subsets of solutions. It • Conflict Handling: If two jobs conflict because their deadlines overlap, complexity of the brute force approach is O(n * n!), which is very slow
works by "bounding" (i.e., calculating lower bounds) the potential the job with the lower profit can be discarded in favor of the higher- for large n.
solutions and pruning branches of the search tree that cannot lead to an profit job, assuming both jobs cannot be scheduled in the available time c. Explain the branch-and-bound technique for solving TSP. How does it
optimal solution. This reduces the number of permutations that need to slots. The dynamic programming approach will automatically select the improve over the brute force method? Illustrate with a simple example:
be considered, as branches that exceed the current best solution are jobs that maximize profit while satisfying the constraints.
discarded early. • Branch-and-Bound Technique: Branch-and-bound is a more efficient
c. Analyze the time complexity of the dynamic programming approach: method to solve TSP by systematically exploring subsets of solutions. It

works by "bounding" (i.e., calculating lower bounds) the potential Where:

solutions and pruning branches of the search tree that cannot lead to an
• V is the current vertex,
optimal solution. This reduces the number of permutations that need to
be considered, as branches that exceed the current best solution are • u is a vertex in the next stage,
discarded early. • w(v,u) is the weight of the edge from vvv to uuu,
• Improvement over Brute Force: Branch-and-bound reduces the search • d(u) is the shortest path distance from vertex uuu to the destination.
space by using bounds (such as the minimum cost of a tour) to prune
suboptimal solutions, leading to a faster solution compared to brute Base Case: For the destination vertex, d(destination)=0d(destination) =
force. 0d(destination)=0, as there is no cost to reach the destination.

• Example: Let's say there are 4 cities: A, B, C, D. • 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
o Brute force would check all 4! = 24 possible routes.
• d(B)=min⁡(w(B,C)+d(C))=min⁡(2+1)=3d(B) = \min(w(B, C) + d(C)) =
o Branch-and-bound would compute a lower bound for each branch \min(2 + 1) = 3d(B)=min(w(B,C)+d(C))=min(2+1)=3
(e.g., using minimum edge costs) and prune branches that cannot
result in a better solution than the best found so far. 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) =
a. Define a multi-stage graph and explain how the stages are organized. 4d(S)=min(w(S,A)+d(A),w(S,B)+d(B))=min(2+4,1+3)=4
A multi-stage graph is a directed graph where the vertices are divided into Step 5: Shortest path from source to destination: The shortest path from SSS
several stages, and edges only connect vertices between consecutive stages. to TTT has a total cost of 4.
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 Thus, the shortest path is:
edges in the graph represent transitions from one stage to the next. • S→B→C→TS \to B \to C \to TS→B→C→T with a total cost of 4.
b. Describe the dynamic programming approach to solving the shortest path This demonstrates how the dynamic programming method works step by step.
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))