力扣周赛222期 1711. 大餐计数 1712. 将数组分成三个子数组的方案数 1713. 得到子序列的最少操作次数

这周的后三道题都挺有意思，先占个坑写下简单思路和比赛时提交的代码，抽空再整理下

第二题：

1711. 大餐计数

难度 中等

大餐 是指 恰好包含两道不同餐品 的一餐，其美味程度之和等于 2 的幂。

你可以搭配 任意 两道餐品做一顿大餐。

给你一个整数数组 deliciousness ，其中 deliciousness[i] 是第 i​​​​​​​ 道餐品的美味程度，返回你可以用数组中的餐品做出的不同 大餐 的数量。结果需要对 10^9 + 7 取余。

注意，只要餐品下标不同，就可以认为是不同的餐品，即便它们的美味程度相同。

 

示例 1：

输入：deliciousness = [1,3,5,7,9]
输出：4
解释：大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。
它们各自的美味程度之和分别为 4 、8 、8 和 16 ，都是 2 的幂。

示例 2：

输入：deliciousness = [1,1,1,3,3,3,7]
输出：15
解释：大餐的美味程度组合为 3 种 (1,1) ，9 种 (1,3) ，和 3 种 (1,7) 。

 

提示：

• 1 <= deliciousness.length <= 10^5
• 0 <= deliciousness[i] <= 2^20

思路：每道菜满足0 <= deliciousness[i] <= 2^20，那么两道菜的deliciousness和范围为[0,2^40]，所以可以组合成的美味程度之和等于 2 的幂的总和情况为41种，即2的0次幂到40次幂，那么可以计算每道菜与这41种情况的差值并记录该差值有几道菜对应，那么在从前往后遍历的过程中即可计算出所有满足的组合

代码：

class Solution {
    public int countPairs(int[] deliciousness) {
        Map<Long, Integer> hm = new HashMap<>();
        int modMask = 1000000000 + 7;
        long[] temNums = new long[41];
        temNums[0] = 1;
        for (int i = 1; i < temNums.length; i++) {
            temNums[i] = temNums[i - 1] * 2;
        }
        long count = 0;
        for (int i = 0; i < deliciousness.length; i++) {
            for (int j = 0; j < temNums.length; j++) {
                if (temNums[j] >= deliciousness[i] && hm.containsKey(temNums[j] - deliciousness[i])) {
                    count += hm.get(temNums[j] - deliciousness[i]);
                    count %= modMask;
                }
            }
            hm.merge((long) deliciousness[i], 1, Integer::sum);
        }
        return (int) (count % modMask);
    }
}

第三题：

1712. 将数组分成三个子数组的方案数

难度 中等

我们称一个分割整数数组的方案是 好的 ，当它满足：

• 数组被分成三个 非空 连续子数组，从左至右分别命名为 left ， mid ， right 。
• left 中元素和小于等于 mid 中元素和，mid 中元素和小于等于 right 中元素和。

给你一个 非负 整数数组 nums ，请你返回 好的 分割 nums 方案数目。由于答案可能会很大，请你将结果对 109 + 7 取余后返回。

 

示例 1：

输入：nums = [1,1,1]
输出：1
解释：唯一一种好的分割方案是将 nums 分成 [1] [1] [1] 。

示例 2：

输入：nums = [1,2,2,2,5,0]
输出：3
解释：nums 总共有 3 种好的分割方案：
[1] [2] [2,2,5,0]
[1] [2,2] [2,5,0]
[1,2] [2,2] [5,0]

示例 3：

输入：nums = [3,2,1]
输出：0
解释：没有好的分割方案。

 

提示：

• 3 <= nums.length <= 10^5
• 0 <= nums[i] <= 10^4

思路：这题数量级为10^5明细考察nlogn时间复杂度的算法，大致可以猜到是二分法，在纸上画的过程中发现划分的过程中，分割点从左往右进行时，条件是否满足是有一定的传递性的，通过移动指针得到分割的结果，其结果是否满足题目关系是具有传递性的，通过滑动指针判断是否满足并计数，即可计算出结果，时间复杂度O(0),空间复杂度O(n);

（类似于双指针的三指针）

代码：

class Solution {
    public int waysToSplit(int[] nums) {
        long count = 0;
        int modMask = 1000000000 + 7;
        int first = 0;
        int second = 1;
        int del = 0;
        int[] sumNums = new int[nums.length];
        sumNums[0] = nums[0];
        for (int i = 1; i < sumNums.length; i++) {
            sumNums[i] = sumNums[i - 1] + nums[i];
        }
        int max = sumNums[nums.length - 1];
        int secondMax = max - (int) Math.ceil(max / 3.0);
        int subCount = 0;
        for (; second < nums.length - 1; second++) {
            if (sumNums[second] > secondMax) {
                break;
            }
            for (; first < second; first++) {
                if (sumNums[first] <= sumNums[second] - sumNums[first]) {
                    subCount++;
                } else {
                    break;
                }
            }
            for (; del < first; del++) {
                if (max - sumNums[second] < sumNums[second] - sumNums[del]) {
                    subCount--;
                } else {
                    break;
                }
            }
            count += subCount;
            count %= modMask;
        }
        return (int) (count % modMask);
    }
}

第四题：

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

难度 困难

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

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

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

一个数组的 子序列 指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说，[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

 

提示：

• 1 <= target.length, arr.length <= 10^5
• 1 <= target[i], arr[i] <= 10^9
• target 不包含任何重复元素。

思路：因为target是不重复的，所以可以对arr中出现的每一个在target中的字母记录其在target中出现的位置，然后题目就可以转化成求最长上升子序列了，需要注意的是题目数据量为10^5，求LIS的时间复杂度需要满足O（nlogn）才可AC
自己没做出nlogn的做法，这里抄了最长递增子序列的题解，还要再好好学习一下

class Solution {
    public int minOperations(int[] target, int[] arr) {
        Map<Integer, Integer> hm = new HashMap<>();
        for (int i = 0; i < target.length; i++) {
            hm.put(target[i], i);
        }
        List<Integer> list = new LinkedList<>();
        for (int i : arr) {
            if (hm.containsKey(i)) {
                list.add(hm.get(i));
            }
        }
        Integer[] arrs = new Integer[list.size()];
        list.toArray(arrs);
        return target.length - lengthOfLIS(arrs);
    }


    public int lengthOfLIS(Integer[] nums) {
        int len = 1, n = nums.length;
        if (n == 0) {
            return 0;
        }
        int[] d = new int[n + 1];
        d[len] = nums[0];
        for (int i = 1; i < n; ++i) {
            if (nums[i] > d[len]) {
                d[++len] = nums[i];
            } else {
                int l = 1, r = len, pos = 0; // 如果找不到说明所有的数都比 nums[i] 大，此时要更新 d[1]，所以这里将 pos 设为 0
                while (l <= r) {
                    int mid = (l + r) >> 1;
                    if (d[mid] < nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    } else {
                        r = mid - 1;
                    }
                }
                d[pos + 1] = nums[i];
            }
        }
        return len;
    }
}