1. Explain the Run-Time analysis and the Space complexity of algorithms.

Ans- Run-time Analysis (Time Complexity):

 Definition:
Time complexity quantifies how the execution time of an algorithm changes as the input data size grows. It's often expressed using Big O
notation, which provides an upper bound on the growth rate.
 Purpose:
Helps predict how an algorithm will perform with larger datasets and allows for comparison of different algorithms.
 Key Concepts:
 Worst-case, average-case, and best-case scenarios: Analyze the performance in different situations.
 Asymptotic analysis: Focuses on the behavior of the algorithm as the input size tends towards infinity.
 Common time complexity classes:
 O(1) (Constant): The execution time doesn't change with input size (e.g., accessing an element in an array
by its index).
 O(log n) (Logarithmic): The execution time grows logarithmically with input size (e.g., binary search).
 O(n) (Linear): The execution time grows linearly with input size (e.g., searching for an element in an
unsorted array).
 O(n log n) (Log-linear): The execution time grows linearly with a logarithmic factor (e.g., merge sort).
 O(n^2) (Quadratic): The execution time grows quadratically with input size (e.g., nested loops).
 O(2^n) (Exponential): The execution time grows exponentially with input size (e.g., brute-force
solutions).
 Example:
A loop that iterates through an array of size n has a time complexity of O(n) because the number of operations increases linearly with the
input size.
Space Complexity:
 Definition:
Space complexity measures the amount of memory (space) an algorithm requires as a function of the input size.
 Purpose:
Helps understand the memory footprint of an algorithm and is crucial for memory-constrained environments.
 Key Concepts:
 Auxiliary space: The additional memory used by the algorithm itself, excluding the input data.
 Space complexity classes: Similar to time complexity classes (O(1), O(log n), O(n), etc.).
 Example:
An algorithm that creates a new array of size n has a space complexity of O(n) because the memory used increases linearly with the input
size.

2. Draw the recursion tree to find upper bond on relation

Tn =2T(n/2) + cn if n>1 and 1; if n=1.
Ans -

3. Explain Binary Search algorithm with an example?

Ans - Binary Search is an efficient algorithm to find an element in a sorted array (or list). It works by repeatedly dividing the search interval
in half. Here’s how it operates:
1. Start with the entire array as the search space.
2. Find the middle element of the current search space.
3. Compare the target element with the middle element:
o If it matches, the search is successful.
o If the target is smaller than the middle element, repeat the search in the left half of the array.
o If the target is larger than the middle element, repeat the search in the right half of the array.
4. The process continues until the target is found or the search space becomes empty.
Example:
Imagine a sorted array: [2, 4, 7, 10, 15, 20, 25]. Let's say you want to find 10.
1. Start with the entire array.
o Left index = 0, Right index = 6.
o Middle index = (0 + 6) // 2 = 3, so the middle element is 10.
2. Compare 10 (target) with 10 (middle element).
o They match! The search is successful, and the target is at index 3.
Another example (target not found):
Now, let’s search for 5 in the same array:
1. Left index = 0, Right index = 6.
o Middle index = 3, so the middle element is 10.
o Since 5 is smaller than 10, move to the left half. Now, Left = 0, Right = 2.
2. Middle index = (0 + 2) // 2 = 1, so the middle element is 4.
o Since 5 is greater than 4, move to the right half. Now, Left = 2, Right = 2.
3. Middle index = (2 + 2) // 2 = 2, so the middle element is 7.
o Since 5 is smaller than 7, move to the left half. Now, Left = 2, Right = 1.
At this point, Left > Right, meaning the search space is empty. The target 5 is not in the array.
Time Complexity:
 Best case: O(1) (if the middle element is the target).
 Worst/average case: O(log n) (as the search space is halved at each step).
 4. Explain Strassen‘s Matrix Multiplication technique? Compute and show how the Strassen's algorithm time complexity is
