Why Find Maximum Subarray Divide and Conquer in DSA C++?

The Big Idea

What if you could find the best money-making period in your data without checking every single possibility?

The Scenario

Imagine you have a long list of daily profits and losses from your small business. You want to find the best continuous period where you made the most money. Doing this by checking every possible period by hand would take forever!

The Problem

Manually checking every possible continuous period means looking at many combinations, which grows very fast as the list gets longer. This is slow and easy to make mistakes, especially if the list is big.

The Solution

The divide and conquer method breaks the big problem into smaller parts, solves each part, and then combines the answers. This way, it finds the best period much faster and without missing any possibilities.

Before vs After

✗ Before

int maxSum = INT_MIN;
for (int i = 0; i < n; i++) {
  for (int j = i; j < n; j++) {
    int sum = 0;
    for (int k = i; k <= j; k++) sum += arr[k];
    if (sum > maxSum) maxSum = sum;
  }
}

✓ After

int findMaxCrossingSubarray(int arr[], int left, int mid, int right) {
  int leftSum = INT_MIN, sum = 0;
  for (int i = mid; i >= left; i--) {
    sum += arr[i];
    if (sum > leftSum) leftSum = sum;
  }
  int rightSum = INT_MIN;
  sum = 0;
  for (int i = mid + 1; i <= right; i++) {
    sum += arr[i];
    if (sum > rightSum) rightSum = sum;
  }
  return leftSum + rightSum;
}

int findMaxSubarray(int arr[], int left, int right) {
  if (left == right) return arr[left];
  int mid = (left + right) / 2;
  int leftMax = findMaxSubarray(arr, left, mid);
  int rightMax = findMaxSubarray(arr, mid + 1, right);
  int crossMax = findMaxCrossingSubarray(arr, left, mid, right);
  return max(leftMax, max(rightMax, crossMax));
}

What It Enables

This method lets you quickly find the most profitable continuous period in large data sets without checking every possibility one by one.

Real Life Example

A stock trader wants to find the best time window to buy and sell stocks to maximize profit from historical price changes.

Key Takeaways

Manual checking is slow and error-prone for large lists.

Divide and conquer breaks the problem into smaller parts and combines results efficiently.

This approach finds the maximum subarray sum faster and reliably.

Practice

1. What is the main idea behind the Divide and Conquer approach to find the maximum subarray sum?

easy

A. Use a sliding window to find the max sum subarray in one pass

B. Sort the array and pick the largest element as max subarray sum

C. Divide the array into two halves, find max subarray in left, right, and crossing middle, then combine results

D. Calculate all possible subarrays and pick the one with max sum

Solution

1. Step 1: Understand divide and conquer strategy

   The array is split into two halves recursively to simplify the problem.

2. Step 2: Combine results from left, right, and crossing subarrays

   We find max subarray sums in left half, right half, and subarrays crossing the middle, then take the maximum.

3. Final Answer:

   Divide the array into two halves, find max subarray in left, right, and crossing middle, then combine results -> Option C

4. Quick Check:

   Divide and conquer = split and combine max sums [OK]

Hint: Split array, check left, right, and crossing sums [OK]

Common Mistakes:

• Thinking sorting helps find max subarray sum
• Ignoring subarrays crossing the middle
• Trying to check all subarrays without divide and conquer

2. Which of the following is the correct base case condition in the divide and conquer function for maximum subarray?

easy

A. if (low >= high) return arr[low] + arr[high];

B. if (low > high) return 0;

C. if (low == high) return 0;

D. if (low == high) return arr[low];

Solution

1. Step 1: Identify base case for single element

   When low equals high, the subarray has one element, so max sum is that element itself.

2. Step 2: Check options for correct base case

   if (low == high) return arr[low]; returns arr[low] when low == high, which is correct base case.

3. Final Answer:

   if (low == high) return arr[low]; -> Option D

4. Quick Check:

   Single element subarray max sum = element value [OK]

Hint: Base case: single element returns that element [OK]

Common Mistakes:

