Binary Search on Answer Technique in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Binary Search on Answer Technique?

It is a method to find an unknown value by guessing an answer range and using binary search to narrow down the correct answer based on a condition check.

beginner

In Binary Search on Answer, what does the 'check' function do?

The 'check' function tests if a guessed answer meets the problem's conditions, helping decide whether to search higher or lower.

intermediate

Why do we use Binary Search on Answer instead of normal binary search on arrays?

Because sometimes the answer is not directly in a list but lies within a range of values, and we can test guesses with a condition instead of searching a list.

beginner

What is a common real-life example to understand Binary Search on Answer?

Finding the minimum time to complete tasks when you can check if a given time is enough to finish all tasks.

beginner

What are the key steps to implement Binary Search on Answer?

1. Define the search range (low and high). 2. Guess the middle value. 3. Use a check function to test the guess. 4. Adjust the range based on the check result. 5. Repeat until the answer is found.

What does the 'check' function in Binary Search on Answer return?

A True if the guessed answer satisfies the problem condition

B The exact answer value

C The middle index of the array

D The maximum value in the range

The check function returns true if the guessed answer meets the problem's condition, guiding the binary search direction.

When using Binary Search on Answer, what do you do if the check function returns false?

A Return the current guess as answer

B Search in the lower half of the range

C Stop the search immediately

D Search in the higher half of the range

If the check returns false, it means the guess is too low, so we search in the higher half.

Binary Search on Answer is useful when:

A You need to find duplicates in a list

B The answer is a value within a range, not an element in a list

C You want to sort an array

D You have a sorted array to search

This technique is for searching an answer in a range by testing guesses, not searching a sorted list.

What is the first step in Binary Search on Answer?

A Sort the input array

B Write the check function

C Define the low and high bounds of the search range

D Print the answer

You start by defining the search range where the answer lies.

Which of these problems is a good candidate for Binary Search on Answer?

A Finding minimum maximum load to ship packages within D days

B Finding the maximum element in an unsorted array

C Sorting a list of numbers

D Counting the number of elements in an array

This problem involves guessing a load capacity and checking feasibility, perfect for Binary Search on Answer.

Explain the Binary Search on Answer Technique and how it differs from normal binary search.

Think about searching for a value by testing conditions, not by looking for an element in a list.

Describe the steps to implement Binary Search on Answer with an example scenario.

Walk through the process as if you are finding the minimum time to finish tasks.

Practice

1. What is the main idea behind the Binary Search on Answer technique?

easy

A. We sort the input array and then perform a binary search on the sorted array.

B. We guess an answer and check if it satisfies the problem, then adjust the guess using binary search.

C. We use binary search to find the maximum element in an unsorted array.

D. We apply binary search to find the first occurrence of a target value in a list.

Solution

1. Step 1: Understand the technique

   Binary Search on Answer guesses a possible solution and verifies if it meets the problem's conditions. If valid, adjust the guess (smaller/larger) using binary search to find the optimal answer.

2. Final Answer:

   We guess an answer and check if it satisfies the problem, then adjust the guess using binary search. -> Option B

3. Quick Check:

   Guess and verify with binary search = B [OK]

Hint: Guess answer, check condition, adjust guess with binary search [OK]

Common Mistakes:

• Confusing binary search on answer with normal binary search on array
• Thinking it only works on sorted arrays
• Not verifying the guessed answer properly

2. Which of the following is the correct C# syntax to start a binary search on answer between low and high?

easy

A. do { int mid = (low - high) / 2; } while (low < high);

B. for (int mid = low; mid <= high; mid++) { }

C. if (low < high) { int mid = low + high; }

D. while (low <= high) { int mid = (low + high) / 2; }

Solution

1. Step 1: Identify correct loop and mid calculation

   The binary search loop uses while (low <= high) and mid = (low + high) / 2 with integer division.

2. Final Answer:

   while (low <= high) { int mid = (low + high) / 2; } -> Option D

3. Quick Check:

   Correct binary search loop syntax = A [OK]

Hint: Use while(low <= high) and mid = (low + high) / 2 [OK]

Common Mistakes:

• Using for loop instead of while
• Incorrect mid calculation like (low - high)/2
• Using if instead of loop

3. Consider the following C# code snippet using binary search on answer to find minimum maximum load:

int low = 10, high = 50;
while (low <= high) {
  int mid = (low + high) / 2;
  if (IsPossible(mid))
    high = mid - 1;
  else
    low = mid + 1;
}
Console.WriteLine(low);

If IsPossible(30) returns true and IsPossible(20) returns false, what will be printed?

medium

A. 10

B. 30

C. 21

D. 20

Solution

1. Step 1: Trace binary search behavior

   IsPossible(mid) true means valid (try smaller, high=mid-1); false means invalid (low=mid+1). Given IsPossible(30)=true, IsPossible(20)=false, assuming monotonicity the search converges to smallest valid at 21.

2. Final Answer:

   21 -> Option C

3. Quick Check:

   Minimum valid answer after binary search = 21 [OK]

Hint: Answer is lowest valid mid after binary search ends [OK]

Common Mistakes:

• Printing high instead of low after loop
• Confusing true/false meaning of IsPossible
• Not updating low and high correctly

4. The following code tries to find the minimum maximum load using binary search on answer. What is the bug?

int low = 0, high = maxLoad;
while (low < high) {
  int mid = (low + high) / 2;
  if (IsPossible(mid))
    low = mid;
  else
    high = mid - 1;
}
Console.WriteLine(low);

medium

A. When IsPossible(mid) is true, 'low' should be set to 'mid + 1' instead of 'mid'.

B. When IsPossible(mid) is true, 'high' should be set to 'mid - 1' instead of 'low'.

C. The condition should be 'while (low <= high)' instead of 'while (low < high)'.

D. The mid calculation should be 'mid = low + (high - low) / 2' to avoid overflow.

Solution

1. Step 1: Identify incorrect update causing infinite loop

   When IsPossible(mid) true, low = mid risks no progress (infinite loop if low == mid); should set low = mid + 1 to advance.

2. Final Answer:

   When IsPossible(mid) is true, 'low' should be set to 'mid + 1' instead of 'mid'. -> Option A

3. Quick Check:

   Increment low by 1 to avoid infinite loop [OK]

Hint: Increment low by 1 when condition true to avoid infinite loop [OK]

Common Mistakes:

• Not incrementing low causing infinite loop
• Confusing when to move low or high
• Ignoring loop condition correctness

5. You want to split an array of weights into k contiguous subarrays so that the maximum sum among these subarrays is minimized. Which approach correctly uses binary search on answer to solve this?

hard

A. Binary search between max weight and sum of all weights; check if array can be split into ≤ k parts with max sum ≤ mid.

B. Sort the array and binary search for the kth largest weight.

C. Use binary search on the array indices to find the split points directly.

D. Apply binary search on the number of subarrays from 1 to k.

Solution

1. Step 1: Define search space and feasibility check

   Binary search from max weight (min possible max sum) to total sum; for mid, check if can split into ≤ k contiguous subarrays each with sum ≤ mid. If yes, try smaller mid; else larger.

2. Final Answer:

   Binary search between max weight and sum of all weights; check if array can be split into ≤ k parts with max sum ≤ mid. -> Option A

3. Quick Check:

   Search answer range and verify splits ≤ k [OK]

Hint: Search between max element and total sum, check splits ≤ k [OK]

Common Mistakes:

• Binary searching on indices instead of answer range
• Not checking contiguous subarray sums properly
• Sorting array unnecessarily