PART A

1)Elaborate the various Algorithm design approaches.

There are several algorithm design approaches, and selecting one depends on the problem
and the specific requirements of a problem. The correct choice can significantly impact the
time and resources required to solve a given problem.
Divide and Conquer:
● Decomposes a problem into smaller, independent subproblems, solves them recursively,
and combines the solutions to obtain the solution for the original problem.
● Example: Merge sort, which divides the list into halves, sorts them recursively, and then
merges the sorted halves.
● Advantages: Efficient for problems solvable by breaking them down into smaller,
independent subproblems. Often leads to logarithmic or linear time complexity.
● Disadvantages: Overhead associated with recursion and subproblem management.
Greedy Algorithm:
● Makes locally optimal choices at each step with the hope of finding a globally optimal
solution.
● Example: Finding the shortest path in a maze by choosing the nearest unvisited neighbor
at each step.
● Advantages: Often simple to implement and efficient for specific problems.
● Disadvantages: May not always lead to globally optimal solutions for all problems.
Dynamic Programming:
● Solves problems by storing solutions to subproblems and reusing them to solve larger
problems efficiently.
● Example: Finding the longest common subsequence of two strings by breaking down the
problem into smaller subproblems and storing solutions in a table.
● Advantages: Efficient for problems with overlapping subproblems, reducing redundant
calculations.
● Disadvantages: Requires additional space to store subproblem solutions and might be
complex to design for certain problems.
5. Backtracking:
● Systematically explores all possible solutions by recursively trying different options and
backtracking from invalid paths.
● Example: Solving the N-Queens problem by placing queens on a chessboard such that no
two queens threaten each other.
● Advantages: Useful for finding all possible solutions or optimal solutions in some cases.
● Disadvantages: Can be computationally expensive for problems with a large number of
possible solutions.
Branch and Bound:
● Systematically explores promising solutions while discarding those that can be guaranteed
not to lead to an optimal solution.
● Example: Finding the shortest path in a graph by pruning branches that exceed a certain
lower bound on the cost of reaching the destination.
● Advantages: Can be more efficient than backtracking by eliminating non-optimal solutions
early.
● Disadvantages: Designing effective bounding functions can be challenging for some
problems.

2) Discuss the ways of selecting the design paradigms for the problems.
Selecting Design Paradigms in Algorithm Design and Analysis
Choosing an appropriate design paradigm is essential for solving computational problems
efficiently. Different paradigms provide structured ways to develop algorithms based on
problem characteristics and constraints.
1. Understanding Problem Characteristics
Before selecting a paradigm, analyze the problem based on:
• Problem Type: Sorting, searching, optimization, graph traversal, etc.
• Constraints: Input size, time, space, and efficiency requirements.
• Data Structure: Arrays, graphs, trees, or unstructured data.
• Real-time Requirements: Whether near-instantaneous processing is needed.
2. Common Design Paradigms and Their Selection Criteria
(a) Divide and Conquer
• Concept: Split problem into subproblems, solve recursively, and merge results.
• Best for: Sorting, searching, and problems with independent subproblems.
• Examples: Merge Sort, QuickSort, Binary Search.
• When to Choose: When the problem can be broken into smaller instances and
combined efficiently.
(b) Dynamic Programming (DP)
• Concept: Break the problem into overlapping subproblems and store results.
• Best for: Optimization problems with repeated subproblems.
• Examples: Fibonacci series, Knapsack problem, Longest Common Subsequence (LCS).
• When to Choose: When a recursive approach leads to redundant computations, and
memoization or tabulation can be used.
(c) Greedy Algorithms
• Concept: Make the best local choice at each step for a globally optimal solution.
• Best for: Optimization problems with a greedy choice property.
• Examples: Huffman Coding, Prim’s Algorithm, Kruskal’s Algorithm, Dijkstra’s
Algorithm.
• When to Choose: When local choices lead to a globally optimal result.
(d) Backtracking
• Concept: Try all possibilities and backtrack upon reaching an invalid state.
• Best for: Constraint satisfaction problems.
• Examples: N-Queens Problem, Sudoku Solver, Graph Coloring.
• When to Choose: When exhaustive search is required but can be pruned for
efficiency.
(e) Branch and Bound
• Concept: Similar to backtracking but with pruning based on bounding functions.
• Best for: Optimization problems.
• Examples: 0/1 Knapsack Problem, Traveling Salesman Problem (TSP).
• When to Choose: When an optimization problem requires intelligent pruning to
improve efficiency.
(f) Randomized Algorithms
• Concept: Use random choices to simplify problem-solving or improve efficiency.
• Best for: Large problems where deterministic solutions are inefficient.
• Examples: Randomized QuickSort, Monte Carlo Methods, Las Vegas Algorithm.
• When to Choose: When a randomized approach can improve efficiency or provide
probabilistic guarantees.
(g) Graph-Based Paradigms
 • Concept: Represent data as graphs and apply traversal/search techniques.
• Best for: Network problems, shortest path, and connectivity issues.
• Examples: Depth-First Search (DFS), Breadth-First Search (BFS), Dijkstra’s Algorithm.
• When to Choose: When problems involve paths, connectivity, or traversal.
3. Comparative Selection of Paradigms

Paradigm Best for Key Property Example Algorithms

Divide & Independent

Recursive breakdown Merge Sort, QuickSort
Conquer subproblems

Dynamic Overlapping
Optimization Fibonacci, LCS
Programming subproblems

Huffman Coding,
Greedy Optimization Locally optimal choices
Prim’s

Backtracking Constraint satisfaction Tries all solutions N-Queens, Sudoku

Branch & Bound Optimization Prunes bad solutions TSP, Knapsack

Approximation, Random choices improve QuickSort (random

Randomized
random efficiency performance pivot), Monte Carlo

Pathfinding,
Graph-Based Graph representation DFS, BFS, Dijkstra
connectivity

4. Factors Influencing Paradigm Selection

1. Problem Structure
o Divide & Conquer and DP if the problem can be split into subproblems.
o Greedy or DP for optimization tasks.
2. Efficiency vs. Simplicity
o Greedy is often simpler than DP but may not always be optimal.
o Backtracking and Branch & Bound work well for exhaustive searches but may
be slow.
3. Exact vs. Approximate Solutions
o Backtracking, Branch & Bound, and DP for exact solutions.
o Randomized algorithms for approximations.
 4. Memory Constraints
o Greedy or Divide & Conquer require less memory than DP.

3)Solve the following recurrence equation using substitution method T(n) =

T(n-1) + 3, T1 = 4
4)Solve the following recurrence equation using Recursive Tree method T(n) =
2T(n/2) + n2
5)Solve the recurrence relation using substitution method and verify same
using Masters theorem. T(n) = 2T(n/2) + n, n >2 T (1) = 1
6)What are line count and operation count in an algorithm? Explain how they
are used to evaluate time complexity with an example algorithm.
Line Count and Operation Count in an Algorithm
1. Line Count:
o It refers to the number of times each line of code in an algorithm is executed
during its execution.
o Helps us understand the control flow and the relative frequency of operations
for different parts of the code.
2. Operation Count:
o It counts the total number of basic operations (such as assignments,
comparisons, arithmetic operations, etc.) performed by the algorithm.
o The count varies based on input size and is used to analyze the time
complexity.
Using Line Count and Operation Count for Time Complexity
Time complexity measures how the running time of an algorithm increases with input size n.
To evaluate time complexity:
• Determine the frequency of execution of each line of code.
• Add the contributions of all lines to calculate the total operation count.
 • Express the result as a function of n and simplify it using Big-O notation.
Example Algorithm: Linear Search
def linear_search(arr, x):
for i in range(len(arr)): # Line 1
if arr[i] == x: # Line 2
return i # Line 3
return -1 # Line 4
Steps to Evaluate:
1. Line-by-Line Analysis:
o Line 1: A loop runs n times for an array of size n.
o Line 2: Inside the loop, the comparison arr[i] == x is executed n times in the
worst case.
o Line 3: In the worst case, this line may not execute at all, as the element is not
found.
o Line 4: Executes once when the loop ends without finding the element.
2. Operation Count:
o Line 1: Loop control executes n+1 times (loop starts n times and ends once).
o Line 2: The comparison operation runs n times.
o Line 3: Executes only once when the element is found (not considered in the
worst case).
o Line 4: Executes once in the worst case.
Total operations in the worst case: (n+1)+n+1=2n+2.
3. Time Complexity:
o The total operation count is 2n+2.
o In Big-O notation, we focus on the dominant term: O(n).
Key Insights:
• Line Count helps identify how often each line is executed.
• Operation Count aggregates the total work done, giving a more detailed
performance measure.
• Time complexity, derived from operation count, helps predict scalability and
performance.
 7)Discuss the difference between the Divide-and-Conquer and Dynamic
Programming paradigms. Provide one example problem for each, with an
explanation of how the paradigm is applied.
Differences Between Divide-and-Conquer and Dynamic Programming
Aspect Divide-and-Conquer Dynamic Programming

Solves problems by breaking them Solves problems by breaking them

into smaller subproblems, solving into overlapping subproblems, solving
Approach
each independently, and each once, and storing the results
combining the results. (memorization or tabulation).

Subproblems are solved Subproblems overlap, and their

Overlapping
independently and may repeat solutions are reused to avoid
Subproblems
across different branches. redundant calculations.

Requires optimal solutions to Requires optimal subproblem

Optimal
subproblems to combine into the solutions that can be reused directly
Substructure
global solution. for the global solution.

Less efficient for problems with

More efficient due to reuse of
Efficiency overlapping subproblems due to
previously computed solutions.
redundant computations.

Merge Sort, Quick Sort, Binary Fibonacci sequence, Matrix Chain

Example Algorithms
Search. Multiplication, Knapsack Problem.

Problem:
Find the sum of the first n natural numbers, where n is provided by the user.
Algorithm:
1. Start.
2. Input n (the number of terms).
3. Initialize a variable sum to 0.
4. Use a for loop to iterate from 1 to nnn:
o Add the current number to sum.
5. Print the value of sum.
6. End.
Example C Code:
#include <stdio.h>
int main() {
int n, sum = 0;
// Input the value of n
printf("Enter a positive integer: ");
scanf("%d", &n);
// Calculate the sum of the first n natural numbers
for (int i = 1; i <= n; i++) {
sum += i; // Add i to sum
}
// Output the result
printf("The sum of the first %d natural numbers is: %d\n", n, sum);

return 0;
}
How It Works:
1. The user enters a number n (e.g., 5).
2. The program uses a for loop to add numbers from 1 to nnn into the variable sum.
o For n=5n = 5n=5: sum = 1 + 2 + 3 + 4 + 5 = 15.
3. The result is printed using printf().
Output Example:
Enter a positive integer: 5
The sum of the first 5 natural numbers is: 15

8)Explain the differences between O, Θ, Ω notations, with the help of graphs

and examples for each.
The best, average, and worst-case time complexities of an algorithm represent different
scenarios for how long an algorithm might take to execute based on the input it receives.
1. Best Case Time Complexity (big Ω)
● It is represented by Big Omega (Ω).
● It represents the minimum amount of time an algorithm takes to execute for a specific
input size.
● This occurs when the algorithm encounters the most favorable input conditions, allowing
it to complete with the fewest possible steps.
● Example: In linear search, if the target element is present at the beginning of the list, the
search concludes in one comparison, resulting in a best-case complexity of O(1).
● Thus, it guarantees the lower bound on the algorithm's execution time for a specific input
size.
2. Average Case Time Complexity (Θ)
● It is represented by Theta (Θ).
● It represents the average amount of time an algorithm takes to execute for a specific input
size.
● This complexity is calculated by averaging the time taken for all possible inputs and their
corresponding frequencies.
● In linear search, assuming all elements have an equal chance of being the target, the
average-case complexity is O(n/2), as the target element might be found in the middle on
average.
● Thus, it captures the typical behavior of the algorithm for a specific input size, considering
all possible inputs with equal probability.
3. Worst Case Time Complexity (big O)
● It is represented by Big O (O).
● It represents the maximum amount of time an algorithm takes to execute for a specific
input size.
● This occurs when the algorithm encounters the most unfavourable input conditions,
leading to the most steps required for completion.
● In linear search, if the target element is not present in the list, the search needs to
compare with all elements, resulting in a worst-case complexity of O(n).
● Thus, it signifies the upper bound on the algorithm's execution time for a specific input
size. The algorithm will never take more time than the worst-case complexity suggests,
regardless of the specific input
PART B
1.Discuss the time complexity analysis of Insertion sort algorithm.
2.Elaborate the various asymptotic notations used in algorithm design.
3.Discuss the time complexity and analysis of Tower of Hanoi algorithm.
The Tower of Hanoi is a classic recursive problem that involves moving a stack of disks from
one peg to another while following specific rules. The time complexity of the algorithm can
be analyzed as follows:
Problem Statement
Given n disks and three rods (source, auxiliary, and destination), the goal is to move all disks
from the source rod to the destination rod, following these rules:
1. Only one disk can be moved at a time.
2. A larger disk cannot be placed on top of a smaller disk.
3. The third rod can be used as an auxiliary storage.
Recursive Approach
The recursive solution follows these steps:
1. Move n−1 disks from the source peg to the auxiliary peg.
2. Move the largest (nth) disk from the source peg to the destination peg.
3. Move n−1 disks from the auxiliary peg to the destination peg.
This leads to the recurrence relation:
T(n)=2T(n−1)+1
where:
• T(n−1) accounts for moving n−1 disks twice.
• The extra +1 accounts for moving the largest disk.
Space Complexity
Since the recursive approach requires function calls on the call stack up to a depth of O(n),
the space complexity is: O(n)
Conclusion
• The Tower of Hanoi has an exponential time complexity O(2^n), making it infeasible
for large n.
• The recursive approach consumes O(n) space due to the recursive stack.
• The problem is best solved recursively, but iterative solutions using stacks also exist.

4. Examine the pseudocode and calculate the time complexity for the
algorithm.
Madd (A, B, C, N)
{
for i = 1 to n
for j = 1 to n
c[i,j] = a[i,j] + b[i,j]
}
5. Analyze the time complexity of the following algorithm and explain each step
of the analysis:
def example_function(arr):
n = len(arr)
for i in range(n):
for j in range(i, n):
print(arr[i], arr[j])
6.Explain the substitution method for solving recurrence relations. Solve the
recurrence T(n)=3T(n/3)+n using this method.
Substitution Method for Solving Recurrence Relations
The substitution method is a technique used to determine the asymptotic complexity of
recurrence relations by guessing a bound and proving it using mathematical induction.
Forward and Backward Substitution Methods
The forward substitution and backward substitution methods are techniques used in
different computational contexts, including solving recurrence relations and linear
equations.
1. Forward Substitution
Definition
Forward substitution is a method used to solve problems progressively, starting from the
smallest values and building up to the required result. It is commonly used in:
• Recurrence Relations: Expanding terms step by step until a pattern emerges.
• Solving Triangular Systems: In linear algebra, it is used to solve lower triangular
systems.
Steps in Forward Substitution for Recurrences
1. Expand the recurrence relation iteratively.
2. Identify a pattern in the expansion.
3. Generalize the pattern to derive a closed-form solution.
2. Backward Substitution
Definition
Backward substitution solves problems in reverse order, starting from the highest indexed
value and working backward. It is primarily used in:
• Recurrence Relations: Simplifying from large values to smaller ones.
• Upper Triangular Systems: In linear algebra, solving upper triangular matrices.
Steps in Backward Substitution for Recurrences
1. Express T(n) in terms of T(n−1), T(n−2), etc.
2. Substitute known values for base cases.
3. Solve recursively until the pattern reveals a closed-form solution.