Non-decreasing Subsequences - Practice Coding Problems

Non-decreasing Subsequences - Problem

Given an integer array nums, your task is to find all unique non-decreasing subsequences that contain at least two elements. A subsequence is a sequence that can be derived from the original array by deleting some or no elements without changing the order of the remaining elements.

For example, in array [4, 6, 7, 7], valid subsequences include [4, 6], [4, 7], [6, 7], [6, 7, 7], [4, 6, 7], and many more. However, [7, 4] would not be valid since it's decreasing.

Key Points:

Subsequences must be non-decreasing (each element ≥ previous element)
Must contain at least 2 elements
Return all unique subsequences (no duplicates)
Order of results doesn't matter

Input & Output

example_1.py — Basic case

$ Input: [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,6,7] appears only once even though there are two 7s, because we want unique subsequences.

example_2.py — Simple case

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

› Output: [[4,4]]

💡 Note: Only [4,4] forms a valid non-decreasing subsequence with at least 2 elements. Other combinations would be decreasing.

example_3.py — Edge case

$ Input: [1, 2, 3]

› Output: [[1,2],[1,2,3],[1,3],[2,3]]

💡 Note: All elements are in ascending order, so we get all possible combinations of length 2 or more.

Constraints

1 ≤ nums.length ≤ 15
-100 ≤ nums[i] ≤ 100
The number of unique subsequences will not exceed 2¹⁵
Order of result doesn't matter

Visualization

Tap to expand

Understanding the Visualization

Start Building

Begin with empty subsequence, consider each element

Local Check

At each level, use set to track tried values

Add & Recurse

Include element if valid and not tried at this level

Collect Results

Save subsequences with length ≥ 2

Key Takeaway

🎯 Key Insight: Use local sets at each recursion level to prevent duplicate subsequences from being generated, eliminating the need for expensive global deduplication.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses backtracking with level-wise deduplication. Instead of generating all subsequences and filtering, we build valid ones incrementally. The key insight is using a local hash set at each recursion level to avoid processing duplicate values, eliminating the need for global deduplication. Time complexity is O(2^n) in worst case, but much better in practice due to pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n × n)	O(2^n × n)	Generate all possible subsequences, then filter valid ones
Backtracking with Global Deduplication	O(2^n)	O(2^n × n)	Use backtracking to generate subsequences with global set for deduplication

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences (2^n total)
For each subsequence, check if it's non-decreasing
Filter subsequences with at least 2 elements
Use set to remove duplicates
Convert result to list format

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate mask

Use binary representation to select elements

Build subsequence

Extract elements based on mask bits

Validate

Check if non-decreasing and length >= 2

Store unique

Add to result set if valid

Code -

solution.c — C

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

int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    int maxResults = 1 << numsSize;
    int** result = malloc(maxResults * sizeof(int*));
    *returnColumnSizes = malloc(maxResults * sizeof(int));
    
    // Generate all possible subsequences
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subseq[20];
        int subseqSize = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subseq[subseqSize++] = nums[i];
            }
        }
        
        // Check if subsequence is valid
        if (subseqSize >= 2) {
            int valid = 1;
            for (int i = 1; i < subseqSize; i++) {
                if (subseq[i] < subseq[i-1]) {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                // Check for duplicates (simple approach)
                int duplicate = 0;
                for (int j = 0; j < *returnSize; j++) {
                    if ((*returnColumnSizes)[j] == subseqSize) {
                        int same = 1;
                        for (int k = 0; k < subseqSize; k++) {
                            if (result[j][k] != subseq[k]) {
                                same = 0;
                                break;
                            }
                        }
                        if (same) {
                            duplicate = 1;
                            break;
                        }
                    }
                }
                
                if (!duplicate) {
                    result[*returnSize] = malloc(subseqSize * sizeof(int));
                    for (int i = 0; i < subseqSize; i++) {
                        result[*returnSize][i] = subseq[i];
                    }
                    (*returnColumnSizes)[*returnSize] = subseqSize;
                    (*returnSize)++;
                }
            }
        }
    }
    
    return result;
}

int main() {
    int nums[] = {4, 6, 7, 7};
    int numsSize = 4;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = findSubsequences(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 × n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(2^n × n)

Storing all possible subsequences, each of average length n/2

⚠ Quadratic Space

89.5K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler