leetcode【困难】1713、得到子序列的最少操作次数

给你一个数组 target ，包含若干 互不相同 的整数，以及另一个整数数组 arr ，arr 可能 包含重复元素。

每一次操作中，你可以在 arr 的任意位置插入任一整数。比方说，如果 arr = [1,4,1,2] ，那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。

请你返回 最少 操作次数，使得 target 成为 arr 的一个子序列。（target中无重复）

一个数组的 子序列 指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列（加粗元素），但 [2,4,2] 不是子序列。

示例 1：

输入：target = [5,1,3], arr = [9,4,2,3,4]
输出：2
解释：你可以添加 5 和 1 ，使得 arr 变为 [5,9,4,1,2,3,4] ，target 为 arr 的子序列。

示例 2：

输入：target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]
输出：3

思路：使 target 为 arr 的子序列。找 arr 中 target 的最长子序列，通过map把target变为有序，再转化arr，题目就变成了找最长递增子序列

例子：
target = [6,4,8,1,3,2] 在map中 map[6] = 1, map[4] = 2, map[8] = 3…
arr = [4,7,6,2,3,8,6,1] 转化为 [2,1,6,5,3,1,4]

1. 首先，先用一个哈希map记录target的值以及对应的索引，因为target是一个不重复值的数组；
2. 然后，遍历arr数组，根据map来用一个数组arrIndexes记录arr里每个值对应到target里的索引；
3. 在arrIndexes里找到最长的递增子序列；300、最长递增子序列 【中等】

class Solution {
    public int minOperations(int[] target, int[] arr) {
        Map<Integer, Integer> hash = new HashMap<>();
        //1、hash记录target里元素的位置
        for(int i=0;i<target.length;i++){
            hash.put(target[i],i);
        }
        //2、arrIndexes记录arr里每个值对应到target里的索引；
        List<Integer>arrIndexes=new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            Integer temp = hash.get(arr[i]);
            if(temp!=null) arrIndexes.add(temp);
        }

        if(arrIndexes.size()==0||arrIndexes.size()==1) return target.length-arrIndexes.size();
        //3、找到arrIndexes里的最大递增子序列        
        //动态规划--超时
        // int[]dp=new int[arrIndexes.size()];
        // Arrays.fill(dp,1);
        // for(int j=1;j<arrIndexes.size();j++){
        //     for(int i=0;i<j;i++){
        //         if(arrIndexes.get(i)<arrIndexes.get(j)) dp[j]=Math.max(dp[j],dp[i]+1);
        //     }
        // }
        // int maxlength=Arrays.stream(dp).max().getAsInt();
        // return target.length-maxlength;

        //二分
        List<Integer>list=new ArrayList<>();
        list.add(arrIndexes.get(0));
        for(int i=1;i<arrIndexes.size();i++){
            if(arrIndexes.get(i)>list.get(list.size()-1)){
                list.add(arrIndexes.get(i));
                continue;
            }
            int l=0,r=list.size();
            while(l<r){
                int mid=(l+r)/2;
                if(list.get(mid)<arrIndexes.get(i)) l=mid+1;
                else r=mid;
            }
            list.set(l,arrIndexes.get(i));
        }
        return target.length-list.size();
    }
}