lOMoARcPSD|45529801

Data Structures & Algorithms for Problem Solving

Module – 4

Graph Algorithms and Polynomials with FFT

1. Graph Algorithms

Bellman-Ford Algorithm

Definition: The Bellman-Ford algorithm is a graph algorithm that computes the shortest
paths from a single source vertex to all other vertices in a weighted graph. It can handle
graphs with negative weight edges.

Algorithm Steps:

1. Initialize the distance to the source vertex as 0 and all other vertices as infinity.

2. For each vertex, relax all edges. This means for each edge ( (u, v) ) with weight ( w ), if
( distance[u] + w < distance[v] ), update ( distance[v] ).

3. Repeat the relaxation process for ( V-1 ) times, where ( V ) is the number of vertices.

4. Check for negative weight cycles by performing one more relaxation. If any distance
can still be updated, a negative cycle exists.

Complexity:

 Time Complexity: (O(V \cdot E)), where (V) is the number of vertices and (E) is the
number of edges.

 Space Complexity: (O(V)) for storing distances.

Single Source Shortest Paths in a DAG

Definition: In a Directed Acyclic Graph (DAG), the shortest paths from a single source can be
found using topological sorting.

Algorithm Steps:

1. Perform a topological sort of the DAG.

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

2. Initialize the distance to the source vertex as 0 and all other vertices as infinity.

3. Process each vertex in topological order:

 For each outgoing edge ( (u, v) ) with weight ( w ), if ( distance[u] + w <

distance[v] ), update ( distance[v] ).

Complexity:

 Time Complexity: (O(V + E)) due to topological sorting and relaxation.

 Space Complexity: (O(V)) for storing distances.

Johnson’s Algorithm for Sparse Graphs

Definition: Johnson’s algorithm finds the shortest paths between all pairs of vertices in a
sparse graph, even with negative weights, but without negative cycles.

Algorithm Steps:

1. Add a new vertex ( q ) connected to all other vertices with zero-weight edges.

2. Use the Bellman-Ford algorithm to find the shortest paths from ( q ) to all other
vertices. If a negative cycle is detected, terminate.

