Transform and Conquer: Solving Computational Problems through Problem Reduction
Transform and conquer is a problem solving technique where a problem is transformed into another problem that is easier to solve. The solution to the transformed problem provides the solution to the original one.
Key aspects:
 Identify a transformation that simplifies the problem
 Solve the transformed problem recursively
 Map the solution back to original problem
 Transformation reduces complexity in some way
For example, in merge sort, the array is transformed into two halves. In dynamic programming, a multistage problem is transformed into a singlestage problem.
Example in Java:


Here the odd n input is transformed into an even number to simplify the problem. The solution is mapped back to the original n.
Similar transform and conquer solutions can be developed in C++, Python by applying a problem simplifying transformation and mapping the solution back.
Introduction
Transform and Conquer is a problemsolving paradigm that first transforms the given problem into a different representation or instance of the same problem or a related problem. After the transformation, it becomes easier or more straightforward to solve. Finally, the solution to the transformed problem is used to obtain the solution to the original problem.
There are typically three kinds of transformations that are used:
Instance Simplification: The given instance of a problem is simplified, making it easier to solve. This doesn’t change the problem, but simplifies the instance of it. For example, in Gaussian Elimination, the given system of linear equations is simplified by replacing it with an equivalent system that is easier to solve.
Problem Reduction: The given problem is transformed into a different problem that we know how to solve more efficiently. This method is often used in problems where a known algorithm can be utilized. For example, reducing the problem of polynomial multiplication to the problem of integer multiplication.
Representation Change: The problem remains the same, but the way the data or inputs are represented or organized is changed. An example is changing an unsorted array to a sorted array in order to perform a binary search instead of a linear search.
In all of these cases, the main idea is to transform the problem or its instance into something that is easier to handle, solve it, and then translate this solution back into the context of the original problem.
Here are examples for each kind of transformation in the Transform and Conquer strategy:
Instance Simplification: Consider the problem of finding the greatest common divisor (GCD) of two numbers. A simple method is to list all the divisors of each number and then find the greatest number that appears in both lists. But this can be simplified by using the Euclidean algorithm, which is based on the principle that the GCD of two numbers also divides their difference. So, you can repeatedly replace the larger number with the difference of the two numbers, reducing the size of the numbers until you reach a point where they are the same, that is, their GCD.
Here’s the Python code for the Euclidean algorithm:
1 2 3 4
def gcd(a, b): while b != 0: a, b = b, a % b return a
Problem Reduction: The problem of multiplying two matrices can be reduced to a simpler problem using Strassen’s algorithm. Strassen’s algorithm breaks a large matrix multiplication problem into seven smaller subproblems, each of which is a multiplication problem half the size of the original, plus several addition and subtraction operations.
Representation Change: An example of this would be the problem of finding an element in an array. If the array is unsorted, the best approach is a linear search, which has O(n) complexity. However, if we sort the array first (i.e., we transform the representation of the data), we can then use binary search, which has O(log n) complexity. The transformation part here is the sorting of the array. Of course, the time complexity of the sorting algorithm itself should also be taken into account.
Explanation at Five Levels
Let’s break down the concept of Transform and Conquer in five different layers of complexity:
1. Child: Imagine you have a big puzzle with a hundred pieces. That sounds like a lot, doesn’t it? But what if you first sorted the pieces by color or edge pieces? It would make putting the puzzle together a lot easier, right? This is what we do in the Transform and Conquer strategy. We change a big problem into a different form that’s easier to solve!
2. Teenager: You know when you have a math problem, and it’s a bit tricky to solve in its current form? Sometimes, you can make it simpler by moving things around or using a formula. This is the idea behind Transform and Conquer. It’s like simplifying a complex fraction into a smaller one; it’s much easier to work with, right?
3. Undergraduate: In computer science, the Transform and Conquer strategy is a method used to make a problem easier to solve. This could mean simplifying the problem, changing how the data is represented, or reducing the problem to a simpler one that we already know how to solve. For example, if you’re given an unsorted list to search an item, it would be more efficient to sort it first and then perform a binary search.
4. Graduate student: Transform and Conquer is an algorithm design paradigm that involves modifying the problem to make it easier to solve and then solving it. The modification could take the form of problem simplification, problem reduction, or changing the representation of the problem. A notable example is the Fast Fourier Transform algorithm that transforms a time domain signal into a frequency domain signal, allowing for efficient computation of convolution and easing digital signal processing tasks.
5. Colleague: Transform and Conquer is a crucial technique in our toolbox as algorithm designers. This paradigm allows us to modify a problem into a more tractable form, often by simplifying instances, reducing to another problem or changing the problem’s representation. A good understanding of problem transformation can lead to highly efficient algorithms that exploit problem structure, as we see in Strassen’s matrix multiplication algorithm, where a complex O(n^3) operation is transformed to less costly operations on smaller matrices, achieving O(n^log2(7)) complexity. Let’s delve deeper into how we can leverage this paradigm in our current problem set.
Level 1  Child: Imagine you’re trying to solve a jigsaw puzzle, but it’s too hard because all the pieces are facing downwards. So, you flip them all to face upwards to see the pictures on them. Now, it’s a lot easier to solve the puzzle. That’s what transform and conquer is like. You take a hard problem, change it into an easier one, and then solve it!
Level 2  Teenager: Let’s consider a game of tictactoe. It can be tough to know where to place your ‘X’ or ‘O’ to win. But, what if you could change the game’s rules and make it easier, like saying you win if you get two in a row instead of three? That would make deciding where to place your ‘X’ or ‘O’ easier, right? That’s what transform and conquer is about. You take a complex problem, change it into a simpler one that you can solve more easily, and then solve it!
Level 3  College Undergraduate: Transform and conquer is an algorithmic paradigm where a problem is made easier to solve, or more ‘digestible’, through a transformation. For instance, in sorting algorithms like heapsort, the original unsorted array is transformed into a heap data structure. This transformation makes it easier to then extract the elements in sorted order. The process involves transforming the problem, solving the transformed problem, and, if necessary, interpreting the solution to answer the original problem.
Level 4  Graduate Student: Transform and conquer is an advanced problemsolving approach where a problem instance is transformed into another problem instance which is easier to solve. After solving the transformed problem, the solution of the original problem can be constructed in an easier or more straightforward way. A practical example is the use of Fast Fourier Transform (FFT) in polynomial multiplication. A brute force approach would result in O(n^2) time complexity, but by transforming the polynomials into points in the frequency domain using FFT, we can achieve O(n log n) time complexity.
Level 5  Fellow Scientist/Colleague: The transform and conquer strategy is an integral approach in algorithm design and analysis. It involves changing the representation or instance of a given problem to make it more tractable. The transformation could either be instance simplification or problem reduction. Instance simplification involves modifying the instance of the problem to make it easier to solve, while problem reduction involves altering the problem to a different problem, solving that, and then interpreting the solution in the context of the original problem. A comprehensive study of this paradigm aids in efficient algorithmic problemsolving and provides a deeper understanding of problem complexity.
Applying the Transform and Conquer
Sometimes a computational task is sufficiently general that any subroutine for it can also be used to solve a variety of other tasks. At first glance they might seem unrelated. For instance, an algorithm for finding the longest path in a DAG can also be used for finding the longest increasing subsequences. The longest increasing subsequence problem reduces to the longest path problem in a DAG. In turn, the longest path in a DAG reduces to the shortest path in a DAG.
Longest Path(G)
Negate all edge weights of G
Return Shortest Path of G
We first preprocess, then utilize the algorithm for another problem. Finally we postprocess the output to solve the original problem.
The process we have just described is known as problem reduction or transformandconquer strategy. This strategy involves transforming the original problem into another problem, solving the transformed problem, and then interpreting the solution of the transformed problem to get a solution to the original problem.
Let’s elaborate on the example provided:
Longest Increasing Subsequence (LIS): The Longest Increasing Subsequence problem is to find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order. For example, for the sequence {3, 4, 5, 1, 2}, the longest increasing subsequence is {3, 4, 5} with length 3.
Longest Path in Directed Acyclic Graph (DAG): The Longest Path Problem for a directed acyclic graph is to find the longest possible path in the graph. The length of the path is calculated based on the sum of the weights of the edges.
When you look at these two problems individually, they may seem unrelated. However, we can reduce the LIS problem to the Longest Path in a DAG problem:
Preprocessing: Transform the LIS problem to the Longest Path problem in a DAG. Each number in the array is a node and directed edges are drawn from smaller numbers to larger numbers, preserving the order in which they appear in the original sequence. The length of the edge is usually assigned the value of the destination node.
Solving the transformed problem: Now, finding the longest increasing subsequence is just a matter of finding the longest path in this DAG. But, most algorithms are designed to find the shortest path. We can still use these by negating all the weights, so the shortest path becomes the longest path.
Postprocessing: Once we have the longest path in the transformed problem, we can easily obtain the longest increasing subsequence in the original problem by following the path and picking the corresponding numbers in the original sequence. This step involves reversing the transformation done in the preprocessing step.
This approach of transforming one problem to another, easiertosolve problem, and then using the solution of the simpler problem to obtain a solution for the original problem is a common technique in algorithm design and is often used in dynamic programming and graph theory.
Divide and Conquer vs Transform and Conquer
Divide and Conquer and Transform and Conquer are both powerful strategies used in algorithm design, but they are fundamentally different in their approach to solving problems. Let’s examine each one:
Divide and Conquer:
Divide and Conquer involves breaking a problem down into smaller, independent subproblems that are similar to the original problem, solving these subproblems, and then combining their solutions to solve the original problem. This technique is used extensively in many algorithms including QuickSort, MergeSort, and Binary Search.
In QuickSort, for example, the problem of sorting an entire array is divided into smaller problems of sorting two subarrays. Each of these subproblems is solved independently, and their solutions are combined to produce the sorted array.
Transform and Conquer:
On the other hand, Transform and Conquer involves transforming the original problem into a different problem that is easier to solve. The transformation does not necessarily break the problem down into subproblems, but changes its representation or its instance to simplify the problemsolving process. Examples of this strategy include the use of heapsort (transforming an array into a heap to make extraction of the maximum element efficient), or the Fast Fourier Transform (transforming a time domain signal into a frequency domain signal to ease digital signal processing tasks).
In summary, while Divide and Conquer solves a problem by dividing it into smaller instances of the same problem, Transform and Conquer solves it by transforming the problem into a different, usually simpler, problem.
Decrease and Conquer vs Transform and Conquer
The key difference between decrease and conquer and transform and conquer is:
Decrease and Conquer:
 Reduces the problem to a smaller instance of the same problem
 The subproblem is of the same nature, just smaller in size
 Recursively solves smaller versions until base case is reached
 Combines solutions to smaller problems for overall solution
For example, calculating nth Fibonacci number by reducing to (n1)th and (n2)th Fibonacci numbers.
Transform and Conquer:
 Transforms the problem into a different, easier to solve problem
 Solves the transformed problem recursively
 Maps the solution back to the original problem
 Transformation simplifies or changes the nature of problem
For example, converting a multiplication problem to repeated addition, solving addition and mapping back.
In summary:
 Decrease and conquer reduces the size/scale of the same problem
 Transform and conquer changes the type/nature of the problem
Decrease and conquer shrinks the problem, while transform and conquer morphs the problem into an easier one. But both solve the transformed problem and map the solution back to the original.
Comparison of All Three Approaches
The key differences between decrease & conquer / transform & conquer and divide & conquer are:
Divide and Conquer:
 Divides the problem into nonoverlapping subproblems
 Subproblems are disjoint and independent
 Solves subproblems recursively
 Combines solutions to subproblems to solve original problem
For example, merge sort divides the array into two halves, conquers the halves, and merges the sorted halves.
Decrease and Conquer:
 Reduces to smaller version of the same problem
 Subproblem is similar but smaller in scale
 Solves smaller version recursively
 Combines solutions of smaller problems
For example, Fibonacci solves for N by reducing to N1 and N2.
Transform and Conquer:
 Transforms into different, easier to solve problem
 Solves transformed problem recursively
 Maps solution back to original problem
For example, converting multiplication to repeated addition.
In summary:
 Divide and conquer divides into independent subproblems
 Decrease and conquer shrinks the same problem
 Transform and conquer morphs the problem into an easier one
Divide and conquer splits the problem, while decrease and conquer and transform and conquer simplify the problem in different ways.
Here is a comparison table of the three problem solving approaches:
Approach  How it works  Example 

Divide and Conquer   Divide into nonoverlapping subproblems Solve subproblems recursively Combine solutions to subproblems  Merge sort  divide array into halves Sort each half recursively Merge sorted halves 
Decrease and Conquer   Reduce to smaller version of same problem Solve smaller version recursively  Combine solutions to small problems  Fibonacci  reduce to Fib(n1) and Fib(n2)  Solve smaller Fibonacci numbers Add solutions 
Transform and Conquer   Transform into different, easier problem Solve transformed problem recursively Map solution back  Multiplication to repeated addition Solve easier addition problem Map addition back to multiplication 
In summary:
 Divide and conquer divides into independent subproblems
 Decrease and conquer shrinks the problem’s size/scale
 Transform and conquer morphs the problem into an easier one
But all three approaches solve subproblems recursively and combine solutions in some way to solve the original problem.