MODULE 4

COMPUTATIONAL APPROACHES TO PROBLEM-SOLVING

(Introductory diagrammatic/algorithmic explanations only. Analysis not

required) :-

-----------------------------------------------------------

Brute-force Approach -Syllabus

- Example: Padlock, Password guessing

----------------------------------------------

Brute-force Approach

The brute-force approach is a fundamental method in problem-solving. It

involves systematically checking every possible solution to find the
optimal one, making it ideal for problems like cracking padlocks or
guessing passwords.

Despite its simplicity, brute-force methods can be computationally

expensive,especially for problems with large solution spaces, leading
to impractical execution times in real-world applications.

Examples of Brute-Force Approach

1. Padlock

Imagine you encounter a padlock with a four-digit numeric code. The brute-
force approach would involve sequentially trying every possible
combination from ”0000” to ”9999” until the correct code unlocks the
padlock.

Despite its simplicity and guaranteed success in finding the correct

combination eventually, this method can be time-consuming, especially for
longer or more complex codes.

2. Password Guessing In the realm of cybersecurity, brute-force attacks

are used to crack passwords by systematically guessing every possible
combination of characters until the correct password is identified. This
approach is effective against weak passwords that are short or lack
complexity.
For instance, attacking a six-character password consisting of letters and
digits would involve testing all 2.18 billion (366) possible combinations until
the correct one is identified.

3. Cryptography: Cracking Codes

In cryptography, brute-force attacks are used to crack codes or encryption

keys by systematically testing every possible combination until the
correctone is found. For example, breaking a simple substitution cipher
involves trying every possible shift in the alphabet until the plain-text
message is deciphered.

4. Sudoku Solving

Brute-force methods can be applied to solve puzzles like Sudoku by

systematically filling in each cell with possible values and backtracking
when contradictions arise. This method guarantees finding a solution but
may require significant computational resources, especially for complex
puzzles.

Characteristics of Brute-Force Solutions

1. Exhaustive Search: Every possible solution is examined. (it

disadvantage for problems with large solution spaces)

2. Simplicity: Easy to understand and implement.(advantage)

3. Inefficiency: Often slow and resource-intensive due to every possible

solution is examined (disadvantage)

4. Guaranteed Solution: If a solution exists, the brute-force method

willeventually find it.(advantage)

5.Time Complexity: Depending on the problem size, brute-force

approaches may require impractically long execution times to find
solutions.(disadvantage)

---------------------------------------------------------------------------

Divide-and-conquer Approach - Syllabus

- Example: The Merge Sort Algorithm

- Advantages of Divide and Conquer Approach

- Disadvantages of Divide and Conquer Approach

-----------------------------------------------------------------------------------

Divide-and-conquer Approach to Problem Solving

Key Steps of Divide-and-Conquer or Principles of Divide-and-Conquer

1. Divide: Split the original problem into smaller sub-problems that are
easier to solve. The sub-problems should be similar to the original problem.

Consider the task of organizing a large set of files into a well-structured

directory system. The first step involves breaking down this problem into
smaller, more manageable subproblems. For instance, you might divide the
files by their type (e.g., documents, images, videos) or by their project
affiliation. Each subset of files is then considered a subproblem, which is
more straightforward to organize than the entire set of files. The key is to
ensure that each subset is similar to the original problem but simpler to
handle individually.

2. Conquer: Solve the smaller sub-problems. If the sub-problems are

small enough, solve them directly. Otherwise, apply the divide-and-
conquer approach recursively to these sub-problems

Once the files are divided into smaller subsets, each subset is organized
recursively. For example, you could sort documents into subcategories
such as reports, presentations, and spreadsheets. Each of these
categories might be further divided into subfolders based on date or
project. This recursive approach allows you to systematically manage and
categorize each subset. For very small subsets, such as a single folder with
a few files, a direct solution is applied without further division, making the
problem- solving process more manageable.

3. Combine: Combine the solutions of the sub-problems to form the

solution to the original problem.

Algorithm DANDC (P)

begin
if (SMALL (P))
then return S (p)
else
divide p into smaller instances p1, p2, …. Pk, k > 1
apply DANDC to each of these sub problems;
return (COMBINE (DANDC (p1) , DANDC (p2),….,
DANDC (pk));
endif
end

Merge Sort Algorithm

Merge Sort is a classic example of the divide-and-conquer strategy used
for sorting an array of elements. It operates by recursively breaking down
the array into progressively smaller sections.

The core idea is to split the array into two halves, sort each half, and
then merge them back together.

This process continues until the array is divided into individual

elements, which are inherently sorted.

The merging process relies on a straightforward principle: when combining

two sorted halves, the smallest value of the entire array must be the
smallest value from either of the two halves. By iteratively comparing the
smallest elements from each half and appending the smaller one to the
sorted array, we efficiently merge the halves into a fully sorted array.

Here is how it works:

1. Divide: Split the array into two halves.

2. Conquer: Recursively sort both halves.

3. Combine: Merge the two sorted halves to produce the sorted array.
1. Function mergeSort()

Check if the array has one or zero elements. If true, return the array as it
is already sorted.Otherwise, find the middle index of the array.

Split the array into two halves: from the beginning to the middle andfrom
the middle+1 to the end.

Recursively apply mergeSort() to the first half and the second half

Merge the two sorted halves using the merge function.

Return the merged and sorted array.

Function merge()
Create an empty list called sorted_arr to store the sorted elements.
While both halves have elements:
 Compare the first element of the left half with the first
element of the right half.
Remove the smaller element and append it to the
sorted_arr list.
End while
If the left half still has elements, append them all to the sorted_arr
list.
If the right half still has elements, append them all to the
sorted_arrlist.
Return the sorted_arr list, which now contains the sorted elements
from both halves

Advantages and Disadvantages of Divide and Conquer

Approach
Advantages of Divide and Conquer Approach
1. Simplicity in Problem Solving: By breaking a problem into
smaller subproblems, each subproblem is simpler to understand and
solve, making the overall problem more manageable.
2. Efficiency: These algorithms often have lower time complexities
compared to iterative approaches.
3. Modularity: Divide-and-conquer promotes a modular approach to
problem- solving, where each subproblem can be handled by a
separate function or module. This makes the code easier to maintain
and extend.
4. Reduction in Complexity: By dividing the problem, the overall
complexity is reduced, and solving smaller subproblems can lead to
simpler and more efficient solutions.
5. Parallelism: The divide-and-conquer approach can easily be
parallelized because the subproblems can be solved independently
and simultaneously on different processors, leading to potential
performance improvements.
6. Better Use of Memory: Some divide-and-conquer algorithms use
memory more efficiently. For example, the merge sort algorithm
works well with large data sets that do not fit into memory, as it can
process subsets of data in chunks.

Disadvantages of Divide and Conquer Approach

1. Overhead of Recursive Calls: The recursive nature can lead to
significant overhead due to function calls and maintaining the call
stack. This can be a problem for algorithms with deep recursion or
large subproblem sizes.
2. Increased Memory Usage: Divide-and-conquer algorithms often
re-quire additional memory for storing intermediate results, which can
be a drawback for memory-constrained environments.
 3. Complexity of Merging Results: The merging step can be
complex and may not always be straightforward. Efficient merging
often requires additional algorithms and can add to the complexity of
the overall solution.
4. Not Always the Most Efficient: For some problems, divide-and-
conquer might not be the most efficient approach compared to
iterative or dynamic programming methods. The choice of strategy
depends on the specific
problem and context.
5. Difficulty in Implementation: Implementing divide-and-conquer
algorithms can be more challenging, especially for beginners. The
recursive nature and merging steps require careful design to ensure
correctness and efficiency.
6. Stack Overflow Risk: Deep recursion can lead to stack overflow
errors if the recursion depth exceeds the system’s stack capacity,
particularly with large inputs or poorly designed algorithms.

Applications of Divide and Conquer.

• Organize a large number of books in a College library.
The problem of categorizing and shelving thousands of books can
seem difficult at first. Dividing the books into smaller groups based on
department.(CS,ME,EE,EC,SB).Each group can then be further
subdivided into categories like Subject(Graphics,C,Java).
This method of dividing the problem into manageable parts, solving
each part, and then combining the results effectively demonstrates
how divide-and-conquer can make complex tasks more
approachable.
• In software development, the divide-and-conquer approach is
frequently employed in designing complex systems and
applications.
Consider the problem of developing a Library management
System Software
The platform is divided into various functional modules, such as
Member Registration,Book Registration,Issue Books,Return
Books,Reniew Books. Each module is developed and tested
independently, allowing developers to focus on specific aspects of the
system. Once all modules are completed, they are integrated to form
a cohesive application.This method ensures that the development
process is manageable and that each component functions correctly
before being combined into the final product.
• In healthcare, divide-and-conquer strategies are applied in
diagnostic processes and treatment plans.
For example, when diagnosing a complex medical condition, doctors
might first divide the patient’s symptoms into different categories,
such as neurological, cardiovascular, and respiratory. Each category
is investigated separately using targeted tests and consultations with
specialists.The results from these investigations are then combined to
form a comprehensive diagnosis and treatment plan.

• Consider the field of logistics and supply chain

management, where divide-and-conquer techniques are
used to optimize the distribution of goods.
For example, a company managing the supply chain for a large
retailer might divide the supply chain into regional distribution centers.
Each center handles a specific geographic area and manages local
inventory, transportation, and delivery. By decentralizing the
management of the supply chain into smaller, regional units, the
company can improve efficiency, reduce costs, and enhance service
levels. The results from each distribution center are then integrated to
ensure a seamless supply chain operation across all regions.

Various application areas of D and C

• Sorting Algorithms
Merge Sort and Quick Sort uses D and C
• Search Algorithms
Binary Search is a divide and conquer algorithm that searches for a
specific element in a sorted array by dividing the search space in half
with each comparison.
• Matrix Multiplication (Strassen's Algorithm)
Strassen's algorithm divides matrices into submatrices and reduces
the number of multiplications needed for large matrices.
• Game Development (AI)
Minimax algorithm with alpha-beta pruning is used in game theory,
where the game tree is divided into subtrees to determine the best
move.
---------------------------------------------------------------------
Dynamic Programming Approach Syllabus
- Example: Fibonacci series
 - Recursion vs Dynamic Programming
-------------------------------------------------------------------------

Dynamic Programming Approach to Problem Solving

Dynamic programming is a problem-solving technique that breaks down
complex problems into smaller, more manageable subproblems. The
solutions to these subproblems are then stored and reused to solve the
original problem. This approach is particularly useful when the same
subproblem appears multiple times, or when the solution can be expressed
recursively.
This approach is particularly effective for problems that exhibit two
key properties:

1.Optimal substructure

2.Overlapping subproblems.

Optimal Substructure: A problem has optimal substructure if the best

solution to the overall problem can be constructed from the best solutions
to its smaller sub problems. This means that if you have the optimal
solutions for the smaller components of the problem, you can combine
them to find the best solution for the entire problem. This property allows
Dynamic Programming to build solutions incrementally, using previously
computed results to achieve the most efficient outcome.

Example. Shortest Path in a Grid: Imagine you need to find the shortest
path from the top-left corner to the bottom-right corner of a grid. You can
only move right or down. Each cell in the grid has a certain cost associated
with entering it, and your goal is to minimize the total cost of the path.
3 2

1 4 5 (i-1,j)

3 2 (i,j-1) 4(i,j)

a) Problem Breakdown:(a) Smaller Subproblems: To find the shortest

path to a particularcell (i, j), you can look at the shortest paths to the cells
immediately above it (i − 1, j) and to the left of it (i, j − 1). The cost to
reachcell (i, j) will be the minimum of the costs to reach these
neighboringcells plus the cost of the current cell
(b) Optimal Substructure: If you know the shortest paths to cells(i − 1, j)
and (i, j − 1), you can use these to determine the shortest path to cell (i, j).
The optimal path to cell (i, j) can be constructed from the optimal paths to
its neighboring cells.

2. Overlapping Subproblems: Many problems require solving the same

subproblems multiple times. Dynamic Programming improves efficiency by
storing the results of these subproblems in a table to avoid redundant
calculations. By caching these results, the algorithm reduces the number of
computations needed, leading to significant performance improvements.

Example: Fibonacci Sequence In the Fibonacci sequence, each number

is the sum of the two preceding ones.

For example,
To find Fibonacci(5), you need the values of Fibonacci(4) and Fibonacci(3).
To compute Fibonacci(4), you need Fibonacci(3) and Fibonacci(2).
Notice that Fibonacci(3) is computed multiple times when calculating
different Fibonacci numbers.

Without Dynamic Programming:( USING RECURSION)

def fib(n):
If n==1 or n==2:
return 1
else:
return fib(n-1)+fib(n-2)

To compute Fibonacci(5), needs to calculate Fibonacci(3) twice.

This redundancy leads to a lot of repeated work.

With Dynamic Programming:

Dynamic programming is a method for solving problems by breaking
them down into simpler subproblems and storing the solutions to
these subproblems in a table to avoid redundant calculations.

compute Fibonacci(3) once and store its result.

When you need Fibonacci(3) again, retrieve the stored result instead of
recalculating it.This caching of results avoids redundant calculations and
speeds up the process.
How it Works:
(a) Compute: Calculate the Fibonacci numbers and store them in an
array.
(b) Reuse: Whenever you need the value of a Fibonacci number that
has already been computed, look it up in the array instead of recal-
culating.
By storing results and reusing them, Dynamic Programming reduces
the number of calculations needed to solve the problem, leading to
significant performance improvements.

Tabular method(dynamic programming)

def fib(n):
if n==1 or n==2:
return 1
f=[0]*(n+1)
f[1]=1
f[2]=1
for i in range(3,n+1):
f[i]=f[i-1]+f[i-2]
return f[n]

Recursion vs Dynamic Programming

 --------------------------------------------------------------------
Greedy Algorithm Approach : Syllabus
- Example: Given an array of positive integers each indicating the
completion time for a task, find the maximum number of tasks that
can be completed in
the limited amount of time that you have.
- Motivations for the Greedy Approach
- Characteristics of the Greedy Algorithm
- Greedy Algorithms vs Dynamic Programming
---------------------------------------------------------------------------
Greedy Approach to Problem Solving
The greedy approach, is often the most intuitive method in algorithm
design. When faced with a problem that requires a series of
decisions, a greedy algorithm makes the ”best” choice available at
each step, focusing solely on the immediate situation without
considering future consequences. This approach simplifies the
problem by reducing it to a series of smaller subproblems,each
requiring fewer decision.
We often deal with problems where the solution involves a sequence
of decisions or steps that must be taken to reach the optimal
outcome. The greedy approach is a strategy that finds a solution by
making the locally optimal choice at each step, based on the best
available option at that particular stage.
Example1: Coin Changing Problem
Given a set of coin denominations, the task is to determine the
minimum number of coins needed to make up a specified amount of
money. One approach to solving this problem is to use a greedy
algorithm, which works by repeatedly selecting the largest
denomination that does not exceed the remaining amount of money.
This process continues until the entire amount is covered.

Greedy Solution
1.Sort the coin denominations in descending order.
2. Start with the highest denomination and take as many coins of that
denomination as possible without exceeding the amount.
3. Repeat the process with the next highest denomination until the
amount is made up.
Example
Suppose you have coin denominations of 1, 5, 10, and 25 Rupees,
and you need to make change for 63 Rupees.
1. Take two 25-Rupee coins (63 - 50 = 13 Rupees left).
2. Take one 10-Rupee coin (13 - 10 = 3 Rupees left).
3. Take three 1-Rupee coins (3 - 3 = 0 Rupee left).
Thus, the minimum number of coins needed is six (two 25-Rupee
coins, one 10-Rupee coin, and three 1-Rupee coins).

Example-2 (Task Completion Problem)

Given an array of positive integers each indicating the completion
time for a task, find the maximum number of tasks that can be
completed in the limited amount of time that you have.
To solve the problem of finding the maximum number of tasks that
can be completed in a limited amount of time using a greedy
algorithm, you can follow these steps:
1. Sort the tasks by their completion times in ascending order: This
ensures that you always consider the shortest task that can fit into the
remaining time, maximizing the number of tasks completed.

2. Iterate through the sorted list of tasks and keep track of the
total time and count of tasks completed: For each task, if adding
the task’s completion time to the total time does not exceed the
available time, add the task to the count and update the total time.

def max_tasks(completion_times, available_time):

completion_times.sort()
total_time = 0
task_count = 0
for time in completion_times:
if total_time + time <= available_time:
total_time += time
task_count += 1
else:
break
return task_count

completion_times = [2, 3, 1, 4, 6]
available_time = 8
print(f"Maximum number of tasks that can be completed:”
,max_tasks(completion_times, available_time))

Key Characteristics of the Greedy Approach

1. Local Optimization: At each step, the algorithm makes the best
possible choice without considering the overall problem. This choice
is made with the hope that these local optimal decisions will lead to a
globally optimal solution.
2. Irrevocable Decisions: Once a choice is made, it cannot be
changed. The algorithm proceeds to the next step, making another
locally optimal choice.
3. Efficiency: Greedy algorithms are typically easy to implement and
run quickly, as they make decisions based on local information and
do not need to consider all possible solutions.
4. Problem-Specific Heuristics:
• Greedy algorithms often rely on problem-specific heuristics to guide
their decision-making process. These heuristics are designed based
on the properties of the problem.
5. Optimality:
• Greedy algorithms are guaranteed to produce optimal solutions for
some problems (e.g., Coin change, Huffman coding, Kruskal’s algo-
rithm for Minimum Spanning Tree) but not for some other problems.
The success of a greedy algorithm depends on the specific character-
istics of the problem.

Motivations for the Greedy Approach

1. Simplicity and Ease of Implementation:
Straightforward Logic: Greedy algorithms make the most optimal
choice at each step based on local information, making them easy to
understand and implement.
Minimal Requirements: These algorithms do not require com-
plex data structures or extensive bookkeeping, reducing the overall
implementation complexity.
2. Efficiency in Time and Space:
Fast Execution: Greedy algorithms typically run in linear or poly-
nomial time, which is efficient for large input sizes.
Low Memory Usage: Since they do not need to store large in-
termediate results, they have low memory overhead, making them
suitable for memory-constrained environments.
3. Optimal Solutions for Specific Problems:
• Greedy-Choice Property: Problems with this property allow local
optimal choices to lead to a global optimum.
• Optimal Substructure: Problems where an optimal solution to the
whole problem can be constructed efficiently from optimal solutions
to its sub-problems.
4. Real-World Applicability:
• Practical Applications: Greedy algorithms are useful in many
real-world scenarios like scheduling, network routing, and resource
allocation.
• Quick, Near-Optimal Solutions: In situations where an exact
solution is not necessary, greedy algorithms provide quick and rea-
sonably good solutions.
Greedy Algorithms vs. Dynamic Programming
Greedy Algorithms:
• Approach: Make the best possible choice at each step based on
local information, without reconsidering previous decisions.
• Decision Process: Makes decisions sequentially and irrevocably.
• Optimality: Guaranteed to produce optimal solutions only for cer-
tain problems with the greedy-choice property and optimal substruc-
ture.
• Efficiency: Typically faster and uses less memory due to the lack of
extensive bookkeeping.
• Example Problems: Coin Change Problem (specific denomina-
tions), Kruskal’s Algorithm for Minimum Spanning Tree, Huffman
Coding.
Dynamic Programming:
• Approach: Breaks down a problem into overlapping sub-problems
and solves each sub-problem only once, storing the results to avoid
redundant computations.
• Decision Process: Considers all possible decisions and combines
them to form an optimal solution, often using a bottom-up or top-
down approach.
• Optimality: Always produces an optimal solution by considering
all possible ways of solving sub-problems and combining them.
• Efficiency: Can be slower and use more memory due to storing
results of all sub-problems (memoization or tabulation).
• Example Problems: Fibonacci Sequence, Longest Common Sub-
sequence, Knapsack Problem.
-----------------------------------------------------
Randomized Approach:-Syllabus
- Example 1: A company selling jeans gives a coupon for each pair
of jeans. There are n different coupons. Collecting n different
coupons would give you free jeans. How many jeans do you expect
to buy before getting a free one?
-Example 2: n people go to a party and drop off their hats to a hat-
check person. When the party is over, a different hat-check person is
on duty and returns the n hats randomly back to each person. What is
the expected number of people who get back their hats?
- Motivations for the Randomized Approach
---------------------------------------------------------
Randomized Approach
- Example 1: A company selling jeans gives a coupon for each pair of
jeans. There are n different coupons. Collecting n different coupons
would give you free jeans. How many jeans do you expect to buy
before getting a free one?

Algorithmic Solution:
1. Initialize Variables:
TotalJeansBought=0
CouponsCollected={ }:
N=The total number of different coupon types

2. Buying Process:
Loop Until All Coupons Are Collected:
Total Jeans Bought +=1 Each time you buy a pair of jeans,
increase the counter for the total
jeans bought by one.
coupon = random.randint(1, n)
 CouponsCollected= CouponsCollected.add(coupon)
When you buy a pair of jeans, you get
a coupon. Add this coupon to your set
of collected coupons.
Check if you have collected all N different types of coupons by
comparing the size of your set to N.
3. Repeat for Accuracy:
To get a reliable estimate, repeat the entire buying process many
times (e.g., 100,000 times).
Keep a running total of the number of jeans bought across all
these repetitions.
4. Calculate the Average:
Average= Total Jeans Bought/100,000
After completing all repetitions, calculate the average number of
jeans bought by dividing the total number of jeans bought by the
number of repetitions.
5. Output the Result:
The average number of jeans bought from the repeated
simulations gives you a good estimate of how many pairs of jeans
you would typically need to buy before collecting all n coupons and
getting a free pair.

Example 2: n people go to a party and drop off their hats to a hat-

check person. When the party is over, a different hat-check person is
on duty and returns the n hats randomly back to each person. What is
the expected number of people who get back their hats?

Algorithmic Solution:
1. Initialization:
• Set up variables to count the total number of correct matches
across all simulations.
• Define the number of simulations to ensure statistical reliability.
• Define the number of people n.
2. Simulate the Process:
For each simulation:
– Create a list of hats representing each person.
– Shuffle the list to simulate random distribution.
– Count how many people receive their own hat.
– Add this count to the total number of correct matches.
3. Calculate the Expected Value:
Divide the total number of correct matches by the number of
simulations to get the average.
4. Output the Result:
Print the expected number of people who get their own hats back.
Motivations for the Randomized Approach

Complexity Reduction: A randomized approach often simplifies

com plex problems by introducing probabilistic choices that
lead to efficient solutions.
(For example, imagine you are organizing a community health
screening event in a large city. You need to decide on the number of
screening stations and their locations to maximize coverage and
efficiency.
Instead of analyzing every possible combination of locations and
station numbers—which would be highly complex and time-
consuming - you could randomly select several potential locations
and test their effectiveness. By evaluating a sample of these random
setups, you can identify patterns or clusters of locations that work
well. This method simplifies the complex problem of optimizing station
placement by reducing the number of scenarios you need to explore
in detail.)
2. Versatility: Applicable across diverse domains, from combinatorial
optimization to stochastic simulations, where deterministic solutions
may be impractical or infeasible.
(For example, consider a company that is developing a new app and
wants to test its usability. Testing every feature with
every possible user scenario could be impractical. Instead, the
company could randomly select a diverse group of users and a
subset of features to test. By analyzing how this sample of users
interacts with the app and identifying any issues they encounter, the
company can gain insights that are broadly applicable to all users.
This approach allows the company to obtain useful feedback and
make improvements without needing to test every possible
combination of user and feature.)
3. Performance: In certain scenarios, a randomized approach can
offer significant performance improvements over deterministic
counterparts, particularly when dealing with large datasets or
complex systems.
For example, imagine a large library that wants to estimate how often
books are checked out. Instead of tracking every single book’s check-
out frequency which would be a massive task—the library staff could
randomly sample a selection of books from different genres and
record their check-out rates over a period of time. By analyzing this
sample, they can estimate the average check-out frequency for the
entire collection. This approach improves performance in terms of
both time and resources, allowing the library to make informed
decisions about which books to keep, acquire, or remove based on
practical data from the sampled books
---------------------------------------------------------------