算法笔记-lc-870. 优势洗牌（中等）

题目

题干

给定两个大小相等的数组 nums1 和 nums2，nums1 相对于 nums2 的优势可以用满足 nums1[i] > nums2[i] 的索引 i 的数目来描述。

返回 nums1 的任意排列，使其相对于 nums2 的优势最大化。

示例

示例 1：

输入：nums1 = [2,7,11,15], nums2 = [1,10,4,11]
输出：[2,11,7,15]
示例 2：

输入：nums1 = [12,24,8,32], nums2 = [13,25,32,11]
输出：[24,32,8,12]

提示：

1 <= nums1.length <= 105
nums2.length == nums1.length
0 <= nums1[i], nums2[i] <= 109

题解

数据结构

显然，对于任意一个t=nums2[i] 而言，我们应当在候选集合中选择比其大的最小数，若不存在这样的数字，则选择候选集合中的最小值。

同时，由于 nums1 相同数会存在多个，我们还要对某个具体数字的可用次数进行记录。

也就是我们总共涉及两类操作：

实时维护一个候选集合，该集合支持高效查询比某个数大的数值操作；
对候选集合中每个数值的可使用次数进行记录，当使用到了候选集合中的某个数后，要对其进行计数减一操作，若计数为 0，则将该数值从候选集合中移除。
计数操作容易想到哈希表，而实时维护候选集合并高效查询可以使用基于红黑树的 TreeSet 数据结构。

代码：

class Solution {
    public int[] advantageCount(int[] nums1, int[] nums2) {
        int n = nums1.length;
        TreeSet<Integer> tset = new TreeSet<>();
        Map<Integer, Integer> map = new HashMap<>();
        for (int x : nums1) {
            map.put(x, map.getOrDefault(x, 0) + 1);
            if (map.get(x) == 1) tset.add(x);
        }
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            Integer cur = tset.ceiling(nums2[i] + 1);
            if (cur == null) cur = tset.ceiling(-1);
            ans[i] = cur;
            map.put(cur, map.get(cur) - 1);
            if (map.get(cur) == 0) tset.remove(cur);
        }
        return ans;
    }
}

时间复杂度：O(nlogn)
空间复杂度：O(n)

排序 + 双指针

在解法一中，我们是从每个nums2[i] 出发考虑，使用哪个 nums1[i] 去匹配最为合适。

实际上，我们也能从nums1[i] 出发，考虑将其与哪个 nums2[i] 进行匹配。

为了让每个决策回合具有独立性，我们需要对两数组进行排序，同时为了在构造答案时，能够对应回 nums2 的原下标，排序前我们需要使用「哈希表」记录每个nums2[i] 的下标为何值。

使用变量 l1 代表当前决策将 nums1[l1] 分配到哪个 nums2 的位置，使用 l2 和 r2 代表当前 nums2 中还有[l2,r2] 位置还待填充。

可以证明我们在从前往后给每个nums1[l1] 分配具体位置时，分配的位置只会在 l2 和 r2 两者之间产生。

代码：

class Solution {
    public int[] advantageCount(int[] nums1, int[] nums2) {
        int n = nums1.length;
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            List<Integer> list = map.getOrDefault(nums2[i], new ArrayList<>());
            list.add(i);
            map.put(nums2[i], list);
        }
        Arrays.sort(nums1); Arrays.sort(nums2);
        int[] ans = new int[n];
        for (int l1 = 0, l2 = 0, r2 = n - 1; l1 < n; l1++) {
            int t = nums1[l1] > nums2[l2] ? l2 : r2;
            List<Integer> list = map.get(nums2[t]);
            int idx = list.remove(list.size() - 1);
            ans[idx] = nums1[l1];
            if (t == l2) l2++;
            else r2--;
        }
        return ans;
    }
}

时间复杂度：O(nlogn)
空间复杂度：O(n)