Delete Columns to Make Sorted II - Practice Coding Problems

Delete Columns to Make Sorted II - Problem

You are given an array of n strings strs, where all strings have the same length. Your task is to delete columns (character positions) to make the strings appear in lexicographic order.

When you delete a column at index i, you remove the character at position i from all strings. For example, if we have strs = ["abcdef", "uvwxyz"] and delete columns {0, 2, 3}, the result is ["bef", "vyz"].

The goal is to find the minimum number of columns to delete so that the remaining strings are in lexicographic order: strs[0] ≤ strs[1] ≤ strs[2] ≤ ... ≤ strs[n-1].

Key insight: Unlike the simpler version of this problem, we need to be smart about which columns to keep. Once we establish that one string is definitively smaller than another at some position, we don't need to worry about those strings in future column checks.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We need to delete column 0. After deletion, strings become ["a","b","c"] which are in lexicographic order. Column 1 alone gives us the sorted result.

example_2.py — Multiple Deletions

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

› Output: 0

💡 Note: The strings are already in lexicographic order ["xc","yb","za"] since 'xc' < 'yb' < 'za'. No deletions needed.

example_3.py — All Deletions

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

› Output: 3

💡 Note: No matter which columns we keep, we cannot make these strings lexicographically sorted since z > w > t, y > v > s, and x > u > r. We must delete all columns, leaving empty strings which are trivially sorted.

Constraints

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

Visualization

Tap to expand

DELETEStep 3: Check Column 1abca < b < c ✓
KEEPResultabcSorted!Algorithm Walkthrough1. Initialize: cut = [false, false] (track sorted pairs)2. Column 0: 'c' > 'b' breaks order → DELETE column3. Column 1: 'a' < 'b' < 'c' maintains order → KEEP4. Update: cut = [true, true] (all pairs now sorted)Result: 1 column deleted, strings are now ["a", "b", "c"]🎯 Time: O(n×m) | Space: O(n) | Optimal Greedy Solution

Understanding the Visualization

Initialize State

Set up tracking for which adjacent string pairs are definitively sorted

Process Each Column

For each column, check if keeping it maintains lexicographic order

Make Decision

Delete columns that break order, keep safe columns

Update Tracking

Mark newly established sorted relationships for future reference

Key Takeaway

🎯 Key Insight: Track definitively sorted pairs to avoid redundant comparisons - once two strings are ordered, they stay ordered!

Asked in

G Google 42 a Amazon 38 f Facebook 25 ⊞ Microsoft 18

The optimal solution uses a greedy approach that processes columns from left to right. The key insight is maintaining a cut array that tracks which adjacent string pairs are already definitively sorted. For each column, we check if keeping it would break the lexicographic order among pairs that aren't yet sorted. If safe to keep, we update our tracking of sorted pairs. This achieves O(n×m) time complexity with O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Column-by-Column (Optimal)	O(n * m)	O(n)	Process columns left-to-right, keeping track of definitely sorted pairs
Brute Force (Try All Combinations)	O(2^m * n * m)	O(m)	Generate all possible column deletion combinations and find the minimum that works

Greedy Column-by-Column (Optimal) — Algorithm Steps

Initialize a boolean array 'cut' to track sorted adjacent pairs
For each column from left to right:
Check if keeping this column would break lexicographic order
If it breaks order, delete the column and continue
If it's safe to keep, update the 'cut' array for newly sorted pairs
Count total deleted columns

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Tracking

Create cut[] array to track definitively sorted pairs

Check Column Safety

For each column, verify it doesn't break existing order

Delete or Keep

Delete unsafe columns, keep safe ones

Update Sorted Pairs

Mark newly established sorted relationships

Code -

solution.c — C

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

int minDeletionSize(char** strs, int strsSize) {
    int m = strlen(strs[0]);
    // cut[i] = true means strs[i] < strs[i+1] is already established
    bool* cut = (bool*)calloc(strsSize - 1, sizeof(bool));
    int deleted = 0;
    
    for (int col = 0; col < m; col++) {
        // Check if keeping this column would break order
        bool shouldDelete = false;
        for (int i = 0; i < strsSize - 1; i++) {
            if (!cut[i] && strs[i][col] > strs[i + 1][col]) {
                shouldDelete = true;
                break;
            }
        }
        
        if (shouldDelete) {
            deleted++;
        } else {
            // Update cut array - mark pairs as definitively sorted
            for (int i = 0; i < strsSize - 1; i++) {
                if (strs[i][col] < strs[i + 1][col]) {
                    cut[i] = true;
                }
            }
        }
    }
    
    free(cut);
    return deleted;
}

int main() {
    char* strs[] = {"ca", "bb", "ac"};
    printf("%d\n", minDeletionSize(strs, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Process each of m columns once, checking n-1 adjacent pairs

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track which adjacent pairs are already sorted

⚡ Linearithmic 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

Greedy Column-by-Column (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler