Delete Columns to Make Sorted II

Delete Columns to Make Sorted II - Problem

You are given an array of n strings strs, all of the same length.

We may choose any deletion indices, and we delete all the characters in those indices for each string.

For example, if we have strs = ["abcdef","uvwxyz"] and deletion indices {0, 2, 3}, then the final array after deletions is ["bef", "vyz"].

Suppose we chose a set of deletion indices answer such that after deletions, the final array has its elements in lexicographic order (i.e., strs[0] <= strs[1] <= strs[2] <= ... <= strs[n - 1]).

Return the minimum possible value of answer.length.

Input & Output

Example 1 — Basic Case

$ Input: strs = ["ca", "bb", "ac"]

› Output: 1

💡 Note: Delete column 0: "ca"→"a", "bb"→"b", "ac"→"c". Result ["a","b","c"] is sorted. Only 1 deletion needed.

Example 2 — No Deletions Needed

$ Input: strs = ["xc", "yb", "za"]

› Output: 0

💡 Note: Already lexicographically sorted: "xc" <= "yb" <= "za". No deletions needed.

Example 3 — Multiple Deletions

$ Input: strs = ["zyx", "wvu", "tsr"]

› Output: 3

💡 Note: Must delete all columns since each column is in reverse order. After deleting all, get ["","",""] which is sorted.

Constraints

1 ≤ strs.length ≤ 100
1 ≤ strs[i].length ≤ 100
strs[i] consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12

The key insight is that once two strings are lexicographically separated by a column, their relative order is fixed. Best approach uses greedy column-by-column processing with pair tracking. Time: O(mn), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible subsets of column indices to delete, check if remaining columns maintain lexicographic order, return minimum deletions needed.

Greedy Column-by-Column

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

Iterate through columns from left to right. For each column, check if keeping it maintains lexicographic order. If not, delete it. Use a tracking array to know which string pairs are already properly ordered.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^m possible deletion combinations
For each combination, check if remaining strings are lexicographically sorted
Track minimum deletions that work

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Masks

Create all 2^m possible deletion combinations

Check Each Combination

For each mask, delete columns and verify lexicographic order

Find Minimum

Track the combination with minimum deletions

Code -

solution.c — C

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

int solution(char strs[][101], int n, int m) {
    if (n == 0 || m == 0) return 0;
    
    int minDeletions = m;
    
    // Try all possible deletion combinations
    for (int mask = 0; mask < (1 << m); mask++) {
        // Build remaining strings after deletions
        char remaining[n][101];
        for (int i = 0; i < n; i++) {
            int pos = 0;
            for (int j = 0; j < m; j++) {
                if (!(mask & (1 << j))) {  // Column j not deleted
                    remaining[i][pos++] = strs[i][j];
                }
            }
            remaining[i][pos] = '\0';
        }
        
        // Check if lexicographically sorted
        int isSorted = 1;
        for (int i = 1; i < n; i++) {
            if (strcmp(remaining[i-1], remaining[i]) > 0) {
                isSorted = 0;
                break;
            }
        }
        
        if (isSorted) {
            int deletions = __builtin_popcount(mask);
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
    }
    
    return minDeletions;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    char strs[100][101];
    int n = 0, m = 0;
    char *ptr = strchr(line, '"');
    while (ptr) {
        ptr++;
        char *end = strchr(ptr, '"');
        if (!end) break;
        strncpy(strs[n], ptr, end - ptr);
        strs[n][end - ptr] = '\0';
        if (m == 0) m = strlen(strs[n]);
        n++;
        ptr = strchr(end + 1, '"');
    }
    
    printf("%d\n", solution(strs, n, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m × n × m)

2^m combinations, each requiring O(n×m) to check lexicographic order

✓ Linear Growth

Space Complexity

O(m)

Space to store current deletion set and string comparisons

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler