Question

2644. 找出可整除性得分最大的整数

English Version

题目描述

给你两个下标从 0 开始的整数数组 nums 和 divisors 。

divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。

返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。

 

示例 1：

输入：nums = [4,7,9,3,9], divisors = [5,2,3]
输出：3
解释：divisors 中每个元素的可整除性得分为：
divisors[0] 的可整除性得分为 0 ，因为 nums 中没有任何数字能被 5 整除。
divisors[1] 的可整除性得分为 1 ，因为 nums[0] 能被 2 整除。 
divisors[2] 的可整除性得分为 3 ，因为 nums[2]、nums[3] 和 nums[4] 都能被 3 整除。 
因此，返回 divisors[2] ，它的可整除性得分最大。

示例 2：

输入：nums = [20,14,21,10], divisors = [5,7,5]
输出：5
解释：divisors 中每个元素的可整除性得分为：
divisors[0] 的可整除性得分为 2 ，因为 nums[0] 和 nums[3] 都能被 5 整除。
divisors[1] 的可整除性得分为 2 ，因为 nums[1] 和 nums[2] 都能被 7 整除。
divisors[2] 的可整除性得分为 2 ，因为 nums[0] 和 nums[3] 都能被5整除。 
由于 divisors[0]、divisors[1] 和 divisors[2] 的可整除性得分都是最大的，因此，我们返回数值最小的一个，即 divisors[2] 。

示例 3：

输入：nums = [12], divisors = [10,16]
输出：10
解释：divisors 中每个元素的可整除性得分为：
divisors[0] 的可整除性得分为 0 ，因为 nums 中没有任何数字能被 10 整除。
divisors[1] 的可整除性得分为 0 ，因为 nums 中没有任何数字能被 16 整除。 
由于 divisors[0] 和 divisors[1] 的可整除性得分都是最大的，因此，我们返回数值最小的一个，即 divisors[0] 。

 

提示：

• 1 <= nums.length, divisors.length <= 1000
• 1 <= nums[i], divisors[i] <= 109

解法

方法一：枚举

我们可以枚举 $divisors$ 中的每个元素 $div$，计算 $nums$ 中有多少个元素能被 $div$ 整除，记为 $cnt$。

• 如果 $cnt$ 大于当前最大的可整除性得分 $mx$，则更新 $mx = cnt$，并且更新 $ans = div$。
• 如果 $cnt$ 等于 $mx$ 并且 $div$ 小于 $ans$，则更新 $ans = div$。

最后返回 $ans$ 即可。

时间复杂度 $(m \times n)$，其中 $m$ 和 $n$ 分别是 $nums$ 和 $divisors$ 的长度。空间复杂度 $O(1)$。

class Solution:
  def maxDivScore(self, nums: List[int], divisors: List[int]) -> int:
    ans, mx = divisors[0], 0
    for div in divisors:
      cnt = sum(x % div == 0 for x in nums)
      if mx < cnt:
        mx, ans = cnt, div
      elif mx == cnt and ans > div:
        ans = div
    return ans

class Solution {
  public int maxDivScore(int[] nums, int[] divisors) {
    int ans = divisors[0];
    int mx = 0;
    for (int div : divisors) {
      int cnt = 0;
      for (int x : nums) {
        if (x % div == 0) {
          ++cnt;
        }
      }
      if (mx < cnt) {
        mx = cnt;
        ans = div;
      } else if (mx == cnt) {
        ans = Math.min(ans, div);
      }
    }
    return ans;
  }
}

class Solution {
public:
  int maxDivScore(vector<int>& nums, vector<int>& divisors) {
    int ans = divisors[0];
    int mx = 0;
    for (int div : divisors) {
      int cnt = 0;
      for (int x : nums) {
        cnt += x % div == 0;
      }
      if (mx < cnt) {
        mx = cnt;
        ans = div;
      } else if (mx == cnt) {
        ans = min(ans, div);
      }
    }
    return ans;
  }
};

func maxDivScore(nums []int, divisors []int) int {
  ans, mx := divisors[0], 0
  for _, div := range divisors {
    cnt := 0
    for _, x := range nums {
      if x%div == 0 {
        cnt++
      }
    }
    if mx < cnt {
      ans, mx = div, cnt
    } else if mx == cnt && ans > div {
      ans = div
    }
  }
  return ans
}

function maxDivScore(nums: number[], divisors: number[]): number {
  let ans: number = divisors[0];
  let mx: number = 0;
  for (const div of divisors) {
    const cnt = nums.reduce((a, b) => a + (b % div == 0 ? 1 : 0), 0);
    if (mx < cnt) {
      mx = cnt;
      ans = div;
    } else if (mx === cnt && ans > div) {
      ans = div;
    }
  }
  return ans;
}

impl Solution {
  pub fn max_div_score(nums: Vec<i32>, divisors: Vec<i32>) -> i32 {
    let mut ans = divisors[0];
    let mut mx = 0;

    for &div in &divisors {
      let mut cnt = 0;

      for &n in &nums {
        if n % div == 0 {
          cnt += 1;
        }
      }

      if cnt > mx || (cnt >= mx && div < ans) {
        mx = cnt;
        ans = div;
      }
    }

    ans
  }
}