• Returning 0 for single element subarray
• Using incorrect comparison operators in base case
• Returning sum of two elements when only one element left

3. What is the output of the following code snippet using divide and conquer to find max subarray sum?

int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
int n = 9;
int maxCrossingSum(int arr[], int low, int mid, int high) {
    int sum = 0, left_sum = INT_MIN;
    for (int i = mid; i >= low; i--) {
        sum += arr[i];
        if (sum > left_sum) left_sum = sum;
    }
    sum = 0; int right_sum = INT_MIN;
    for (int i = mid + 1; i <= high; i++) {
        sum += arr[i];
        if (sum > right_sum) right_sum = sum;
    }
    return left_sum + right_sum;
}
int maxSubArraySum(int arr[], int low, int high) {
    if (low == high) return arr[low];
    int mid = (low + high) / 2;
    int left_max = maxSubArraySum(arr, low, mid);
    int right_max = maxSubArraySum(arr, mid + 1, high);
    int cross_max = maxCrossingSum(arr, low, mid, high);
    return max(max(left_max, right_max), cross_max);
}
int result = maxSubArraySum(arr, 0, n - 1);
std::cout << result;

medium

A. 6

B. 7

C. 5

D. 4

Solution

1. Step 1: Identify the maximum subarray

   The array is [-2, 1, -3, 4, -1, 2, 1, -5, 4]. The subarray [4, -1, 2, 1] (indices 3-6) sums to 6, the maximum.

2. Step 2: Verify code execution

   Top-level split: left_max=4, right_max=4, cross_max=6 (left suffix 4 + right prefix -1+2+1=2). Returns 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Max subarray sum = 6 [OK]

Hint: Check sums of subarrays crossing middle carefully [OK]

Common Mistakes:

• Confusing max crossing sum with max overall sum
• Miscounting indices in loops
• Assuming max sum includes all positive numbers only

4. Identify the bug in this divide and conquer max subarray code snippet:

int maxCrossingSum(int arr[], int low, int mid, int high) {
    int sum = 0, left_sum = 0;
    for (int i = mid; i >= low; i--) {
        sum += arr[i];
        if (sum > left_sum) left_sum = sum;
    }
    sum = 0; int right_sum = 0;
    for (int i = mid + 1; i <= high; i++) {
        sum += arr[i];
        if (sum > right_sum) right_sum = sum;
    }
    return left_sum + right_sum;
}

medium

A. left_sum and right_sum should be initialized to INT_MIN, not 0

B. The loops should run from low to mid and mid+1 to high respectively

C. sum should not be reset to 0 before right loop

D. The function should return max(left_sum, right_sum) instead of sum

Solution

1. Step 1: Check initialization of left_sum and right_sum

   They are initialized to 0, which fails if all numbers are negative because max sum could be less than 0.

2. Step 2: Correct initialization to INT_MIN

   Initializing left_sum and right_sum to INT_MIN ensures negative sums are correctly handled.

3. Final Answer:

   left_sum and right_sum should be initialized to INT_MIN, not 0 -> Option A

4. Quick Check:

   Initialize max sums to INT_MIN to handle negatives [OK]

Hint: Use INT_MIN for max sums to handle negative values [OK]

Common Mistakes:

• Initializing max sums to zero causing wrong results
• Incorrect loop directions
• Not resetting sum before right loop

5. Given an array arr = [-1, -2, -3, -4], what will the divide and conquer maximum subarray function return?

hard

A. -10

B. -1

C. 0

D. -4

Solution

1. Step 1: Understand max subarray with all negative numbers

   When all numbers are negative, max subarray is the single largest element (least negative).

2. Step 2: Find largest element in arr

   Elements are -1, -2, -3, -4. The largest is -1.

3. Final Answer:

   -1 -> Option B

4. Quick Check:

   Max subarray in negatives = max element [OK]

Hint: Max subarray in all negatives is max single element [OK]

Common Mistakes:

• Returning sum of all elements instead of max single element
• Returning zero incorrectly assuming empty subarray
• Ignoring negative values in max calculation