Divide Array Into Increasing Sequences

Divide Array Into Increasing Sequences - Problem

Array Counting Hard

Given an integer array nums sorted in non-decreasing order and an integer k, return true if this array can be divided into one or more disjoint increasing subsequences of length at least k, or false otherwise.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements. Two subsequences are disjoint if they do not share any elements.

An increasing subsequence means each element is strictly greater than the previous one.

Input & Output

Example 1 — Valid Partition

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

› Output: true

💡 Note: We can form one increasing subsequence [1,2,3,4,5] of length 5 ≥ 3 by using elements at positions [0,1,2,4,5], leaving the duplicate 3 unused.

Example 2 — Too Small Array

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

› Output: false

💡 Note: Array length is 2, but we need subsequences of length at least 3, so it's impossible.

Example 3 — Frequency Too High

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

› Output: false

💡 Note: Number 1 appears 3 times, but with k=2, we can have at most ⌈4/2⌉ = 2 occurrences of any number.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
nums is sorted in non-decreasing order
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that if any number appears more than ⌈n/k⌉ times, partitioning is impossible. Best approach uses frequency counting with greedy validation. Time: O(n), Space: O(n)

Common Approaches

✓ Heap

⏱️ Time: N/A Space: N/A

Sort First

⏱️ Time: N/A Space: N/A

Brute Force Backtracking

⏱️ Time: O(2^n) Space: O(n)

Generate all possible partitions of the array and check if each partition can form valid increasing subsequences of length at least k. Use backtracking to explore all combinations.

Frequency Count with Validation

⏱️ Time: O(n) Space: O(n)

Count frequency of each element. If any element appears more than n/k times, it's impossible since we need at least k elements per subsequence. Then use greedy approach to verify feasibility.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Min-heap implementation would be complex in C
// Simplified version using array sorting

int compare(const void* a, const void* b) {
    int* ia = *(int**)a;
    int* ib = *(int**)b;
    return ia[0] - ib[0];
}

int** solution(int*** schedule, int* scheduleSizes, int** scheduleColSizes, int scheduleSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (scheduleSize == 0) {
        return NULL;
    }
    
    // Collect all intervals
    int totalIntervals = 0;
    for (int i = 0; i < scheduleSize; i++) {
        totalIntervals += scheduleSizes[i];
    }
    
    int** intervals = (int**)malloc(totalIntervals * sizeof(int*));
    int idx = 0;
    
    for (int i = 0; i < scheduleSize; i++) {
        for (int j = 0; j < scheduleSizes[i]; j++) {
            intervals[idx] = (int*)malloc(2 * sizeof(int));
            intervals[idx][0] = schedule[i][j][0];
            intervals[idx][1] = schedule[i][j][1];
            idx++;
        }
    }
    
    // Sort intervals
    qsort(intervals, totalIntervals, sizeof(int*), compare);
    
    // Process intervals to find gaps
    int** result = (int**)malloc(totalIntervals * sizeof(int*));
    *returnColumnSizes = (int*)malloc(totalIntervals * sizeof(int));
    
    int currentEnd = intervals[0][1];
    int resultCount = 0;
    
    for (int i = 1; i < totalIntervals; i++) {
        if (intervals[i][0] > currentEnd) {
            result[resultCount] = (int*)malloc(2 * sizeof(int));
            result[resultCount][0] = currentEnd;
            result[resultCount][1] = intervals[i][0];
            (*returnColumnSizes)[resultCount] = 2;
            resultCount++;
            currentEnd = intervals[i][1];
        } else {
            if (intervals[i][1] > currentEnd) {
                currentEnd = intervals[i][1];
            }
        }
    }
    
    *returnSize = resultCount;
    
    // Clean up
    for (int i = 0; i < totalIntervals; i++) {
        free(intervals[i]);
    }
    free(intervals);
    
    return result;
}

int parseArray(const char* input, int*** result, int** sizes, int*** colSizes) {
    // Simple hardcoded parser for test cases
    if (strstr(input, "[[[1,3],[6,10]],[[2,4],[9,12]]]")) {
        *result = (int***)malloc(2 * sizeof(int**));
        *sizes = (int*)malloc(2 * sizeof(int));
        *colSizes = (int**)malloc(2 * sizeof(int*));
        
        (*result)[0] = (int**)malloc(2 * sizeof(int*));
        (*result)[0][0] = (int*)malloc(2 * sizeof(int));
        (*result)[0][0][0] = 1; (*result)[0][0][1] = 3;
        (*result)[0][1] = (int*)malloc(2 * sizeof(int));
        (*result)[0][1][0] = 6; (*result)[0][1][1] = 10;
        (*sizes)[0] = 2;
        (*colSizes)[0] = (int*)malloc(2 * sizeof(int));
        (*colSizes)[0][0] = 2; (*colSizes)[0][1] = 2;
        
        (*result)[1] = (int**)malloc(2 * sizeof(int*));
        (*result)[1][0] = (int*)malloc(2 * sizeof(int));
        (*result)[1][0][0] = 2; (*result)[1][0][1] = 4;
        (*result)[1][1] = (int*)malloc(2 * sizeof(int));
        (*result)[1][1][0] = 9; (*result)[1][1][1] = 12;
        (*sizes)[1] = 2;
        (*colSizes)[1] = (int*)malloc(2 * sizeof(int));
        (*colSizes)[1][0] = 2; (*colSizes)[1][1] = 2;
        
        return 2;
    }
    return 0;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int*** schedule;
    int* sizes;
    int** colSizes;
    int scheduleSize = parseArray(input, &schedule, &sizes, &colSizes);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(schedule, sizes, colSizes, scheduleSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

15.6K Views

Medium Frequency

~25 min Avg. Time

423 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