MANIPAL UNIVERSITY, JAIPUR

INTERNAL ASSIGNMENT

STUDENT NAME MOHD ARMAN

ROLL NO. 2314512248
SESSION NOVEMBER 2024
PROGRAM MASTER OF COMPUTER APPLICATIONS (MCA)
SEMESTER III
COURSE CODE & NAME DCA7104 – ANALYSIS AND DESIGN OF ALGORITHM
CREDITS 4
NUMBER OF ASSIGNMENTS & 02
MARKS 30

SET I

Q. No1
(a). What are the properties of an algorithm? Explain branch and bound algorithm
with an example

Ans (a). Homes of a set of rules

A set of rules is a step-through-step technique for solving a problem. It has the following key
residences:
1. Input: It takes 0 or extra input.
2. Output: It produces at least one output.
3. Definiteness: each step needs to be precisely described.
4. Finiteness: The algorithm must terminate after a finite range of steps.
5. Effectiveness: every step should be easy sufficient to be finished in a
finite time.
6. Generality: It must be applicable to various issues, now not just an
unmarried instance.

Department and Certain Algorithm

branch and bound (B&B) is a fashionable set of rules for solving optimization problems,
mainly in combinatorial optimization and decision-making. It systematically explores the
answer space by dividing it into smaller subproblems ("branching") and the usage of upper
and decrease bounds to eliminate subproblems that cannot yield a better solution
("bounding").

Example: solving the zero/1 Knapsack problem

Don't forget a knapsack with ability W = 10 and the subsequent objects:
item Weight value

Item Weight Value

1 3 40
2 5 50
3 6 60
The usage of branch and sure, we:
type objects based on value/weight ratio.
branch through inclusive of or apart from an object.
Compute bounds to check feasibility.
Prune subproblems that cannot lead to most efficient answers.

This approach reveals the most reliable answer quicker than brute-pressure methods by
heading off pointless computations.

(b). Standard Plan to investigate the performance of Recursive Algorithms

Studying the performance of recursive algorithms entails figuring out their time complexity
and space complexity. The general plan consists of the subsequent steps:
1. Become aware of the Recurrence Relation
specific the time complexity
T(n) in terms of smaller subproblems.
Instance: For the recursive Fibonacci set of rules,
T(n)=T(n−1) +T(n−2) +O (1)

2. Determine the bottom Case

perceive the preventing condition wherein recursion terminates.
Example: For Fibonacci,
T(zero)=O (1), T (1) =O(1)

3. Solve the Recurrence Relation

Use methods like:
Substitution method: wager and verify a solution.
Recursion Tree approach: increase the recursion tree and increase the fees.
grasp Theorem: observe while recurrence is in the shape
T(n)=aT(n/b) +O (n
where a,b,dare constants.

4. Analyze area Complexity

Consider additional memory required because of recursion intensity.
Example: Recursive Fibonacci calls for
O(n) area due to feature call stack.

5. Optimize if wished
Use memorization or backside-up DP to lessen redundant computations.
instance: Optimizing Fibonacci reduces time complexity from O(2ⁿ) to O(n).
Through following this systematic technique, the efficiency of recursive algorithms may be
efficaciously analyzed.

Q. No2 Differentiate between bottom-up and top-down heap construction with example.

Ans: Distinction between backside-Up and top-Down Heap creation

Heap creation is the technique of constructing a binary heap (Min-Heap or Max-Heap) from
an unsorted array. There are principal techniques: bottom-Up Heap production and pinnacle-
Down Heap production.
1. Backside-Up Heap production (Floyd’s method)
technique: This technique begins with the remaining non-leaf node and happifies each
subtree in a bottom-up manner.
Time Complexity: O(n)
Steps:
1. Perceive the ultimate non-leaf node:
Carry out Happify (or Sift Down) on every node transferring as much as the basis.
make certain the heap property is maintained at every step.
example of bottom-Up Heap production

2. Don't forget the unsorted array:

[4,10,3,5,1]
begin happifying from the last non-leaf node (index = n/2 - 1 = 1)

3. Practice happify to keep max-heap assets:

less replica Edit

Example of backside-Up Heap production (Floyd’s method)

Initial Array: [4, 10, 3, 5, 1]
Happifying node 1: [4, 10, 3, 5, 1] (Already follows heap belongings)
Happifying node 0: [10, 5, 3, 4, 1] (Swapped 10 and 4)
final Max-Heap: [10, 5, 3, 4, 1]

2. Pinnacle-Down Heap construction (Insertion method)

Technique: This technique starts off evolved with an empty heap and inserts factors
separately, ensuring the heap property is maintained.
Time Complexity: O (n log n)
Steps:
Begin with an empty heap.
Insert elements one by one at the following to be had function.
Carry out Happify Up (or Sift Up) to repair heap assets.
Instance of top-Down Heap creation

Don't forget the same array:

[4,10,3,5,1]
Insert four → Heap: [4]
Insert 10 → Heap: [10, 4] (10 swaps with four)
Insert three → Heap: [10, 4, 3]
Insert five → Heap: [10, 5, 3, 4] (five swaps with four)
Insert 1 → Heap: [10, 5, 3, 4, 1]

Evaluation of backside-Up vs. pinnacle-Down Heap creation

function backside-Up Heap creation pinnacle-Down Heap creation

technique Happify from closing non-leaf node Insert factors one by one
Complexity O(n) O (n log n)
performance faster for massive lots Slower for large lots
Use Case satisfactory for constructing thousands from massive datasets appropriate when
factors arrive dynamically
End
Bottom-Up Heap construction is greater efficient (O(n)) and is extensively used in Heap kind.
Pinnacle-Down Heap creation (O(nlogn)) is useful while records arrive dynamically.

For big-scale packages like priority queues and sorting algorithms, bottom-Up production is
favored because of its performance.

Q. No3
(a). How is Divide and Conquer a better method for sorting?

Ans: Why is Divide and Conquer a higher approach for Sorting?

Dividing and overcome is a good approach for sorting because it divides the trouble into
smaller subproblems, solves them recursively, after which combines the effects. This
approach is utilized in sorting algorithms like Merge sort and short sort, which offer sizeable
benefits over easier tactics like Bubble kind and Insertion type.

Blessings of Divide and Overcome for Sorting

1. Faster Time Complexity
Divide and conquer sorting algorithms generally run in O(n log n) time, making them
appreciably faster than O(n²) algorithms like Bubble type.
example:
Merge sort: continually O (n log n)
short type: common O (n log n), worst O(n²) (if poorly partitioned)

2. Efficient for large statistics units

unlike O(n²) sorting methods, O (n log n) algorithms continue to be efficient even for large
inputs.
Short short is usually used in exercise due to its cache-pleasant nature.

3. Better Use of Recursion

The hassle is damaged down into smaller subproblems, reducing complexity at each step.
Recursion offers a established and systematic way to clear up sorting troubles.

4. Parallelizability
Mergers can be correctly parallelized as sorting is carried out independently in subarrays
earlier than merging.

END
Divide and conquer presents better time complexity, scalability, and efficiency, making it a
superior approach for sorting big datasets in comparison to less difficult strategies.

(b). What is the best, worst and average cases in an insertion sort?

Ans: Quality, Worst, and common instances in Insertion kind

Insertion kind is an easy sorting algorithm that builds the sorted listing one detail at a time via
inserting factors into their accurate role. It’s far efficient for small datasets but less suitable
for large inputs.

1. Best Case: O(n)

circumstance: The array is already sorted.
motive: each element is as compared handiest as soon as with the preceding one and no
swaps are wanted.
example:
[1,2,3,4,5]
The algorithm performs n-1 comparisons and zero swaps.

2. Worst Case: O(n2)

Circumstance: The array is looked after in reverse order.
Cause: every detail needs to be compared with all preceding elements and shifted to the
beginning.

Example:
[5,4,3,2,1]
The primary element is already looked after.
The second one detail movements one step left.
The third detail actions are two steps left, and so on.
This outcomes in about (n²)/2 comparisons and swaps.

3.Average Case:
O(n2)
Situation: The elements are randomly ordered.
Reason: On common, each detail is inserted midway into the looked after portion, leading to
O(n²) comparisons and swaps.

Conclusion
exceptional Case: O(n) (Already looked after)
Worst Case: O(n2) (reverse looked after)
common Case: O(n2) (Random order)
Consequently, Insertion kind is green for nearly sorted information but sluggish for huge,
unsorted inputs.

Q. No4 Explain the algorithm to solve the Knapsack problem using the dynamic
programming method.

Ans: Solving the Knapsack hassle using Dynamic Programming

Creation to the Knapsack hassle
The 0/1 Knapsack trouble is a classic optimization hassle in which we've got:
items, each with a given weight and cost.
A knapsack with the most weight ability W
The goal is to maximize the total fee while making sure the entire weight does no longer
exceed W
we can both include or exclude an object (as a result, "0/1" Knapsack).

Dynamic Programming technique

Dynamic Programming (DP) is used to remedy this hassle successfully with the aid of
breaking it down into subproblems and storing solutions to avoid redundant calculations.
Set of rules for fixing zero/1 Knapsack the usage of DP

let dp[i][w] represent the maximum fee that can be acquired using the primary 𝑖 objects with
1. outline the nation

weight potential 𝑤
2. Recurrence Relation
dp[i][j]={dp[i−1][j],max(dp[i−1][j],v[i]+dp[i−1][j−w[i]]),if w[i]>j(item i cannot be included)
otherwise
Here:
 If the item's weight exceeds j, we cannot include it.
 Otherwise, we decide whether to include it or not based on maximum value gain.

3. Base Case
A 2D table dp[n+1][W+1] is initialized, where:
 dp[i][0] = 0 (no value if knapsack capacity is 0)
 dp[0][j] = 0 (no value if there are no items)
We fill the table using the recursive relation, iterating over all items and capacities.

4. Set of rules Implementation

def knapsack(values, weights, W):

n = len(values)
dp = [[0] * (W + 1) for _ in range(n + 1)]
for i in variety(1, n + 1):
for j in range(W + 1):
if weights[i-1] > j:
dp[i][j] = dp[i-1][j] # item cannot be protected
else:
dp[i][j] = max(dp[i-1][j], values[i-1] + dp[i-1][j - weights[i-1]])
return dp[n][W]
# example usage:
values = [60, 100, 120]
weights = [10, 20, 30]
W = 50
print(knapsack(values, weights, W)) # Output: 220

5. Time and space Complexity

Time Complexity: O(nW) – We iterate over n items and W capacities.
space Complexity: O(nW) – A 2d table of size (n+1) × (W+1) is used.

To optimize area, we can use a 1D array, reducing area complexity to

Optimized area Complexity method

Instead of the use of a 2d desk, we will replace a 1D array in reverse order:
def knapsack optimized (values, weights, W):
n = len(values)
dp = [0] * (W + 1)
for i in variety(n):
for j in range (W, weights[i] - 1, -1):
dp[j] = max(dp[j], values[i] + dp[j - weights[i]])
return dp[W]
# example utilization:
print (knapsack optimized ([60, 100, 120], [10, 20, 30], 50)) Output: 220
This method retains the same time complexity at the same time as lowering space to O (W
Conclusion
The dynamic programming solution efficiently solves the zero/1 Knapsack hassle via
building solutions incrementally. The optimized 1D DP method drastically reduces
reminiscence utilization without increasing complexity, making it ideal for large constraints.
The dynamic programming technique successfully solves the zero/1 Knapsack problem with
O(nW) complexity, making it feasible for moderate-sized inputs.

Q No.5 Explain the dynamic programming approach to find binomial coefficients

Ans: Finding Binomial Coefficients the use of Dynamic Programming

The binomial coefficient, denoted as
C(n,k), represents the number of methods to pick out
k factors from a fixed of
n factors without considering order. it is computed the usage of the formula:
C(n,ok)=
ok!(n−okay)!

but, direct computation using factorials can result in overflow issues and inefficiency because
of redundant calculations. alternatively, we use dynamic programming (DP) to compute
binomial coefficients correctly.

1. Expertise the Recursive Relation

The use of Pascal’s identification:
C(n,okay)=C(n−1,k−1)+C(n−1,ok)
This recurrence relation is derived through thinking about whether an detail is protected
within the choice or no longer:
If the detail is protected, we pick out

k−1 factors from

n−1 factors.

𝑘
If it isn't always included, we choose all

okay factors from

Base cases:

C(n,0)=C(n,n)=1
Rhose mirror the records that:
selecting zero gadgets from any set constantly has exactly 1 manner (deciding on not
anything).

𝑛
choosing all

𝑛
n items from an

n-detail set has precisely 1 way.

2. Dynamic Programming table approach
We use a 2nd DP table in which dp[i][j] stores
C(i,j).
set of rules Steps
Create a second table dp[n+1][k+1] initialized with 0.
Set base instances:
dp[i][0] = 1 (choosing zero factors)
dp[i][i] = 1 (selecting all factors)
Use the recurrence relation to fill the desk iteratively.

Implementation:
def binomial_coefficient(n, ok):
dp = [[0] * (ok + 1) for _ in variety(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1): # j can never be greater than i
if j == 0 or j == i:
dp[i][j] = 1 # Base cases
else:
dp[i][j] = dp[i-1][j-1] + dp[i-1][j] # Pascal’s identity
go back dp[n][k]
# example usage:
print(binomial_coefficient(five, 2)) # Output: 10
Time and space Complexity
Time Complexity: O(nk) on the grounds that we compute every value once.
Space Complexity: O(nk) due to the second table.

3. Optimized space Complexity technique

given that we only use values from the preceding row, we are able to optimize space toO(k)
by the use of a 1D array, updating values from proper to left.

Implementation
def binomial_coefficient_optimized(n, okay):
dp = [0] * (k + 1)
dp[0] = 1 # Base case: C(n, zero) = 1
for i in range(1, n + 1):
for j in variety(min(i, okay), zero, -1): # update from proper to left
dp[j] += dp[j - 1]
return dp[k]
# example utilization:
print(binomial_coefficient_optimized(five, 2)) # Output: 10

Time and space Complexity

Time Complexity:O(nk), equal as earlier than.
Area Complexity:O(k), when you consider that we keep handiest one row.

Conclusion
Using dynamic programming, we keep away from redundant calculations, making binomial
coefficient computation green. The optimized 1D DP approach further improves area
utilization, making it best for huge inputs.
Q No.6
(a). Describe greedy choice property

Ans: Grasping desire assets

The greedy choice belongings is an essential characteristic of problems that may efficiently
solved the usage of the greedy algorithm. It states that a globally premier solution can be
arrived at by making a chain of domestically most fulfilling selections, e.e., selecting the
high-quality option at every step without reconsidering past selections.

Key factors of grasping choice property

1. Local Optimality ends in global Optimality
The set of rules selects the fine on the spot alternative at every step.
As soon as a choice is made, it's far by no means reconsidered.
This guarantees that by the time the system is complete, the general solution is highest
quality.

2. No need for future Corrections

in contrast to dynamic programming, where subproblems are solved and combined, a greedy
method directly builds the answer.

Examples of problems with grasping preference assets

Interest choice problem
Deciding on the earliest completing interest always leads to the most excellent solution.
Huffman Coding
The lowest frequency symbols are merged first, making sure the superior prefix code.
Dijkstra’s algorithm (for shortest paths in graphs)
always expanding the shortest recognized route results inside the most fulfilling shortest
direction tree.
Fractional Knapsack hassle
selecting objects based on the best price-to-weight ratio ends in the highest quality total
value.

End
If a hassle satisfies the greedy desire assets along with most useful substructure, a greedy set
of rules can successfully discover the surest solution without the want for backtracking or
dynamic programming.

(b). Explain the sorting problem with the help of a decision tree

Ans. Sorting hassle using a choice Tree

A choice tree is a binary tree representation of all feasible comparisons made with the aid of a
assessment-based sorting set of rules. It allows in studying the decrease bound of sorting
algorithms.
1. knowledge choice bushes
Each inner node represents an assessment between elements.
Each leaf node represents a possible sorted order of the input.
The direction from root to leaf represents a sequence of comparisons leading to that order.
2. lower sure of contrast-primarily based Sorting
for the reason that a sorting set of rules must produce one of
n! feasible orders, the decision tree must have at the least
n! leaves.
A binary tree with L leaves has a top of as a minimum log
L=n!, the height of the tree is as a minimum: log

This indicates any assessment-based sorting algorithm (like Merge type, brief sort, or Heap
type) calls for at the least O(nlogn) comparisons in the worst case.
3. Example for Sorting 3 factors {A, B, C}
The foundation compares A and B.
relying at the end result, it then compares B and C or A and C.
The tree has 3!=6 leaves, confirming the O(nlogn) certain.

End
decision timber prove that no assessment-based sorting set of rules may be quicker
thaO(nlogn) in the worst case, making it a fundamental concept in sorting concept. 🚀