## Algorithm

Problem Name: 960. Delete Columns to Make Sorted III

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 every string (row) in lexicographic order. (i.e., `(strs <= strs <= ... <= strs[strs.length - 1])`, and `(strs <= strs <= ... <= strs[strs.length - 1])`, and so on). Return the minimum possible value of `answer.length`.

Example 1:

```Input: strs = ["babca","bbazb"]
Output: 3
Explanation: After deleting columns 0, 1, and 4, the final array is strs = ["bc", "az"].
Both these rows are individually in lexicographic order (ie. strs <= strs and strs <= strs).
Note that strs > strs - the array strs is not necessarily in lexicographic order.```

Example 2:

```Input: strs = ["edcba"]
Output: 4
Explanation: If we delete less than 4 columns, the only row will not be lexicographically sorted.
```

Example 3:

```Input: strs = ["ghi","def","abc"]
Output: 0
Explanation: All rows are already lexicographically sorted.
```

Constraints:

• `n == strs.length`
• `1 <= n <= 100`
• `1 <= strs[i].length <= 100`
• `strs[i]` consists of lowercase English letters.

## Code Examples

### #1 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const minDeletionSize = function(A) {
const dp = new Array(A.length).fill(1)
for (let i = 0; i < A.length; i++) {
for (let j = 0; j < i; j++) {
for (let k = 0; k <= A.length; k++) {
if (k === A.length) dp[i] = Math.max(dp[i], dp[j] + 1)
else if (A[k][j] > A[k][i]) break
}
}
}
return A.length - Math.max(...dp)
}
``````
Copy The Code &

Input

cmd
strs = ["babca","bbazb"]

Output

cmd
3

### #2 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def minDeletionSize(self, A):
m, n = len(A), len(A)
dp =  * n
for j in range(1, n):
for i in range(j):
if all(A[k][i] <= A[k][j] for k in range(m)):
dp[j] = max(dp[j], dp[i] + 1)
return n - max(dp)
``````
Copy The Code &

Input

cmd
strs = ["babca","bbazb"]

Output

cmd
3