Python Scripts: 2 Multiply two polynomials
Multiply Two Polynomials - Video Solution
Watch the video solution for Multiply Two Polynomials, a hard level problem involving Array, Math. This walkthrough by Afiz has 4,325 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
Problem Statement
You are given two integer arrays poly1 and poly2, where the element at index i in each array represents the coefficient of xi in a polynomial.
Let A(x) and B(x) be the polynomials represented by poly1 and poly2, respectively.
Return an integer array result of length (poly1.length + poly2.length - 1) representing the coefficients of the product polynomial R(x) = A(x) * B(x), where result[i] denotes the coefficient of xi in R(x).
Example 1:
Input: poly1 = [3,2,5], poly2 = [1,4]
Output: [3,14,13,20]
Explanation:
A(x) = 3 + 2x + 5x2andB(x) = 1 + 4xR(x) = (3 + 2x + 5x2) * (1 + 4x)R(x) = 3 * 1 + (3 * 4 + 2 * 1)x + (2 * 4 + 5 * 1)x2 + (5 * 4)x3R(x) = 3 + 14x + 13x2 + 20x3- Thus, result =
[3, 14, 13, 20].
Example 2:
Input: poly1 = [1,0,-2], poly2 = [-1]
Output: [-1,0,2]
Explanation:
A(x) = 1 + 0x - 2x2andB(x) = -1R(x) = (1 + 0x - 2x2) * (-1)R(x) = -1 + 0x + 2x2- Thus, result =
[-1, 0, 2].
Example 3:
Input: poly1 = [1,5,-3], poly2 = [-4,2,0]
Output: [-4,-18,22,-6,0]
Explanation:
A(x) = 1 + 5x - 3x2andB(x) = -4 + 2x + 0x2R(x) = (1 + 5x - 3x2) * (-4 + 2x + 0x2)R(x) = 1 * -4 + (1 * 2 + 5 * -4)x + (5 * 2 + -3 * -4)x2 + (-3 * 2)x3 + 0x4R(x) = -4 -18x + 22x2 -6x3 + 0x4- Thus, result =
[-4, -18, 22, -6, 0].
Constraints:
1 <= poly1.length, poly2.length <= 5 * 104-103 <= poly1[i], poly2[i] <= 103poly1andpoly2contain at least one non-zero coefficient.
Approach Overview
Problem Overview: You are given two polynomials represented as arrays of coefficients. The task is to multiply them and return the resulting polynomial. If A[i] represents the coefficient of x^i in the first polynomial and B[j] represents the coefficient of x^j in the second, the product requires computing coefficients for every power x^(i+j).
Approach 1: Naive Convolution (O(n*m) time, O(n+m) space)
The direct approach mirrors the mathematical definition of polynomial multiplication. Iterate through every coefficient in the first array and multiply it with every coefficient in the second array. Each product contributes to index i + j in the result array. This approach uses two nested loops and accumulates results into a result array of size n + m - 1. Time complexity is O(n*m) because every pair of coefficients is processed. Space complexity is O(n+m) for the output polynomial. This works well for small inputs and is often the first implementation you write to verify correctness.
Approach 2: Fast Fourier Transform (FFT) Convolution (O(n log n) time, O(n) space)
Polynomial multiplication can be transformed into a convolution problem. Instead of computing every pair of coefficients directly, convert both coefficient arrays into point-value form using the Fast Fourier Transform. Once transformed, multiplication becomes element-wise: multiply corresponding complex values from both transforms. Then apply the inverse FFT to convert the result back to coefficient form. Padding both arrays to the next power of two ensures efficient FFT computation and avoids cyclic convolution artifacts.
This approach reduces the complexity from quadratic to O(n log n), which is critical when polynomial degrees reach tens or hundreds of thousands. The algorithm relies heavily on numerical operations and array manipulation, making it closely related to problems involving arrays and numerical algorithms in math. Most competitive programming libraries and scientific computing packages provide optimized FFT implementations, so the main task is structuring the convolution pipeline correctly.
Recommended for interviews: Start by explaining the naive convolution to demonstrate you understand how polynomial multiplication works. Then transition to the FFT optimization and explain why convolution in frequency space reduces complexity. Interviewers usually expect awareness of FFT for large-scale polynomial multiplication because it shows strong algorithmic background beyond basic array manipulation.
Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Naive Convolution | O(n*m) | O(n+m) | Small polynomial sizes or quick verification of correctness |
| FFT-Based Multiplication | O(n log n) | O(n) | Large polynomials where quadratic multiplication becomes too slow |