Non-decreasing Subsequences - Practice Coding Problems

Non-decreasing Subsequences - Problem

Given an integer array nums, return all the different possible non-decreasing subsequences of the given array with at least two elements. You may return the answer in any order.

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.

Note that the solution set must not contain duplicate subsequences.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,6,7,7]

› Output: [[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

💡 Note: All possible non-decreasing subsequences with at least 2 elements. Note that [4,7,7] and [6,7,7] are different subsequences even though they contain the same values because they use different indices.

Example 2 — Minimum Size

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

› Output: [[4,4]]

💡 Note: Only [4,4] forms a valid non-decreasing subsequence with at least 2 elements. All other pairs are decreasing.

Example 3 — All Same Values

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

› Output: [[1,1],[1,1,1]]

💡 Note: We can form [1,1] (using any two 1s) and [1,1,1] (using all three 1s). Note that duplicate subsequences are eliminated.

Constraints

1 ≤ nums.length ≤ 15
-100 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array [4,6,7,7] with repeated values

Find Subsequences

Extract all non-decreasing subsequences with length ≥ 2

Result

All valid subsequences without duplicates

Key Takeaway

🎯 Key Insight: Use backtracking to explore all possibilities while preventing duplicates with a set at each recursion level

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The optimal approach uses backtracking to build non-decreasing subsequences while preventing duplicates by tracking used values at each recursion level. Key insight: Use a set to avoid processing the same value multiple times at the same recursion depth. Best approach: Backtracking. Time: O(2^n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Duplicate Prevention	O(2^n)	O(n)	Build subsequences recursively while preventing duplicates at each level
Brute Force - Generate All Combinations	O(2^n × n)	O(2^n × n)	Generate all possible subsequences and filter non-decreasing ones

Backtracking with Duplicate Prevention — Algorithm Steps

Start backtracking from each position in array
At each step, try adding elements that are ≥ current last element
Use set to prevent duplicate values at same recursion level
Add valid subsequences with length ≥ 2 to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Element

Pick an element that maintains non-decreasing order

Recurse

Build subsequence by adding more valid elements

Backtrack

Try other possibilities by removing last element

Code -

solution.c — C

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

int** globalResult;
int* globalColumnSizes;
int globalReturnSize;
int globalCapacity = 1000;

void backtrack(int* nums, int numsSize, int start, int* path, int pathSize) {
    if (pathSize >= 2) {
        if (globalReturnSize >= globalCapacity) {
            globalCapacity *= 2;
            globalResult = realloc(globalResult, globalCapacity * sizeof(int*));
            globalColumnSizes = realloc(globalColumnSizes, globalCapacity * sizeof(int));
        }
        
        globalResult[globalReturnSize] = malloc(pathSize * sizeof(int));
        for (int i = 0; i < pathSize; i++) {
            globalResult[globalReturnSize][i] = path[i];
        }
        globalColumnSizes[globalReturnSize] = pathSize;
        globalReturnSize++;
    }
    
    int used[1000] = {0}; // Assuming values fit in reasonable range
    for (int i = start; i < numsSize; i++) {
        // Simple duplicate check (assuming reasonable range)
        int val = nums[i] + 500; // Offset for negative numbers
        if (val >= 0 && val < 1000 && used[val]) {
            continue;
        }
        
        // Only add if it maintains non-decreasing order
        if (pathSize == 0 || nums[i] >= path[pathSize - 1]) {
            if (val >= 0 && val < 1000) used[val] = 1;
            path[pathSize] = nums[i];
            backtrack(nums, numsSize, i + 1, path, pathSize + 1);
        }
    }
}

int** solution(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    globalResult = malloc(globalCapacity * sizeof(int*));
    globalColumnSizes = malloc(globalCapacity * sizeof(int));
    globalReturnSize = 0;
    
    int path[20];
    backtrack(nums, numsSize, 0, path, 0);
    
    *returnSize = globalReturnSize;
    *returnColumnSizes = globalColumnSizes;
    return globalResult;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each element can be included or excluded, with pruning for duplicates

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth and temporary subsequence storage

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Duplicate Prevention — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler