FACULTY OF

ENGINEERING
Computer Engineering Department

Algorithms Analysis and Design

Section:2
Name ID

Mohamed Bani Hasan 202111409

Ahmad Khaldi 202110946

Hasan Salah 202110579

Omar Almasri 202113524

1
Introduction:

Divide and conquer is a powerful algorithmic

technique that breaks down complex problems into
simpler, smaller parts, solves each part individually,
and then combines the solutions to solve the
original problem. When it comes to the
multiplication of large numbers, traditional methods
become inefficient as the size of the numbers
increases.

2
Divide and Conquer Approach:
Large integer multiplication using the divide and conquer method
involves a systematic process of breaking down the problem into smaller
sub-problems, solving them individually, and then combining the results
to obtain the final product. Here is a detailed explanation of the divide
and conquer methodology in the context of large integer multiplication,
along with a breakdown of the algorithmic steps involved:
1.Divide:
•Split the input integers, each with n digits, into two equal-sized halves.
Let's denote them as A and B.
•Express the original multiplication problem (A * B) as four sub-
problems: A₁ * B₁, A₁ * B₂, A₂ * B₁, and A₂ * B₂.
2.Conquer:
•Recursively compute the four sub-products using the same divide and
conquer approach until reaching base cases.
•The base case is often when the input integers have a small number of
digits, where direct multiplication becomes more efficient.
3.Combine:
•Combine the results of the sub-problems to obtain the final product.
•The combination step involves arithmetic operations and additions to
reconstruct the overall multiplication outcome.

Understanding and implementing these steps effectively enable

the algorithm to efficiently multiply large integers. The divide and
conquer methodology's advantage lies in its ability to reduce the
overall computational complexity by breaking down the problem
into more manageable components, thereby improving the
efficiency of large integer multiplication.

3
Algorithm design:

Justification for Design Choices and Considerations:

1.Divide Step:

•The algorithm divides the input integers into two halves to create sub-
problems. This choice simplifies the overall computation and aligns with the
essence of the divide and conquer paradigm.

2.Base Case:

•The base case checks if the integers are single-digit, at which point direct
multiplication is performed. This ensures that the algorithm efficiently handles
smaller sub-problems.

3.Recursion:

•The algorithm recursively applies the divide and conquer approach to solve
sub-problems. The recursive calls are made for each pair of divided sub-
integers.

4.Combination Step:

•The combination step effectively combines the results of the sub-problems to

obtain the final product. The choice of coefficients (10^(2*m) and 10^m) is
made to align with the place value of each sub-product.

4
5.SplitAt Helper Function:

The splitAt function simplifies the process of dividing large integers into two
halves. It is a crucial component for the divide step and enhances the
readability of the algorithm.

This algorithmic design strikes a balance between

simplicity and efficiency, leveraging the strengths of the
divide and conquer methodology to address the
challenges posed by large integer multiplication. The
chosen design allows for scalability and performance
improvements, making it a viable solution for practical
applications.

5
Implementation:
Below is a simplified Python implementation of the divide and
conquer algorithm for large integer multiplication:

1.Divide the numbers into halves:

•For A=1234, divide it into A1=12 (high-order digits) and
A2=34 (low-order digits).
•For B=5678, divide it into B1=56 and B2=78.
2.Conquer by recursively multiplying the smaller parts:

6
•Multiply A1 by B1 to get the high-order part of the
product (A1 * B1 = 12 * 56).
•Multiply A2 by B2 to get the low-order part of the
product (A2 * B2 = 34 * 78).
3.Multiply and add for the middle parts of the product:
•Multiply A1 by B2 and A2 by B1, then add them together
((A1 * B2) + (A2 * B1) = (12 * 78) + (34 * 56)).
3.Combine the sub-results to get the final product:
•The high-order product (from step 2) needs to be shifted
left by the total number of digits (in this case, 4, since each
half has 2 digits).
•The middle-order product (from step 3) needs to be
shifted left by the number of digits in one half (2 in this
case).
•The low-order product (from step 2) remains as is.
So the final result is calculated as:
Final Product=(A1×B1)×104+((A1×B2)+(A2×B1))×102+(A2×B2)
Final Product=(12×56)×104+((12×78)+(34×56))×102+(34×78)
•High-order product (A1 * B1) = 672

•Middle-order product ((A1 * B2) + (A2 * B1)) = 2840

•Low-order product (A2 * B2) = 2652

Final Product=(672×104)+(2840×102)+2652=7006652

7
Complexity Analysis:

1.Time Complexity:

1.The time complexity of the proposed divide and conquer

algorithm for large integer multiplication is O(n^log₂3), where n
represents the number of digits in the input integers.

2.This complexity arises from the recursive nature of the algorithm,

with each recursive call handling a fraction of the total digits. The
presence of four recursive calls per level contributes to the
logarithmic factor.
2.Space Complexity:
1.The space complexity of the algorithm is O(n), where n is the
number of digits in the input integers.

2.The space requirements primarily stem from the recursive call

stack and the storage of intermediate results during the
computation. The maximum depth of the recursion is log₂n.

Discussion on Efficiency Gains:

1.Reduced Time Complexity:

1.The primary advantage of the divide and conquer method lies in

its ability to significantly reduce the time complexity compared to
traditional multiplication algorithms.

2.The O(n^log₂3) time complexity of this algorithm represents a

substantial improvement over the O(n²) complexity of schoolbook
multiplication for large integers.

2.Optimized Recursive Structure:

1.The recursive structure of the algorithm allows for efficient
handling of sub-problems, and the divide and conquer approach
ensures that each sub-problem is of a manageable size.

8
2.By breaking down the problem into smaller parts, the algorithm
achieves optimal performance, especially for large integers where
the time savings become more pronounced.

3.Applicability to cryptography and Mathematics:

1.The efficiency gains become particularly valuable in

cryptographic applications, where large integer multiplication is a
fundamental operation.

2.The algorithm's scalability makes it well-suited for mathematical

computations involving extremely large integers, common in fields
such as number theory and cryptography.

Potential Trade-offs:
1.Implementation Complexity:

1.The divide and conquer approach introduces additional

complexity in terms of algorithmic design and implementation
compared to simpler methods like schoolbook multiplication.

2.Achieving optimal performance may require careful handling of

edge cases and considerations for practical implementation.
2.Space Overhead:
1.The space complexity, while linear, introduces some overhead
due to the storage of intermediate results. This overhead can
become significant for extremely large integers.

2.Striking a balance between space efficiency and time efficiency

may be a consideration, depending on the specific application.

3.Crossover Point:
There exists a crossover point where the divide and conquer
method becomes more efficient than traditional methods. This
point depends on factors such as the specific algorithm

9
implementations, hardware architecture, and the size of the input
integers.

Conclusion:
In conclusion, this exploration into large integer multiplication
using the divide and conquer approach has yielded key findings
and insights into algorithmic efficiency and design. The analysis
and implementation of the divide and conquer algorithm revealed
its significance in addressing challenges posed by the
multiplication of large integers. Here are the key findings:

1. Efficiency Gains:
•The divide and conquer approach, when applied to large
integer multiplication, demonstrates significant efficiency
gains compared to traditional quadratic algorithms like
schoolbook multiplication. The reduction in time complexity
to O(n^log₂3) positions it as a valuable strategy for handling
extremely large integers.

2.Versatility and Adaptability:

•The divide and conquer methodology is versatile and adaptable

to various scenarios, making it suitable for a broad range of
applications. Its scalability allows for efficient handling of large
integers encountered in diverse fields, including cryptography,
mathematics, and scientific computing

10