Interesting question, requires deep thinking of logic and edge cases.
Complexity

Time complexity:
O(n3) worst & O(n2) average


Space complexity:

Code

# Complexity
- Time complexity:
$$O(n^3)$$ worst & $$O(n^2)$$ average

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->

# Code
```cpp []
class Solution {
public:
    int minDeletionSize(vector<string>& strs) {
        int n = strs.size();
        int m = strs[0].size();

        int ans = 0;
        unordered_map<int, bool>ignore;
        unordered_map<int, bool> jumps;
        bool changed = true;
        while(changed) {
            changed = false;
            int lastBreak = -1;
            for(int i=1;i<n;i++) {
                    if(changed) break;
                for(int j=0;j < m;j++) {
                    if(changed) break;
                    if(ignore[j]) continue;
                    if(strs[i][j] > strs[i-1][j]) {
                        lastBreak = j;
                        jumps[j]=true;
                        break;
                    } else if (strs[i][j] == strs[i-1][j]) {
                        continue;
                    } else {
                        ignore[j]=true;
                        ans++;
    if(jumps[j]) {
        changed = true;
        break;
    }
                    }
                }
            }
        }
        return ans;
    }
};
```
['C++']