(DP) 960. 删列造序 III

给定由 N 个小写字母字符串组成的数组 A，其中每个字符串长度相等。

选取一个删除索引序列，对于 A 中的每个字符串，删除对应每个索引处的字符。

比如，有 A = ["babca","bbazb"]，删除索引序列 {0, 1, 4}，删除后 A 为["bc","az"]。

假设，我们选择了一组删除索引 D，那么在执行删除操作之后，最终得到的数组的行中的每个元素都是按字典序排列的。

清楚起见，A[0] 是按字典序排列的（即，A[0][0] <= A[0][1] <= ... <= A[0][A[0].length - 1]），A[1] 是按字典序排列的（即，A[1][0] <= A[1][1] <= ... <= A[1][A[1].length - 1]），依此类推。

请你返回 D.length 的最小可能值。

示例 1：

输入：["babca","bbazb"]
输出：3
解释：
删除 0、1 和 4 这三列后，最终得到的数组是 A = ["bc", "az"]。
这两行是分别按字典序排列的（即，A[0][0] <= A[0][1] 且 A[1][0] <= A[1][1]）。
注意，A[0] > A[1] —— 数组 A 不一定是按字典序排列的。
示例 2：

输入：["edcba"]
输出：4
解释：如果删除的列少于 4 列，则剩下的行都不会按字典序排列。
示例 3：

输入：["ghi","def","abc"]
输出：0
解释：所有行都已按字典序排列。
 

提示：

1 <= A.length <= 100
1 <= A[i].length <= 100

题解：删除最小，意味着保留递增（保留相等）的最多；因此可以联系的想到最长上升子序列。

           

class Solution {
public:
    int dp[10005];
    
    int fun(int x,int y,vector<string>& a){
        for(int i=0;i<a.size();i++)
            if(a[i][x]>a[i][y]) return 0;
        return 1;
    }
    
    int minDeletionSize(vector<string>& a) {
        int len=a.size();
        vector<int>v; 
        
        int n=a[0].length();
        memset(dp,0,sizeof(dp));
        
        for(int i=0;i<n;i++){
            dp[i]=1;
            for(int j=0;j<i;j++){
                if(fun(j,i,a)) dp[i]=max(dp[i],dp[j]+1);
            }
        }
        int ans=0;
        for(int i=0;i<n;i++)  ans=max(ans,dp[i]);
        return n-ans;
    }
};

知识点回顾：

300. 最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

题解：o(n^2)  和 o(n*logn)：

/*
class Solution {     // O(n*n)
public:
    int dp[10005];
    int lengthOfLIS(vector<int>& a) {
        int len=a.size();
        //memset(dp,1,sizeof(dp));
        int ans=0;
        for(int i=0;i<len;i++){
            dp[i]=1;
            for(int j=0;j<i;j++){
                if(a[i]>a[j]) dp[i]=max(dp[i],dp[j]+1); 
            }
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};
*/

class Solution {    // O(n*log(n))
public:
    int dp[10005];
    int lengthOfLIS(vector<int>& a) {
        int len=a.size();
        int p=0;
        for(int i=0;i<len;i++){
            if(!p) dp[p++]=a[i];
            else{
                int h=lower_bound(dp,dp+p,a[i])-dp;
                if(h==p) dp[p++]=a[i];
                else dp[h]=a[i];
            }
        }
        return p;
    }
};