Sorting Three Groups

Sorting Three Groups - Problem

You are given an integer array nums. Each element in nums is 1, 2 or 3.

In each operation, you can remove an element from nums. Return the minimum number of operations to make nums non-decreasing.

A non-decreasing array means that for all valid indices i, nums[i] <= nums[i+1].

Input & Output

Example 1 — Mixed Values

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

› Output: 3

💡 Note: One optimal non-decreasing subsequence is [1,2] or [1,3]. We keep 2 elements and remove 3: operations = 5 - 2 = 3

Example 2 — Already Sorted

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

› Output: 2

💡 Note: Longest non-decreasing subsequence could be [1,1,3,3] with length 4. Remove 2 elements: operations = 6 - 4 = 2

Example 3 — All Same

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

› Output: 0

💡 Note: Array is already non-decreasing (all elements equal), so no operations needed

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is 1, 2, or 3

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is to find the longest non-decreasing subsequence and remove everything else. Since values are only 1, 2, 3, we can optimize by tracking the best subsequence length ending with each value. Best approach uses optimized DP in O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Try All Subsequences

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

Generate every possible subsequence of the array, check if each one is non-decreasing, and find the longest valid subsequence. The answer is total length minus longest valid subsequence length.

Dynamic Programming - LIS Approach

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

Since we only have values 1, 2, 3, we can use dynamic programming to find the longest non-decreasing subsequence efficiently. For each position, we track the best length ending at each value.

Optimized - Count-Based DP

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

Since we only have three possible values (1, 2, 3), we can optimize by tracking the best subsequence length ending with each value. This reduces space and time complexity significantly.

Brute Force - Try All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences
For each subsequence, check if it's non-decreasing
Track the longest valid subsequence
Return n - longest_length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Create all 2^n possible subsequences using bit manipulation

Validate Each

Check if each subsequence is non-decreasing

Find Maximum

Track longest valid subsequence, return n - max_length

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsequence[20];
        int subLen = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            }
        }
        
        // Check if subsequence is non-decreasing
        int isValid = 1;
        for (int i = 1; i < subLen; i++) {
            if (subsequence[i] < subsequence[i-1]) {
                isValid = 0;
                break;
            }
        }
        
        if (isValid && subLen > maxLength) {
            maxLength = subLen;
        }
    }
    
    return numsSize - maxLength;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

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

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary subsequence storage

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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 - Try All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler