使所有数组元素可被数字 K 整除

在编程中，我们经常需要处理数组的元素，有时候需要将数组中的所有元素都能被一个数字 K 整除。这通常涉及到对数组元素进行取余操作，而取余操作的性能较低，因此我们需要寻找更快速的方法。

以下是几种实现方式，对于不同的场景和需求，可以选择不同的实现方式。

方法一：遍历数组元素

第一种方式是遍历数组中的每个元素，并检查是否可以被 K 整除。如果元素不能被 K 整除，就将其乘上一个倍数，使得乘上这个倍数后能够被 K 整除。

def make_all_divisible(a, k):
    for i in range(len(a)):
        if a[i] % k != 0:
            a[i] = a[i] * (k - a[i] % k)
    return a

这个方法的时间复杂度是 O(N)，其中 N 是数组的长度。当数组很大时，这个方法的效率会降低。

方法二：求最小公倍数

第二种方式是求出数组中所有元素的最小公倍数，然后将其作为一个倍数来将数组中的元素扩大，使得它们都能够被 K 整除。

import math

def lcm(a, b):
    return abs(a * b) // math.gcd(a, b)

def make_all_divisible(a, k):
    lcm = 1
    for i in range(len(a)):
        lcm = lcm(lcm, a[i])
    return [x * (lcm // k) for x in a]

这个方法的时间复杂度是 O(N log M)，其中 N 是数组的长度，M 是数组中的元素的最大值。当需要处理多个数组时，最小公倍数的计算可以在多个数组之间共享，从而提高效率。

方法三：利用余数相加

第三种方式是利用余数相加的特性，对于连续的一段数组元素，如果它们的余数之和恰好等于 K 的倍数，那么这一段元素就可以被一个数字 K 整除。具体实现如下：

def make_all_divisible(a, k):
    n = len(a)
    mod = [0] * k  # 存储余数的计数器
    for i in range(n):
        mod[a[i] % k] += 1
    ans = [0] * n
    t = 0
    # 处理余数和为 K 的倍数的一段连续元素
    for i in range(1, k // 2 + 1):
        if i != k - i:
            t += min(mod[i], mod[k - i])
        else:
            t += (mod[i] // 2) * 2
    # 处理余数为 0 的元素
    t += mod[0] // 2 * 2
    # 处理不能被分组的余数
    if k % 2 == 0:
        t += mod[k // 2] // 2 * 2
    j = 0
    # 将能够被整除的元素放到最前面
    for i in range(1, k // 2 + 1):
        while mod[i] >= 2:
            ans[j] = i
            ans[n - j - 1] = k - i
            j += 1
            mod[i] -= 2
    if k % 2 == 0:
        while mod[k // 2] >= 2:
            ans[j] = k // 2
            ans[n - j - 1] = k // 2
            j += 1
            mod[k // 2] -= 2
    # 处理余数为 0 的元素
    for i in range(n):
        if j >= n // 2:
            break
        if a[i] % k == 0:
            ans[j] = a[i]
            j += 1
    # 处理不能被分组的余数
    for i in range(1, k // 2 + 1):
        if j >= n // 2:
            break
        if mod[i] == 1 and mod[k - i] == 1:
            ans[j] = i
            ans[n - j - 1] = k - i
            j += 1
    # 将剩下的元素放在后面
    for i in range(n):
        if ans[i] == 0:
            ans[i] = a[i]
    return ans

这个方法的时间复杂度是 O(N)，其中 N 是数组的长度。相较于第一种方法，它的效率更高，并且可以处理更多的情况。