effective as compared to native matrix multiplication technique?
Ans- Strassen's algorithm is an efficient divide-and-conquer method for matrix multiplication, offering a faster time complexity than
the traditional O(n^3) method for large matrices. It achieves this by reducing the number of recursive multiplications from eight to
seven while performing additional additions and subtractions. The resulting time complexity is O(n^2.81), significantly faster for large
matrix sizes.
Strassen's Algorithm Explained:
1. 1. Divide and Conquer:
The algorithm recursively divides the input matrices into smaller submatrices.
2. 2. Recursive Multiplication:
It computes seven products of these submatrices using a specific set of equations.
3. 3. Combine:
It then combines the seven products using additions and subtractions to form the final result.
4. 4. Base Case:
When the submatrices are small enough (e.g., 2x2), standard matrix multiplication is used.
Example (2x2 matrices):
Let A and B be 2x2 matrices:
A = [[a11, a12], [a21, a22]]
B = [[b11, b12], [b21, b22]]
Strassen's algorithm defines seven products:
1. P1 = a11 * (b12 - b22)
2. P2 = (a11 + a12) * b22
3. P3 = (a21 + a22) * b11
4. P4 = a22 * (b21 - b11)
5. P5 = (a11 + a22) * (b11 + b22)
6. P6 = (a12 - a22) * (b21 + b22)
7. P7 = (a11 - a21) * (b11 + b12)
Then the final result C is calculated as:
C = [[P5 + P4 - P2 + P6, P1 + P2],
[P3 + P4, P1 + P5 - P3 - P7]]

5.Find the sum of subset for { 5, 10, 12, 13, 15, 18} where M=30 and draw state space tree.
Ans - What you're solving for

Finding subsets of a given set that sum to a target value and representing the search process as a state-space tree.

What's given in the problem

 Set:
 Target sum:
Helpful information
 The subset sum problem can be solved using backtracking.
 A state-space tree visually represents the search space for a solution.
 Each node in the tree represents a decision point (include or exclude an element).
 Branches represent the choices made at each decision point.
How to solve

Use backtracking to explore all possible subsets and check if their sum equals .
1. Step 1 Start with an empty subset and a current sum of .
o Current subset: \{\}
o Current sum:
2. Step 2 Consider the first element ).
o Case 1: Include .
 Current subset:
 Current sum:
o Case 2: Exclude .
 Current subset: \{\}
 Current sum:
3. Step 3 Consider the next element ).
o Case 1 (from Step 2, Case 1): Include .
 Current subset:
 Current sum:
o Case 2 (from Step 2, Case 1): Exclude .
 Current subset:
 Current sum:
o Case 3 (from Step 2, Case 2): Include .
 Current subset:
 Current sum:
o Case 4 (from Step 2, Case 2): Exclude .
 Current subset: \{\}
 Current sum:
4. Step 4 Continue this process for all elements.
o Explore all branches until either the sum equals or it's clear that the sum cannot reach .
5. Step 5 Identify the subsets that sum to .
o
o
o
6. Step 6 Draw the state-space tree.
o The root node is the empty set.
o Each level represents a decision for an element.
o Leaf nodes represent either a solution or a dead end.
Solution

The subsets that sum to are , , and .

.
6.State and explain the Masters theorem with example.
Ans - Masters theorem is one of the many methods that are applied to calculate time complexities of algorithms. In analysis, time
complexities are calculated to find out the best optimal logic of an algorithm. Masters theorem is applied on recurrence relations.
But before we get deep into the masters theorem, let us first revise what recurrence relations are −
Recurrence relations are equations that define the sequence of elements in which a term is a function of its preceding term. In algorithm
analysis, the recurrence relations are usually formed when loops are present in an algorithm.

7. Explain the Merge Sort with Example.

Ans - Merge Sort is a popular and efficient sorting algorithm based on the Divide-and-Conquer technique. It works by dividing
the array into smaller sub-arrays, sorting them, and then merging these sorted sub-arrays back into a single sorted array.
Here's how Merge Sort works step-by-step:
Steps of Merge Sort:
1. Divide: The array is divided into two halves until each sub-array contains just one element.
2. Conquer: Each sub-array is sorted recursively using Merge Sort.
3. Combine: The sorted sub-arrays are merged together to form a single sorted array.
Example: Sorting [38, 27, 43, 3, 9, 82, 10]
Step 1: Divide
The array is split recursively into smaller halves:
 Split into two halves: [38, 27, 43, 3] and [9, 82, 10]
 Split further:
o [38, 27] and [43, 3]
o [9] and [82, 10]
 Continue until individual elements:
o [38], [27], [43], [3], [9], [82], [10]
Step 2: Sort Each Half
Each pair of elements is sorted:
 Merge [38] and [27] → [27, 38]
 Merge [43] and [3] → [3, 43]
 Merge [82] and [10] → [10, 82]
Step 3: Merge Sorted Sub-arrays
Merge the sorted sub-arrays step by step:
 Merge [27, 38] and [3, 43] → [3, 27, 38, 43]
 Merge [9] and [10, 82] → [9, 10, 82]
 Merge [3, 27, 38, 43] and [9, 10, 82] → [3, 9, 10, 27, 38, 43, 82]
Final Sorted Array: The array becomes [3, 9, 10, 27, 38, 43, 82]