1713. 得到子序列的最少操作次数

题目链接：leetcode.

寻思了半天的dp，超时

/*
73 / 82 个通过测试用例
超出时间限制
*/ 
class Solution {
public:
    int minOperations(vector<int>& target, vector<int>& arr) {
        int M = target.size(), N = arr.size();
        unordered_map<int, vector<int>> Map;
        for(int i = 0;i < N;++i)
        {
            Map[arr[i]].push_back(i);
        }
        vector<int> dp(N, 0);
        for(int i = 0;i < M;++i)
        {
            int t = target[i];
            for(int j = N - 1;j >= 0;--j)
            {
                if(Map[t].empty())
                {
                    dp[j] += 1;
                }
                else
                {
                    int minn = dp[j] + 1;
                    for(auto x : Map[t])
                    {
                        if(x <= j)
                        {
                            minn = min(dp[x], minn);
                        }
                    }
                    dp[j] = minn;
                }
            }
        }
        return dp[N - 1];
    }
};

题解使用的方式很巧妙，因为target元素不重复，就找target和arr两者的最长公共子序列（其实就是上面的O(mn)复杂度的动态规划），氮素，会超时
所以就用哈希表存放target的元素索引值，将其变成[0,1,2,3,4,5]这样的，再重新构建arr，如果arr中的元素不在target中，那这个元素就用不上，不用记录，否则就记录上对应target中的索引，将其变成[1,0,5,4,2,0,3]这样的，记录为nums。
原题转变为找nums中的最长递增子序列，因为target一定是递增的，求得最长递增子序列的长度len，则需要补充的元素个数就是target.size() - len。

/*
执行用时：268 ms, 在所有 C++ 提交中击败了94.34%的用户
内存消耗：110.9 MB, 在所有 C++ 提交中击败了49.06%的用户
*/
class Solution {
public:
    int minOperations(vector<int>& target, vector<int>& arr) {
        int M = target.size(), N = arr.size();
        //哈希表记录target的index
		unordered_map<int, int> Map;
		for(int i = 0;i < M;++i)
		{
			Map[target[i]] = i;
		} 
		//构建新的arr，用target的下标表示
		vector<int> nums;
		for(auto x : arr)
		{
			if(Map.count(x))
			{
				nums.emplace_back(Map[x]);
			}
		} 
		
		//贪心+二分在nums里查找最长的递增子序列
		//dp[i]存放长度为i的递增子序列中末尾最小的数，dp数组是递增的
		vector<int> dp(nums.size() + 1, 0);
        int len = 1;
        dp[1] = nums[0];
        for(int i = 1;i < nums.size();++i)
        {
            if(nums[i] > dp[len])
            {
                dp[++len] = nums[i];
            }
            else
            {
                //在dp数组中用二分查找第一个比nums[i]大的数
                int left = 1, right = len;
                while(left < right)
                {
                    int mid = left + (right - left) / 2;
                    if(dp[mid] < nums[i])
                    {
                        left = mid + 1;
                    }
                    else
                    {
                        right = mid;
                    }
                }
                //将nums[i]插入到left之后
                dp[left] = nums[i];
            }
        }
        return M - len; 
    }
};