跳转至

1497. 检查数组对是否可以被 k 整除

题目描述

给你一个整数数组 arr 和一个整数 k ，其中数组长度是偶数，值为 n 。

现在需要把数组恰好分成 n / 2 对，以使每对数字的和都能够被 k 整除。

如果存在这样的分法，请返回 true ；否则，返回 false。

 

示例 1：

输入：arr = [1,2,3,4,5,10,6,7,8,9], k = 5
输出：true
解释：划分后的数字对为 (1,9),(2,8),(3,7),(4,6) 以及 (5,10) 。

示例 2：

输入：arr = [1,2,3,4,5,6], k = 7
输出：true
解释：划分后的数字对为 (1,6),(2,5) 以及 (3,4) 。

示例 3：

输入：arr = [1,2,3,4,5,6], k = 10
输出：false
解释：无法在将数组中的数字分为三对的同时满足每对数字和能够被 10 整除的条件。

 

提示：

  • arr.length == n
  • 1 <= n <= 105
  • n 为偶数
  • -109 <= arr[i] <= 109
  • 1 <= k <= 105

解法

方法一：统计余数

两个数 \(a\) 和 \(b\) 的和能被 \(k\) 整除，当且仅当这两个数分别对 \(k\) 取模的结果之和能被 \(k\) 整除。

因此，我们可以统计数组中每个数对 \(k\) 取模的结果，即余数，记录在数组 \(\textit{cnt}\) 中。然后我们遍历数组 \(\textit{cnt}\)，对于范围在 \([1,..k-1]\) 的每个数 \(i\)，如果 \(\textit{cnt}[i]\) 和 \(\textit{cnt}[k-i]\) 的值不相等，说明无法将数组中的数字分为 \(n/2\) 对，使得每对数字的和都能被 \(k\) 整除。如果 \(\textit{cnt}[0]\) 的值不是偶数，也说明无法将数组中的数字分为 \(n/2\) 对，使得每对数字的和都能被 \(k\) 整除。

时间复杂度 \(O(n)\)，其中 \(n\) 为数组 \(\textit{arr}\) 的长度。空间复杂度 \(O(k)\)。

1
2
3
4
class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:
        cnt = Counter(x % k for x in arr)
        return cnt[0] % 2 == 0 and all(cnt[i] == cnt[k - i] for i in range(1, k))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
    public boolean canArrange(int[] arr, int k) {
        int[] cnt = new int[k];
        for (int x : arr) {
            ++cnt[(x % k + k) % k];
        }
        for (int i = 1; i < k; ++i) {
            if (cnt[i] != cnt[k - i]) {
                return false;
            }
        }
        return cnt[0] % 2 == 0;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution {
public:
    bool canArrange(vector<int>& arr, int k) {
        vector<int> cnt(k);
        for (int& x : arr) {
            ++cnt[((x % k) + k) % k];
        }
        for (int i = 1; i < k; ++i) {
            if (cnt[i] != cnt[k - i]) {
                return false;
            }
        }
        return cnt[0] % 2 == 0;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
func canArrange(arr []int, k int) bool {
    cnt := make([]int, k)
    for _, x := range arr {
        cnt[(x%k+k)%k]++
    }
    for i := 1; i < k; i++ {
        if cnt[i] != cnt[k-i] {
            return false
        }
    }
    return cnt[0]%2 == 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function canArrange(arr: number[], k: number): boolean {
    const cnt: number[] = Array(k).fill(0);
    for (const x of arr) {
        ++cnt[((x % k) + k) % k];
    }
    for (let i = 1; i < k; ++i) {
        if (cnt[i] !== cnt[k - i]) {
            return false;
        }
    }
    return cnt[0] % 2 === 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
impl Solution {
    pub fn can_arrange(arr: Vec<i32>, k: i32) -> bool {
        let k = k as usize;
        let mut cnt = vec![0; k];
        for &x in &arr {
            cnt[((x % k as i32 + k as i32) % k as i32) as usize] += 1;
        }
        for i in 1..k {
            if cnt[i] != cnt[k - i] {
                return false;
            }
        }
        cnt[0] % 2 == 0
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
/**
 * @param {number[]} arr
 * @param {number} k
 * @return {boolean}
 */
var canArrange = function (arr, k) {
    const cnt = Array(k).fill(0);
    for (const x of arr) {
        ++cnt[((x % k) + k) % k];
    }
    for (let i = 1; i < k; ++i) {
        if (cnt[i] !== cnt[k - i]) {
            return false;
        }
    }
    return cnt[0] % 2 === 0;
};

评论