使一个数组的所有元素乘以另一个数组所需的最小前缀增量

问题描述

给定两个长度为n的数组A和B，目标是将数组A的所有元素分别乘以数组B中对应的元素，使得A的所有元素都是B中元素的倍数，求此时A数组的前缀和需要增加多少。

例如，给定数组A=[2, 4, 6, 8]和数组B=[2, 3, 1, 2]，计算A数组所有元素分别乘以B数组元素之后，使得A的前缀和增加的最小值是多少。具体计算过程如下：

• 将A数组中的每个元素分别乘以B数组中的相应元素，得到A'=[4, 12, 6, 16]；
• 对A'进行前缀求和，得到前缀和数组C=[4, 16, 22, 38]；
• 按照题目要求，使得C的每一个元素都是2的倍数；
• 对C进行前缀求和，得到新的前缀和数组D=[4, 20, 42, 80]；
• 使D的每个元素都是2的倍数，需要将D中的第二个元素增加4、第三个元素增加2、第四个元素增加2，最终得到的D数组就是A数组所有元素分别乘以B数组元素之后最小的增量。

因此，所求答案为8。

解决方案

解决此类问题的第一步是要找到问题的本质。实际上，我们可以将问题转化为以下等价的形式：给定一个长度为n的数组C，找到一个长度为n的数组D，使得D的每个元素都是2的倍数，且满足C xor D的前缀和最小。其中，xor表示按位异或运算。

具体的，对于一个长度为n的数组A，若数组C=[C1, C2, ..., Cn]为C=Ab，即Ci=Aibi，数组D=[D1, D2, ..., Dn]为D=Ac，即Di=Aici，其中bi和ci的值都是2的整数幂（即只包含0和1），则有C xor D=[C1 xor D1, C2 xor D2, ..., Cn xor Dn]，C xor D的前缀和即为∑(1<=i<=n)(C xor D)[i]。因此，我们的目标是找到一个长度为n的数组D，使得D的每个元素都是2的倍数，且满足∑(1<=i<=n) (C xor D)[i]最小。

根据异或运算的性质，对于任意a、b、c，有(a xor b) xor c=a xor (b xor c)。因此，可以先将C和D的前缀异或起来，然后求异或后数组的子段最大值，将这些子段最大值之和减去C和D的前缀和之差即为所求答案。

具体实现时，可以使用前缀和和动态规划来解决问题。具体步骤如下：

1. 计算数组C的前缀和数组C_pre[i]=∑(1<=j<=i)C[j]；
2. 计算C和D的前缀和数组C_pre和D_pre；
3. 用动态规划算法求解D数组，设opt[i][j]表示将前i个元素转化为2的整数幂，第i个元素的值为2^j时，∑(1<=k<=i) (C xor D)[k]的最小值。则有opt[i][j]=min(opt[i-1][k]+V[i][j-k])，其中V[i][j-k]表示将第i个元素的值从2^(j-1)变为2^j需要增加的前缀和。
4. 最终答案为∑(1<=i<=n)(C xor D)[i]-∑(1<=i<=n)C[i]+∑(1<=i<=n)D[i]。

• 代码段:

def min_prefix_increment(A, B):
    n = len(A)
    C = [A[i] * B[i] for i in range(n)]
    C_pre = [C[0]] + [0] * (n - 1)
    for i in range(1, n):
        C_pre[i] = C_pre[i-1] + C[i]
    D = [0] * n
    opt = [[float("inf")] * 32 for _ in range(n)]
    for i in range(n):
        for j in range(32):
            if j == 0:
                V = C[i] % 2
            else:
                V = ((C[i] >> j) - (C[i] >> (j-1))) % 2
            if i == 0:
                opt[i][j] = V if V else 0
            else:
                for k in range(32):
                    if k >= j:
                        opt[i][j] = min(opt[i][j], opt[i-1][k] + V)
            if j == 0:
                D[i] = 2 * C_pre[i] if not V else 0
            else:
                D[i] += ((D[i] >> (j-1)) - (D[i] >> j)) * (1 << (j-1))
            opt[i][j] += D[i] - C_pre[i]
    ans = 0
    for i in range(n):
        ans += (C[i] ^ D[i])
    ans -= (C_pre[n-1] - C[0])
    ans += D[n-1]
    return ans

时间复杂度

使用前缀和算法需要O(n)的时间，使用动态规划算法需要O(n^3)的时间。因此，总时间复杂度为O(n^3)。

空间复杂度

需要n个元素的数组C、C_pre、D，32*n个元素的二维数组opt。因此，总空间复杂度为O(n^2)。

参考资料

• aops
• codeforces