Delete Columns to Make Sorted III - Practice Coding Problems

Delete Columns to Make Sorted III - Problem

You are given an array of n strings strs, all of the same length. Your goal is to find the minimum number of columns to delete so that after deletion, every remaining string is lexicographically sorted.

What does this mean? When we delete columns at certain indices, we remove those characters from all strings. The resulting strings must have their characters in non-decreasing order (sorted alphabetically).

Example: If we have strs = ["abcdef", "uvwxyz"] and delete columns at indices {0, 2, 3}, we get ["bef", "vyz"]. Both strings are now sorted: b ≤ e ≤ f and v ≤ y ≤ z.

The challenge: Find the minimum number of columns to delete to achieve this for all strings simultaneously.

Input & Output

example_1.py — Basic Case

$ Input: strs = ["babca", "bbazb"]

› Output: 3

💡 Note: After deleting columns 0, 1, and 4, the remaining strings are ["bc", "az"] where both are sorted: b ≤ c and a ≤ z. This is the minimum number of deletions needed.

example_2.py — Already Sorted

$ Input: strs = ["eddbca", "gfhkba"]

› Output: 4

💡 Note: We need to delete 4 columns to make both strings sorted. One optimal solution is to keep columns that form ["dd", "gf"] after appropriate deletions.

example_3.py — Single Character

$ Input: strs = ["ghi", "def", "abc"]

› Output: 0

💡 Note: Each string is already sorted individually (single characters are trivially sorted), so no deletions are needed.

Constraints

1 ≤ strs.length ≤ 100
1 ≤ strs[i].length ≤ 100
strs[i] consists of lowercase English letters
All strings have the same length

Visualization

Tap to expand

Understanding the Visualization

Analyze Columns

Examine each column to see which ones can form valid increasing sequences

Build DP Table

For each column, find the longest valid sequence ending at that position

Find Maximum Keep

Identify the longest subsequence of columns that maintains sorting for all rows

Calculate Deletions

Subtract the maximum keepable columns from total columns

Key Takeaway

🎯 Key Insight: Transform the "minimum deletions" problem into finding the "maximum columns to keep" using dynamic programming - this avoids exponential search and gives us the optimal O(m²n) solution.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

This problem is solved optimally using Dynamic Programming to find the longest increasing subsequence of columns that can be kept. Instead of trying all deletion combinations (exponential time), we compute the maximum number of columns we can preserve while maintaining sorted order across all strings, then subtract from the total. The key insight is transforming from "minimum deletions" to "maximum keeps" - a classic DP optimization pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m² × n)	O(m)	Find longest subsequence of columns to keep using DP
Brute Force (Try All Combinations)	O(2^m × n × m)	O(m)	Try every possible subset of columns to delete and check validity

Dynamic Programming (Optimal) — Algorithm Steps

Define dp[i] as the length of longest valid subsequence ending at column i
For each column i, check all previous columns j < i
If we can extend from j to i (all strings have s[j] <= s[i]), update dp[i]
Return m - max(dp[i]) where m is the total number of columns

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Array

dp[i] represents longest valid subsequence ending at column i

Check Column Pairs

For each pair (j,i), verify if column j can extend to column i

Update DP Values

If extension is valid, update dp[i] = max(dp[i], dp[j] + 1)

Calculate Result

Return total columns minus maximum dp value

Code -

solution.c — C

int minDeletionSize(char** strs, int strsSize) {
    int m = strlen(strs[0]);
    if (m == 0) return 0;
    
    // dp[i] = length of longest valid subsequence ending at column i
    int* dp = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        dp[i] = 1;
    }
    
    for (int i = 1; i < m; i++) {
        for (int j = 0; j < i; j++) {
            // Check if we can extend subsequence from j to i
            int canExtend = 1;
            for (int k = 0; k < strsSize; k++) {
                if (strs[k][j] > strs[k][i]) {
                    canExtend = 0;
                    break;
                }
            }
            
            if (canExtend) {
                if (dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
        }
    }
    
    // Return total columns minus longest subsequence we can keep
    int maxKeep = 0;
    for (int i = 0; i < m; i++) {
        if (dp[i] > maxKeep) {
            maxKeep = dp[i];
        }
    }
    
    free(dp);
    return m - maxKeep;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n)

m² pairs of columns to check, n strings to validate each pair

✓ Linear Growth

Space Complexity

O(m)

DP array to store longest subsequence lengths

✓ Linear Space

42.5K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler