Count Non-Decreasing Subarrays After K Operations

Count Non-Decreasing Subarrays After K Operations - Problem

Array Stack Segment Tree Queue Sliding Window Monotonic Stack Monotonic Queue Hard

You're given an array nums of n integers and an integer k representing the maximum number of operations allowed.

Your goal: Count how many subarrays can be made non-decreasing using at most k operations.

Operations: For each subarray, you can increment any element by 1 up to k times total. Each subarray is considered independently - changes don't carry over.

Non-decreasing: An array where each element is greater than or equal to the previous element (e.g., [1, 2, 2, 5]).

Example: Given nums = [2, 1, 3] and k = 1, the subarray [2, 1] can become [2, 2] with 1 operation, making it non-decreasing.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 1, 3], k = 1

› Output: 5

💡 Note: Subarrays that can be made non-decreasing: [2] (0 ops), [1] (0 ops), [3] (0 ops), [2,1] (1 op to make [2,2]), [1,3] (0 ops). Total: 5 subarrays.

example_2.py — No Operations Needed

$ Input: nums = [1, 2, 3], k = 0

› Output: 6

💡 Note: Array is already non-decreasing, so all 6 possible subarrays ([1], [2], [3], [1,2], [2,3], [1,2,3]) require 0 operations.

example_3.py — Edge Case Single Element

$ Input: nums = [5], k = 2

› Output: 1

💡 Note: Only one subarray [5] exists and it's already non-decreasing with 0 operations needed.

Visualization

Tap to expand

Understanding the Visualization

Identify Subarray

Consider a contiguous portion of the array as a potential staircase

Calculate Operations

For each element, determine how many 'bricks' (increment operations) needed to reach the running maximum height

Check Feasibility

If total bricks needed ≤ k, this staircase can be built successfully

Key Takeaway

🎯 Key Insight: For each subarray, we maintain a running maximum and count operations needed to lift smaller elements to that height. The challenge is doing this efficiently for all O(n²) possible subarrays.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays × O(n) to check each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
Each subarray is considered independently

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires counting subarrays that can be made non-decreasing with at most k operations. The key insight is that for each subarray, we need to calculate the minimum operations by ensuring each element is at least as large as the running maximum. The brute force approach checks all O(n²) subarrays in O(n³) time, while optimized solutions can use sliding window techniques with early termination for better practical performance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and calculate operations needed
Sliding Window with Binary Search Optimization	O(n² log n)	O(n)	Use sliding window technique with binary search for efficient range maximum queries

Brute Force (Check All Subarrays) — Algorithm Steps

Generate all possible subarrays using nested loops
For each subarray, calculate minimum operations needed
Track running maximum and sum operations needed
Count subarrays where operations ≤ k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarray

Start with subarray [i,j] and track maximum element

Calculate Operations

For each element, add operations needed to reach current maximum

Check Validity

If total operations ≤ k, count this subarray

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int countSubarrays(int* nums, int n, int k) {
    int count = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            long long operations = 0;
            int maxSoFar = nums[i];
            int valid = 1;
            
            // Calculate operations needed for subarray [i, j]
            for (int idx = i; idx <= j; idx++) {
                if (nums[idx] < maxSoFar) {
                    operations += maxSoFar - nums[idx];
                    if (operations > k) {
                        valid = 0;
                        break;
                    }
                } else {
                    maxSoFar = nums[idx];
                }
            }
            
            if (valid) count++;
        }
    }
    
    return count;
}

int main() {
    // Simple input parsing
    int nums[1000];
    int n = 0, k;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse nums array and k
    char* token = strtok(line, "[,]:{}\"");
    while (token != NULL) {
        if (strcmp(token, "nums") == 0) {
            token = strtok(NULL, "[,]:{}\"");
            while (token != NULL && strcmp(token, "k") != 0) {
                nums[n++] = atoi(token);
                token = strtok(NULL, "[,]:{}\"");
            }
        }
        if (token != NULL && strcmp(token, "k") == 0) {
            token = strtok(NULL, "[,]:{}\"");
            k = atoi(token);
            break;
        }
        if (token != NULL) token = strtok(NULL, "[,]:{}\"");
    }
    
    printf("%d\n", countSubarrays(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays × O(n) to check each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
Each subarray is considered independently

26.1K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler