Jobs

Interviews

Discussions

Make Array Non-decreasing

Medium

Asked by:

23 views

Topics:

ArraysDynamic Programming

You are given an integer array nums. In one operation, you can select a subarray and replace it with a single element equal to its maximum value.

Return the maximum possible size of the array after performing zero or more operations such that the resulting array is non-decreasing.

Example 1:

Input: nums = [4,2,5,3,5]

Output: 3

Explanation:

One way to achieve the maximum size is:

Replace subarray nums[1..2] = [2, 5] with 5 → [4, 5, 3, 5].
Replace subarray nums[2..3] = [3, 5] with 5 → [4, 5, 5].

The final array [4, 5, 5] is non-decreasing with size 3.

Example 2:

Input: nums = [1,2,3]

Output: 3

Explanation:

No operation is needed as the array [1,2,3] is already non-decreasing.

Constraints:

1 <= nums.length <= 2 * 10⁵
1 <= nums[i] <= 2 * 10⁵

Try coding it in LeetCode

Make Array Non-decreasing

Medium

Asked by:

23 views

Topics:

ArraysDynamic Programming

You are given an integer array nums. In one operation, you can select a subarray and replace it with a single element equal to its maximum value.

Return the maximum possible size of the array after performing zero or more operations such that the resulting array is non-decreasing.

Example 1:

Input: nums = [4,2,5,3,5]

Output: 3

Explanation:

One way to achieve the maximum size is:

Replace subarray nums[1..2] = [2, 5] with 5 → [4, 5, 3, 5].
Replace subarray nums[2..3] = [3, 5] with 5 → [4, 5, 5].

The final array [4, 5, 5] is non-decreasing with size 3.

Example 2:

Input: nums = [1,2,3]

Output: 3

Explanation:

No operation is needed as the array [1,2,3] is already non-decreasing.

Constraints:

1 <= nums.length <= 2 * 10⁵
1 <= nums[i] <= 2 * 10⁵

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What is the range of values for elements within the array? Can they be negative, zero, or floating-point numbers?
What should I return if it's impossible to make the array non-decreasing with a single modification?
Is it acceptable to modify the input array directly, or should I return a new array?
If there are multiple possible modifications that result in a non-decreasing array, is there any preference for which one I should choose?
How large can the input array be?

Brute Force Solution

Approach

To make the given list of numbers non-decreasing, we can try changing each number one by one. The brute force approach involves exploring all possible modifications to see if any of them result in a non-decreasing sequence.

Here's how the algorithm would work step-by-step:

Consider the first number in the list. Try changing it to every possible value.
After changing the first number, look at the second number. Again, try changing it to every possible value.
Keep doing this for each number in the list, exploring all possible changes for each.
For every combination of changes you've made, check if the list is now non-decreasing. This means checking if each number is greater than or equal to the number before it.
If you find a combination of changes that makes the list non-decreasing, remember that solution.
After trying all possible changes, choose the solution that required the fewest changes. That's your answer.

Code Implementation

def make_array_non_decreasing_brute_force(numbers):
    best_count = float('inf')
    best_array = numbers[:] # Create a copy to avoid modifying the original

    def is_non_decreasing(array):
        for index in range(1, len(array)):
            if array[index] < array[index - 1]:
                return False
        return True

    def explore(index, current_array, change_count):
        nonlocal best_count, best_array

        # If we've reached the end of the array, check if it's non-decreasing
        if index == len(numbers):
            if is_non_decreasing(current_array):
                if change_count < best_count:
                    best_count = change_count
                    best_array = current_array[:]
            return

        original_value = numbers[index]
        
        # Try changing the number to every possible value
        for new_value in range(min(numbers) - 1, max(numbers) + 2):

            new_array = current_array[:]
            new_array[index] = new_value
            
            # Recursively explore the rest of the array
            if new_value != original_value:
                explore(index + 1, new_array, change_count + 1)
            else:
                explore(index + 1, new_array, change_count)

    # Begin exploring from the first number, making no changes initially
    explore(0, numbers[:], 0)

    return best_count

Big(O) Analysis

Time Complexity

O(infinity) – The provided brute force approach suggests trying every possible value for each number in the input array. Since there's no constraint on the range of possible values, the number of potential modifications for each element is infinite. Therefore, the algorithm explores an infinite number of combinations, leading to an infinite time complexity, which is expressed as O(infinity).

Space Complexity

O(1) – The plain English explanation describes exploring all possible modifications through iteration and comparison. It does not explicitly mention creating any auxiliary data structures like arrays, hash maps, or trees to store intermediate states or results. The algorithm appears to primarily modify the input array in place and uses variables to keep track of the current combination of changes being explored and the best solution so far, which requires constant space regardless of the input size N (the length of the input list). Therefore, the space complexity is O(1).

Optimal Solution

Approach

The key idea is to go through the sequence once, fixing any problems as soon as we find them. We focus on making only one change when a problem is found and strategically choose which element to modify to make the sequence non-decreasing with the fewest changes.

Here's how the algorithm would work step-by-step:

Go through the numbers one at a time, from the beginning to the end.
When you find a number that is smaller than the one before it, you've found a problem.
You can only fix this problem by changing either the number before it or the current number.
Decide which number to change based on the numbers surrounding the problem area. Consider the number *before* the previous number to help you make this decision.
If changing the previous number makes the sequence work, then change it so that it's equal to the current number. This resolves the immediate problem.
If changing the previous number doesn't work, then the best thing to do is change the current number to be equal to the previous number.
Continue doing this until you have gone through all the numbers, fixing issues as you encounter them.

Code Implementation

def make_array_non_decreasing(numbers):
    number_of_changes = 0
    for index in range(1, len(numbers)):
        if numbers[index] < numbers[index - 1]:
            # Found a decreasing pair, need to make a change
            if index > 1 and numbers[index] < numbers[index - 2]:
                # Changing the current number is the only option
                numbers[index] = numbers[index - 1]
                number_of_changes += 1

            else:
                # Changing the previous number is viable.
                numbers[index - 1] = numbers[index]
                number_of_changes += 1

    return number_of_changes

Big(O) Analysis

Time Complexity

O(n) – The algorithm iterates through the input array nums of size n exactly once. Inside the loop, it performs constant-time comparisons and potentially one modification of an array element. Because the loop iterates through each element of the array only once, and the operations within the loop take constant time, the time complexity is directly proportional to the size of the array.

Space Complexity

O(1) – The algorithm iterates through the input array in place, making modifications directly. It uses a constant number of variables, such as the loop counter and a counter for modifications made, regardless of the input array's size (N). No auxiliary data structures like lists or maps are created, so the additional space required remains constant. Therefore, the space complexity is O(1).

Edge Cases

Case	How to Handle
Null or empty input array	Return 0 or an appropriate error code/exception since no modifications are possible on an empty array.
Array with only one element	The array is already non-decreasing, so return 0 as no moves are needed.
Array already non-decreasing	The optimal solution should identify this case and return 0 without unnecessary modifications.
Array in strictly decreasing order	This represents the worst-case scenario, requiring maximum modifications to achieve a non-decreasing order.
Array with all elements equal	The array is already non-decreasing, so return 0 in this scenario.
Large array (e.g., approaching memory limits)	Ensure the algorithm uses memory efficiently and avoids unnecessary data copying or large intermediate data structures.
Array with very large or very small numbers (potential integer overflow)	Consider using larger data types like long or handling potential overflow situations to prevent incorrect comparisons or calculations.
Input array contains duplicate adjacent values	The solution must handle these duplicates gracefully, not misidentifying them as violations of the non-decreasing property.

Null or empty input array

How to Handle:

Return 0 or an appropriate error code/exception since no modifications are possible on an empty array.

Array with only one element

How to Handle:

The array is already non-decreasing, so return 0 as no moves are needed.

Array already non-decreasing

How to Handle:

The optimal solution should identify this case and return 0 without unnecessary modifications.

Array in strictly decreasing order

How to Handle:

This represents the worst-case scenario, requiring maximum modifications to achieve a non-decreasing order.

Array with all elements equal

How to Handle:

The array is already non-decreasing, so return 0 in this scenario.

Large array (e.g., approaching memory limits)

How to Handle:

Ensure the algorithm uses memory efficiently and avoids unnecessary data copying or large intermediate data structures.

Array with very large or very small numbers (potential integer overflow)

How to Handle:

Consider using larger data types like long or handling potential overflow situations to prevent incorrect comparisons or calculations.

Input array contains duplicate adjacent values

How to Handle:

The solution must handle these duplicates gracefully, not misidentifying them as violations of the non-decreasing property.

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What is the range of values for elements within the array? Can they be negative, zero, or floating-point numbers?
What should I return if it's impossible to make the array non-decreasing with a single modification?
Is it acceptable to modify the input array directly, or should I return a new array?
If there are multiple possible modifications that result in a non-decreasing array, is there any preference for which one I should choose?
How large can the input array be?

Brute Force Solution

Approach

Here's how the algorithm would work step-by-step:

Consider the first number in the list. Try changing it to every possible value.
After changing the first number, look at the second number. Again, try changing it to every possible value.
Keep doing this for each number in the list, exploring all possible changes for each.
For every combination of changes you've made, check if the list is now non-decreasing. This means checking if each number is greater than or equal to the number before it.
If you find a combination of changes that makes the list non-decreasing, remember that solution.
After trying all possible changes, choose the solution that required the fewest changes. That's your answer.

Code Implementation

def make_array_non_decreasing_brute_force(numbers):
    best_count = float('inf')
    best_array = numbers[:] # Create a copy to avoid modifying the original

    def is_non_decreasing(array):
        for index in range(1, len(array)):
            if array[index] < array[index - 1]:
                return False
        return True

    def explore(index, current_array, change_count):
        nonlocal best_count, best_array

        # If we've reached the end of the array, check if it's non-decreasing
        if index == len(numbers):
            if is_non_decreasing(current_array):
                if change_count < best_count:
                    best_count = change_count
                    best_array = current_array[:]
            return

        original_value = numbers[index]
        
        # Try changing the number to every possible value
        for new_value in range(min(numbers) - 1, max(numbers) + 2):

            new_array = current_array[:]
            new_array[index] = new_value
            
            # Recursively explore the rest of the array
            if new_value != original_value:
                explore(index + 1, new_array, change_count + 1)
            else:
                explore(index + 1, new_array, change_count)

    # Begin exploring from the first number, making no changes initially
    explore(0, numbers[:], 0)

    return best_count

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

Go through the numbers one at a time, from the beginning to the end.
When you find a number that is smaller than the one before it, you've found a problem.
You can only fix this problem by changing either the number before it or the current number.
Decide which number to change based on the numbers surrounding the problem area. Consider the number *before* the previous number to help you make this decision.
If changing the previous number makes the sequence work, then change it so that it's equal to the current number. This resolves the immediate problem.
If changing the previous number doesn't work, then the best thing to do is change the current number to be equal to the previous number.
Continue doing this until you have gone through all the numbers, fixing issues as you encounter them.

Code Implementation

def make_array_non_decreasing(numbers):
    number_of_changes = 0
    for index in range(1, len(numbers)):
        if numbers[index] < numbers[index - 1]:
            # Found a decreasing pair, need to make a change
            if index > 1 and numbers[index] < numbers[index - 2]:
                # Changing the current number is the only option
                numbers[index] = numbers[index - 1]
                number_of_changes += 1

            else:
                # Changing the previous number is viable.
                numbers[index - 1] = numbers[index]
                number_of_changes += 1

    return number_of_changes

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
Null or empty input array	Return 0 or an appropriate error code/exception since no modifications are possible on an empty array.
Array with only one element	The array is already non-decreasing, so return 0 as no moves are needed.
Array already non-decreasing	The optimal solution should identify this case and return 0 without unnecessary modifications.
Array in strictly decreasing order	This represents the worst-case scenario, requiring maximum modifications to achieve a non-decreasing order.
Array with all elements equal	The array is already non-decreasing, so return 0 in this scenario.
Large array (e.g., approaching memory limits)	Ensure the algorithm uses memory efficiently and avoids unnecessary data copying or large intermediate data structures.
Array with very large or very small numbers (potential integer overflow)	Consider using larger data types like long or handling potential overflow situations to prevent incorrect comparisons or calculations.
Input array contains duplicate adjacent values	The solution must handle these duplicates gracefully, not misidentifying them as violations of the non-decreasing property.

Null or empty input array

How to Handle:

Return 0 or an appropriate error code/exception since no modifications are possible on an empty array.

Array with only one element

How to Handle:

The array is already non-decreasing, so return 0 as no moves are needed.

Array already non-decreasing

How to Handle:

The optimal solution should identify this case and return 0 without unnecessary modifications.

Array in strictly decreasing order

How to Handle:

This represents the worst-case scenario, requiring maximum modifications to achieve a non-decreasing order.

Array with all elements equal

How to Handle:

The array is already non-decreasing, so return 0 in this scenario.

Large array (e.g., approaching memory limits)

How to Handle:

Ensure the algorithm uses memory efficiently and avoids unnecessary data copying or large intermediate data structures.

Array with very large or very small numbers (potential integer overflow)

How to Handle:

Consider using larger data types like long or handling potential overflow situations to prevent incorrect comparisons or calculations.

Input array contains duplicate adjacent values

How to Handle:

The solution must handle these duplicates gracefully, not misidentifying them as violations of the non-decreasing property.