Divide and Conquer is an algorithmic paradigm that solves problems by:

Concept

Divide and Conquer is an algorithm-design paradigm built on three steps: divide the problem into smaller subproblems of the same type; conquer each subproblem by solving it recursively, with a base case solved directly; and combine the subproblem solutions into the solution of the original problem. The step that defines the paradigm is the recursive self-application to progressively smaller instances of the same problem.

Application

Merge Sort is a standard instance of this paradigm. To sort an array: divide it into two halves; conquer each half by recursively invoking the same Merge Sort procedure on it until a half contains a single element (the base case, which is trivially sorted); then combine the two sorted halves by merging them into one sorted array. All three steps happen inside a single procedure: it divides its own input, invokes itself on each smaller piece to conquer them, and then combines the returned results, driven by that self-invocation rather than by a loop repeating under a controlling condition, an approximate rule of thumb, or a single locally-optimal pick.

Cross-check

This matches the description of solving subproblems recursively. It rules out the other three descriptions: an iterative process repeats a loop body for as long as a controlling condition remains true (a counter, pointer position, or sentinel check), stopping once that condition becomes false, without the procedure calling itself again; a heuristic approach generally seeks a useful solution quickly without guaranteeing an optimal or provably correct result, which is not the systematic decomposition, subproblem-solving, and combination process being described here; and a greedy approach commits to a single locally-optimal choice at each step without revisiting it, a separate paradigm from the divide, solve, and combine structure described here.