LeetCode 2300. 咒语和药水的成功对数

2300. 咒语和药水的成功对数

给你两个正整数数组 spells 和 potions ，长度分别为 n 和 m ，其中 spells[i] 表示第 i 个咒语的能量强度，potions[j] 表示第 j 瓶药水的能量强度。

同时给你一个整数 success 。一个咒语和药水的能量强度 相乘 如果 大于等于 success ，那么它们视为一对 成功 的组合。

请你返回一个长度为 n 的整数数组 pairs，其中 pairs[i] 是能跟第 i 个咒语成功组合的 药水 数目。

示例 1：

输入：spells = [5,1,3], potions = [1,2,3,4,5], success = 7
输出：[4,0,3]
解释：
- 第 0 个咒语：5 * [1,2,3,4,5] = [5,10,15,20,25] 。总共 4 个成功组合。
- 第 1 个咒语：1 * [1,2,3,4,5] = [1,2,3,4,5] 。总共 0 个成功组合。
- 第 2 个咒语：3 * [1,2,3,4,5] = [3,6,9,12,15] 。总共 3 个成功组合。
所以返回 [4,0,3] 。

示例 2：

输入：spells = [3,1,2], potions = [8,5,8], success = 16
输出：[2,0,2]
解释：
- 第 0 个咒语：3 * [8,5,8] = [24,15,24] 。总共 2 个成功组合。
- 第 1 个咒语：1 * [8,5,8] = [8,5,8] 。总共 0 个成功组合。
- 第 2 个咒语：2 * [8,5,8] = [16,10,16] 。总共 2 个成功组合。
所以返回 [2,0,2] 。

解法1：排序 + 二分查找  

Java版：

public class Solution {
    public int[] successfulPairs(int[] spells, int[] potions, long success) {
        Arrays.sort(potions);
        int[] pairs = new int[spells.length];
        for (int i = 0; i < spells.length; i++) {
            // success / spells[i] 上取整
            long target = (success + spells[i] - 1) / spells[i];  
            int count = countPairs(potions, spells[i], target);      
            pairs[i] = count;
        }
        return pairs;
    }

    private int countPairs(int[] potions, int spell, long target) {
        int left = 0;
        int right = potions.length - 1;
        while (left <= right) {
            // 循环不变量:
            // left - 1 < target
            // right + 1 >= target
            int mid = left + (right - left) / 2;
            if (potions[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        // left 是成功配对的药水的最小下标
        return potions.length - left;
    } 
}

Python3版：

class Solution:
    def successfulPairs(self, spells: List[int], potions: List[int], success: int) -> List[int]:
        potions.sort()
        n = len(potions)
        pairs = []

        def binarySearch(s: int) -> int:
            l = 0
            r = len(potions) - 1
            while l <= r:
                m = (l + r) // 2
                if s * potions[m] >= success:
                    r = m - 1
                else:
                    l = m + 1
            return l

        for s in spells:
            pairs.append(n - binarySearch(s))
        return pairs

复杂度分析

• 时间复杂度：O((n+m)log⁡m)，其中 n 为 spells 的长度，m 为 potions 的长度，potions排序的时间复杂度为mlogm。
• 空间复杂度：O(1)。忽略排序的栈开销，仅用到若干额外变量。返回值不计入。