3. Reweight the edges using the formula: ( w'(u, v) = w(u, v) + h[u] - h[v] ), where ( h ) is
the distance from ( q ).

4. Use Dijkstra’s algorithm for each vertex to find the shortest paths in the reweighted
graph.

Complexity:

 Time Complexity: (O(V^2 \log V + V E)) for sparse graphs.

 Space Complexity: (O(V + E)).

Flow Networks and Ford-Fulkerson Method

Definition: The Ford-Fulkerson method computes the maximum flow in a flow network using
augmenting paths.

Algorithm Steps:

1. Initialize the flow in all edges to 0.

2. While there exists an augmenting path from the source to the sink, increase the flow
along this path.

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

3. Update the capacities of the edges and reverse edges accordingly.

Complexity:

 Time Complexity: (O(E \cdot f)), where (f) is the maximum flow.

 Space Complexity: (O(V + E)) for storing the graph.

Maximum Bipartite Matching

Definition: Maximum bipartite matching finds the largest matching in a bipartite graph.

Algorithm Steps:

1. Use the Hopcroft-Karp algorithm, which alternates between finding augmenting

paths and updating the matching.

2. Perform BFS to find the shortest augmenting paths.

3. Use DFS to find and augment the paths.

Complexity:

 Time Complexity: (O(E \sqrt{V})).

 Space Complexity: (O(V + E)).

2. Polynomials and the FFT

Representation of Polynomials

Definition: A polynomial can be represented as: [ P(x) = a_0 + a_1 x + a_2 x^2 + \ldots + a_n
x^n ] where ( a_i ) are the coefÏcients.

Storage: Polynomials can be stored in an array where the index represents the power of ( x ).

The DFT and FFT

Discrete Fourier Transform (DFT): The DFT transforms a sequence of complex numbers into
another sequence of complex numbers, providing frequency domain representation.

Formula: [ X(k) = \sum_{n=0}^{N-1} x(n) e^{-2\pi i kn/N} ]

Fast Fourier Transform (FFT): The FFT is an efÏcient algorithm to compute the DFT, reducing
the time complexity from (O(N^2)) to (O(N \log N)).

Algorithm Steps:

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

1. Divide the polynomial into even and odd indexed coefÏcients.

2. Recursively compute the FFT for both halves.

3. Combine the results using the properties of roots of unity.

EfÏcient Implementation of FFT

Implementation:

1. Use a recursive or iterative approach to divide the input.

2. Utilize in-place computation to save space.

3. Handle both real and complex coefÏcients.

Complexity:

 Time Complexity: (O(N \log N)).

 Space Complexity: (O(N)) for storing intermediate results.

Bellman-Ford Algorithm
Introduction

The Bellman-Ford algorithm is a fundamental algorithm in graph theory used to find the
shortest paths from a single source vertex to all other vertices in a weighted graph. It is
particularly useful for graphs that may contain negative weight edges, making it a versatile
choice for various applications in computer science, such as network routing and
optimization problems.

Definition

The Bellman-Ford algorithm computes the shortest path from a source vertex (s) to all other
vertices in a graph (G = (V, E)), where (V) is the set of vertices and (E) is the set of edges. The
algorithm can handle graphs with negative weight edges but cannot handle graphs with
negative weight cycles.

Algorithm Steps

1. Initialization:

 Set the distance to the source vertex (s) to 0: [ distance[s] = 0 ]

 Set the distance to all other vertices to infinity: [ distance[v] = \infty \quad \
text{for all } v \in V, v \neq s ]

2. Relaxation:

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

 For each vertex (V-1) times, iterate through all edges ( (u, v) ) with weight
( w ):

 If ( distance[u] + w < distance[v] ), update the distance: [ distance[v] =

distance[u] + w ]

3. Check for Negative Weight Cycles:

 After (V-1) iterations, perform one more iteration over all edges. If any
distance can still be updated, a negative weight cycle exists in the graph.

Pseudocode:

Complexity Analysis

 Time Complexity:

 The algorithm runs in (O(V \cdot E)), where (V) is the number of vertices and
(E) is the number of edges. This is because we perform relaxation for each
edge (E) for (V-1) iterations.

 Space Complexity:

 The space complexity is (O(V)) for storing the distance values.

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Example

Consider a graph with the following edges and weights:

 ( (A, B, 1) )

 ( (A, C, 4) )

 ( (B, C, -3) )

 ( (B, D, 2) )

 ( (C, D, 3) )

1. Initialize distances:

 ( distance[A] = 0 )

 ( distance[B] = \infty )

 ( distance[C] = \infty )

 ( distance[D] = \infty )

2. After the first iteration:

 Update ( distance[B] = 1 )

 Update ( distance[C] = 4 )

 Update ( distance[D] = \infty )

3. After the second iteration:

 Update ( distance[C] = -2 ) (via (B))

 Update ( distance[D] = 1 ) (via (B))

4. Final distances:

 ( distance[A] = 0 )

 ( distance[B] = 1 )

 ( distance[C] = -2 )

 ( distance[D] = 1 )

Conclusion

The Bellman-Ford algorithm is a powerful tool for finding the shortest paths in graphs with
negative weights. Its ability to detect negative weight cycles makes it a crucial algorithm in
various applications, including network routing and optimization problems. Understanding

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

the Bellman-Ford algorithm is essential for solving complex problems in graph theory and
computer science.

Single Source Shortest Paths in a Directed Acyclic Graph

(DAG)
Introduction

In graph theory, a Directed Acyclic Graph (DAG) is a directed graph that contains no cycles.
This property allows for efÏcient algorithms to find the shortest paths from a single source
vertex to all other vertices. The absence of cycles means that we can perform a topological
sort on the graph, which is a key step in finding the shortest paths.

Definition

The Single Source Shortest Path problem in a DAG involves finding the shortest paths from a
given source vertex (s) to all other vertices in the graph. The weights of the edges can be
positive, negative, or zero, but there should be no negative weight cycles.

Algorithm Steps

1. Topological Sorting:

 Perform a topological sort of the DAG. This will give an ordering of the
vertices such that for every directed edge ( (u, v) ), vertex (u) comes before
vertex (v) in the ordering.

2. Initialization:

 Initialize the distance to the source vertex (s) as 0: [ distance[s] = 0 ]

 Set the distance to all other vertices as infinity: [ distance[v] = \infty \quad \
text{for all } v \in V, v \neq s ]

3. Relaxation:

 Process each vertex in topological order. For each vertex (u), update the
distances of its adjacent vertices (v) using the relaxation technique:

 For each edge ( (u, v) ) with weight ( w ): [ if , distance[u] + w <

distance[v]: distance[v] = distance[u] + w ]

Pseudocode:

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Complexity Analysis

 Time Complexity:

 The time complexity for topological sorting is (O(V + E)), where (V) is the
number of vertices and (E) is the number of edges.

 The relaxation step also takes (O(V + E)).

 Therefore, the overall time complexity is: [ O(V + E) ]

 Space Complexity:

 The space complexity is (O(V)) for storing the distance values and the
topological order.

Example

Consider a DAG with the following vertices and edges:

 Vertices: (A, B, C, D, E)

 Edges with weights:

 (A \rightarrow B) (weight 1)

 (A \rightarrow C) (weight 4)

 (B \rightarrow C) (weight -3)

 (B \rightarrow D) (weight 2)

 (C \rightarrow D) (weight 3)

 (C \rightarrow E) (weight 2)

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

1. Topological Sort:

 A possible topological order could be: (A, B, C, D, E).

2. Initialization:

 (distance[A] = 0)

 (distance[B] = \infty)

 (distance[C] = \infty)

 (distance[D] = \infty)

 (distance[E] = \infty)

3. Relaxation:

 Process (A):

 Update (distance[B] = 1)

 Update (distance[C] = 4)

 Process (B):

 Update (distance[C] = -2) (via (B))

 Update (distance[D] = 3) (via (B))

 Process (C):

 Update (distance[D] = 3) (no change)

 Update (distance[E] = 6) (via (C))

4. Final Distances:

 (distance[A] = 0)

 (distance[B] = 1)

 (distance[C] = -2)

 (distance[D] = 3)

 (distance[E] = 6)

Conclusion

The Single Source Shortest Path algorithm for Directed Acyclic Graphs (DAGs) is efÏcient and
effective due to the properties of DAGs that allow for topological sorting. This algorithm is
widely used in various applications, including scheduling, optimization, and network routing.

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Understanding this algorithm is essential for solving shortest path problems in directed
graphs.

Johnson’s Algorithm for Sparse Graphs

Introduction

Johnson’s Algorithm is an efÏcient method for finding the shortest paths between all pairs of
vertices in a weighted directed graph. It is particularly useful for sparse graphs, where the
number of edges is much less than the square of the number of vertices. The algorithm can
handle graphs with negative weights but does not allow negative weight cycles.

Overview

Johnson’s Algorithm combines the Bellman-Ford algorithm and Dijkstra’s algorithm to

compute the shortest paths. It first reweights the edges to eliminate negative weights and
then applies Dijkstra’s algorithm for each vertex.

Algorithm Steps

1. Add a New Vertex:

 Introduce a new vertex (q) and connect it to all other vertices in the graph
with edges of weight 0. This allows the Bellman-Ford algorithm to compute
the shortest paths from (q) to all other vertices.

2. Run Bellman-Ford Algorithm:

 Use the Bellman-Ford algorithm starting from the new vertex (q) to compute
the shortest path distances (h[v]) from (q) to each vertex (v). If a negative
weight cycle is detected, terminate the algorithm.

3. Reweight the Edges:

 For each edge ( (u, v) ) with weight ( w(u, v) ), reweight the edges using the
formula: [ w'(u, v) = w(u, v) + h[u] - h[v] ]

 This transformation ensures that all edge weights (w'(u, v)) are non-negative.

4. Run Dijkstra’s Algorithm:

 For each vertex (v) in the original graph, run Dijkstra’s algorithm using the
reweighted edges (w'(u, v)) to find the shortest paths from (v) to all other
vertices.

5. Adjust the Distances:

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

 After obtaining the shortest path distances from Dijkstra’s algorithm, adjust
the distances back to the original weights using: [ distance[v] = d[v] -
h[source] + h[v] ]

 Here, (d[v]) is the distance obtained from Dijkstra’s algorithm.

Pseudocode

Complexity Analysis

 Time Complexity:

 The Bellman-Ford algorithm runs in (O(V \cdot E)).

 Dijkstra’s algorithm runs in (O((V + E) \log V)) when using a priority queue.

 Therefore, the overall time complexity of Johnson’s algorithm is: [ O(V \cdot E
+ V^2 \log V) ]

 This is efÏcient for sparse graphs where (E) is much less than (V^2).

 Space Complexity:

 The space complexity is (O(V)) for storing distances and (O(V + E)) for the
graph representation.

Example

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Consider a directed graph with the following edges and weights:

 (A \rightarrow B) (weight 1)

 (A \rightarrow C) (weight 4)

 (B \rightarrow C) (weight -3)

 (B \rightarrow D) (weight 2)

 (C \rightarrow D) (weight 3)

1. Add Vertex (q):

 Connect (q) to (A, B, C, D) with edges of weight 0.

2. Run Bellman-Ford:

 Compute shortest paths from (q) to all vertices.

3. Reweight Edges:

 Adjust the weights of the edges based on the distances obtained.

4. Run Dijkstra’s Algorithm:

 For each vertex, compute the shortest paths using the reweighted edges.

5. Adjust Distances:

 Convert the distances back to the original weights.

Conclusion

Johnson’s Algorithm is a powerful method for finding the shortest paths between all pairs of
vertices in sparse directed graphs. By combining the Bellman-Ford and Dijkstra’s algorithms,
it efÏciently handles graphs with negative weights while ensuring that the results are
accurate. Understanding Johnson’s Algorithm is essential for solving complex shortest path
problems in various applications, including network routing and optimization.

Flow Networks and the Ford-Fulkerson Method

Introduction

Flow networks are directed graphs where each edge has a capacity and each edge receives a
flow. The flow must satisfy certain constraints, and the goal is often to find the maximum
flow from a source vertex to a sink vertex. The Ford-Fulkerson method is a popular algorithm
used to compute the maximum flow in a flow network.

Flow Network Definition

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

A flow network is defined as a directed graph ( G = (V, E) ) with the following components:

 Vertices: A set of nodes, including a source ( s ) and a sink ( t ).

 Edges: A set of directed edges ( (u, v) ) with a capacity ( c(u, v) ) that represents the
maximum flow that can pass through the edge.

 Flow: A function ( f(u, v) ) that represents the flow from vertex ( u ) to vertex ( v ),
which must satisfy:

 Capacity Constraint: ( 0 \leq f(u, v) \leq c(u, v) )

 Flow Conservation: For every vertex ( v ) except for ( s ) and ( t ): [ \sum_{u \

in V} f(u, v) = \sum_{w \in V} f(v, w) ]

Ford-Fulkerson Method

The Ford-Fulkerson method computes the maximum flow in a flow network using the
concept of augmenting paths.

Algorithm Steps

1. Initialization:

 Start with an initial flow of 0 for all edges in the network.

2. Find Augmenting Path:

 While there exists an augmenting path from the source ( s ) to the sink ( t ) in
the residual graph, continue to augment the flow. The residual graph is
constructed by considering the remaining capacities of the edges after
accounting for the current flow.

3. Augment Flow:

 For each augmenting path found, determine the minimum capacity along the
path, known as the bottleneck capacity.

 Increase the flow along the path by the bottleneck capacity and update the
residual capacities of the edges accordingly.

4. Repeat:

 Repeat the process until no more augmenting paths can be found.

5. Result:

 The maximum flow is the total flow into the sink ( t ).

Pseudocode

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Complexity Analysis

 Time Complexity:

 The time complexity of the Ford-Fulkerson method depends on the method

used to find augmenting paths. If BFS is used (as in the Edmonds-Karp
algorithm), the complexity is (O(VE^2)), where (V) is the number of vertices
and (E) is the number of edges.

 If DFS is used, the complexity can be (O(E \cdot f)), where (f) is the maximum
flow.

 Space Complexity:

 The space complexity is (O(V + E)) for storing the graph and the flow values.

Example

Consider a flow network with the following vertices and edges:

 Vertices: (s, a, b, t)

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

 Edges with capacities:

 (s \rightarrow a) (capacity 10)

 (s \rightarrow b) (capacity 5)

 (a \rightarrow b) (capacity 15)

 (a \rightarrow t) (capacity 10)

 (b \rightarrow t) (capacity 10)

1. Initialization:

 Start with zero flow on all edges.

2. Find Augmenting Paths:

 Possible paths include (s \rightarrow a \rightarrow t) and (s \rightarrow b \

rightarrow t).

3. Augment Flow:

 For the path (s \rightarrow a \rightarrow t), the bottleneck is 10. Update the
flow accordingly.

4. Repeat:

 Continue finding paths and augmenting flow until no more augmenting paths
exist.

5. Result:

 The maximum flow from (s) to (t) is computed.

Conclusion

The Ford-Fulkerson method is a fundamental algorithm for solving the maximum flow
problem in flow networks. Its ability to handle various edge capacities and its
straightforward implementation make it a valuable tool in network flow analysis.
Understanding this method is essential for solving complex problems in operations research,
network design, and optimization.

Maximum Bipartite Matching

Introduction

Bipartite graphs are a special type of graph where the set of vertices can be divided into two
disjoint sets such that no two graph vertices within the same set are adjacent.
The Maximum Bipartite Matching problem involves finding the largest matching in a

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

bipartite graph, which is a set of edges that pairs vertices from the two sets without any
shared vertices.

Definition

A matching in a bipartite graph ( G = (U, V, E) ) is a subset of edges such that no two edges
share a vertex. The goal of the maximum bipartite matching problem is to find the largest
possible matching, which maximizes the number of edges in the matching.

Applications

 Job Assignments: Assigning jobs to workers where each worker can perform certain
jobs.

 Network Flow Problems: Solving problems related to flow networks.

 Resource Allocation: Allocating resources to tasks in a way that maximizes efÏciency.

Algorithm for Maximum Bipartite Matching

One of the most common algorithms to find the maximum bipartite matching is
the Hopcroft-Karp algorithm, which uses a combination of breadth-first search (BFS) and
depth-first search (DFS).

Algorithm Steps

1. Initialization:

 Create a matching set ( M ) and initialize it to empty.

2. BFS for Augmenting Paths:

 Use BFS to find the shortest augmenting path in the residual graph. An
augmenting path is a path that starts from an unmatched vertex in set ( U )
and ends at an unmatched vertex in set ( V ).

3. DFS to Augment the Matching:

 For each vertex found in the BFS, use DFS to find and augment the matching
along the path.

4. Repeat:

 Repeat the BFS and DFS steps until no more augmenting paths can be found.

5. Result:

 The matching set ( M ) will contain the maximum matching after the
algorithm terminates.

Pseudocode

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Complexity Analysis

 Time Complexity:

 The Hopcroft-Karp algorithm runs in (O(E \sqrt{V})), where (E) is the number
of edges and (V) is the number of vertices in the bipartite graph.

 Space Complexity:

 The space complexity is (O(V + E)) for storing the graph and the matching.

Example

Consider a bipartite graph with the following sets:

 Set ( U = {A, B, C} )

 Set ( V = {1, 2, 3} )

 Edges:

 ( A \rightarrow 1 )

 ( A \rightarrow 2 )

 ( B \rightarrow 2 )

 ( C \rightarrow 3 )

1. Initialization:

 Start with an empty matching ( M ).

2. BFS:

 Find augmenting paths. For example, ( A \rightarrow 1 ) can be matched.

3. DFS:

 Augment the matching by adding the edge ( A \rightarrow 1 ).

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

4. Repeat:

 Continue finding augmenting paths and augmenting the matching until no

more paths can be found.

5. Result:

 The maximum matching might be ( M = {(A, 1), (B, 2), (C, 3)} ).

Conclusion

Maximum Bipartite Matching is a fundamental problem in graph theory with numerous

practical applications. The Hopcroft-Karp algorithm provides an efÏcient method for finding
the maximum matching in bipartite graphs. Understanding this algorithm is essential for
solving various problems in optimization, resource allocation, and network flow.

Polynomials and the Fast Fourier Transform (FFT)

Introduction

Polynomials are mathematical expressions involving variables raised to powers and

coefÏcients. The Fast Fourier Transform (FFT) is an efÏcient algorithm for computing the
Discrete Fourier Transform (DFT) and its inverse. FFT is widely used in various applications,
including signal processing, image analysis, and solving polynomial multiplication efÏciently.

1. Representation of Polynomials

Definition: A polynomial ( P(x) ) of degree ( n ) can be represented as: [ P(x) = a_0 + a_1 x +
a_2 x^2 + \ldots + a_n x^n ] where ( a_0, a_1, \ldots, a_n ) are the coefÏcients of the
polynomial.

Storage: Polynomials can be stored in an array where the index represents the power of ( x ):

 For example, the polynomial ( P(x) = 3 + 2x + 5x^2 ) can be stored as: [ \

text{coefÏcients} = [3, 2, 5] ]

2. The Discrete Fourier Transform (DFT)

Definition: The Discrete Fourier Transform (DFT) transforms a sequence of complex numbers
into another sequence of complex numbers, providing a frequency domain representation.

Formula: For a sequence ( x_0, x_1, \ldots, x_{N-1} ), the DFT is defined as: [ X(k) = \
sum_{n=0}^{N-1} x(n) e^{-2\pi i kn/N} \quad \text{for } k = 0, 1, \ldots, N-1 ] where ( X(k) ) is
the k-th frequency component.

3. Fast Fourier Transform (FFT)

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Definition: The Fast Fourier Transform (FFT) is an efÏcient algorithm to compute the DFT,
reducing the time complexity from ( O(N^2) ) to ( O(N \log N) ).

Algorithm Steps:

1. Divide and Conquer:

 Split the input sequence into two halves: one containing the even-indexed
elements and the other containing the odd-indexed elements.

 Recursively compute the FFT for both halves.

2. Combine:

 Use the results from the two halves to compute the DFT of the original
sequence using the properties of roots of unity.

Cooley-Tukey Algorithm: The most common FFT algorithm is the Cooley-Tukey algorithm,
which recursively breaks down the DFT into smaller DFTs.

4. EfÏcient Implementation of FFT

Implementation:

1. Recursive Approach:

 Implement the FFT using recursion to handle the divide-and-conquer strategy.

2. In-Place Computation:

 Use in-place computation to save space and avoid creating additional arrays.

3. Bit-Reversal Permutation:

 Reorder the input array using bit-reversal to improve cache performance.

Complexity:

 Time Complexity: ( O(N \log N) )

 Space Complexity: ( O(N) ) for storing intermediate results.

5. Applications of FFT

 Polynomial Multiplication: FFT can be used to multiply two polynomials efÏciently.

By evaluating the polynomials at the roots of unity, multiplying the results, and then
using the inverse FFT, the product can be obtained in ( O(N \log N) ) time.

 Signal Processing: FFT is widely used in digital signal processing for analyzing
frequencies in signals.

 Image Processing: FFT is used in image compression and filtering techniques.

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Example of Polynomial Multiplication Using FFT

1. Polynomials:

 Let ( P(x) = 1 + 2x + 3x^2 ) and ( Q(x) = 4 + 5x ).

2. Evaluate at Roots of Unity:

 Use FFT to evaluate ( P(x) ) and ( Q(x) ) at the roots of unity.

3. Multiply the Results:

 Multiply the evaluated results pointwise.

4. Inverse FFT:

 Use the inverse FFT to convert the results back to the coefÏcient form of the
resulting polynomial.

Conclusion

Polynomials and the Fast Fourier Transform (FFT) are fundamental concepts in computer
science and mathematics. The FFT provides an efÏcient method for performing operations
on polynomials, such as multiplication, in a time-efÏcient manner. Understanding these
concepts is crucial for solving problems in various fields, including signal processing, image
analysis, and numerical computations.

Representation of Polynomials; The DFT and FFT; EfÏcient Implementation of FFT

1. Representation of Polynomials

Definition: A polynomial is a mathematical expression involving variables raised to powers

and coefÏcients. A polynomial ( P(x) ) of degree ( n ) can be expressed as: [ P(x) = a_0 + a_1 x
+ a_2 x^2 + \ldots + a_n x^n ] where ( a_0, a_1, \ldots, a_n ) are the coefÏcients of the
polynomial.

Storage: Polynomials can be represented in various ways, but the most common method is
using an array:

 The coefÏcients of the polynomial are stored in an array where the index represents
the power of ( x ).

 For example, the polynomial ( P(x) = 3 + 2x + 5x^2 ) can be stored as: [ \

text{coefÏcients} = [3, 2, 5] ]

 This representation allows for efÏcient evaluation and manipulation of polynomials.

2. The Discrete Fourier Transform (DFT)

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

Definition: The Discrete Fourier Transform (DFT) is a mathematical technique used to

transform a sequence of complex numbers into another sequence of complex numbers,
providing a frequency domain representation.

Formula: For a sequence ( x_0, x_1, \ldots, x_{N-1} ), the DFT is defined as: [ X(k) = \
sum_{n=0}^{N-1} x(n) e^{-2\pi i kn/N} \quad \text{for } k = 0, 1, \ldots, N-1 ] where ( X(k) ) is
the k-th frequency component.

Properties:

 The DFT converts time-domain signals into frequency-domain signals, allowing for
analysis of the frequency components.

 The DFT is computationally expensive, with a time complexity of ( O(N^2) ).

3. Fast Fourier Transform (FFT)

Definition: The Fast Fourier Transform (FFT) is an efÏcient algorithm to compute the DFT,
reducing the time complexity from ( O(N^2) ) to ( O(N \log N) ). The FFT is widely used in
various applications, including signal processing, image analysis, and polynomial
multiplication.

Algorithm Steps:

1. Divide and Conquer:

 Split the input sequence into two halves: one containing the even-indexed
elements and the other containing the odd-indexed elements.

 Recursively compute the FFT for both halves.

2. Combine:

 Use the results from the two halves to compute the DFT of the original
sequence using the properties of roots of unity.

Cooley-Tukey Algorithm: The most common FFT algorithm is the Cooley-Tukey algorithm,
which recursively breaks down the DFT into smaller DFTs.

4. EfÏcient Implementation of FFT

Implementation:

1. Recursive Approach:

 Implement the FFT using recursion to handle the divide-and-conquer strategy.

 The basic idea is to recursively compute the FFT for the even and odd indexed
elements.

2. In-Place Computation:

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

 Use in-place computation to save space and avoid creating additional arrays.
This can be achieved by reordering the input array using bit-reversal.

3. Bit-Reversal Permutation:

 Reorder the input array using bit-reversal to improve cache performance and
reduce memory access time.

Pseudocode for FFT:

function FFT(x):

N = length(x)

if N <= 1:

return x

even = FFT(x[0::2]) // FFT of even indexed elements

odd = FFT(x[1::2]) // FFT of odd indexed elements

T = [exp(-2 * pi * i * k / N) * odd[k] for k in range(N // 2)]

return [even[k] + T[k] for k in range(N // 2)] + [even[k] - T[k] for k in range(N // 2)]

Complexity Analysis

 Time Complexity: The FFT algorithm runs in ( O(N \log N) ), making it significantly
faster than the naive DFT computation.

 Space Complexity: The space complexity is ( O(N) ) for storing intermediate results.

Applications of FFT

 Polynomial Multiplication: FFT can be used to multiply two polynomials efÏciently.

By evaluating the polynomials at the roots of unity, multiplying the results, and then
using the inverse FFT, the product can be obtained in ( O(N \log N) ) time.

 Signal Processing: FFT is widely used in digital signal processing for analyzing
frequencies in signals.

 Image Processing: FFT is used in image compression and filtering techniques.

Conclusion

The representation of polynomials, the Discrete Fourier Transform (DFT), and the Fast
Fourier Transform (FFT) are fundamental concepts in computer science and mathematics.
The FFT provides an efÏcient method for performing operations on polynomials and
analyzing signals, making it a crucial tool in various applications. Understanding these

Downloaded by armar abdul (abdularmar6@gmail.com)

 lOMoARcPSD|45529801

concepts is essential for solving problems in numerical computations, signal processing, and
data analysis.

Downloaded by armar abdul (abdularmar6@gmail.com)