题目

标题和出处

标题：找到最接近目标值的函数值

出处：1521. 找到最接近目标值的函数值

难度

8 级

题目描述

要求

Winston 构造了一个如上所示的函数 $\text{func}$。他有一个整数数组 $\text{arr}$ 和一个整数 $\text{target}$，他想找到让 $|\text{func(arr, l, r)}-\text{target}|$ 最小的 $\text{l}$ 和 $\text{r}$。

返回 $|\text{func(arr, l, r)}-\text{target}|$ 的最小值。

注意 $\text{func}$ 的输入参数包含 $\text{l}$ 和 $\text{r}$，满足 $\text{0}\le \text{l, r}<\text{arr.length}$。

示例

示例 1：

输入：$\text{arr = [9,12,3,7,15], target = 5}$
输出：$\text{2}$
解释：所有可能的 $\text{[l,r]}$ 数对包括 $\text{[[0,0],[1,1],[2,2],[3,3],[4,4],[0,1],[1,2],[2,3],[3,4],[0,2],[1,3],[2,4],[0,3],[1,4],[0,4]]}$，Winston 得到的相应结果为 $\text{[9,12,3,7,15,8,0,3,7,0,0,3,0,0,0]}$。最接近 $\text{5}$ 的值是 $\text{7}$ 和 $\text{3}$，所以最小差值为 $\text{2}$。

示例 2：

输入：$\text{arr = [1000000,1000000,1000000], target = 1}$
输出：$\text{999999}$
解释：Winston 输入函数的所有可能 $\text{[l,r]}$ 数对得到的函数值都为 $\text{1000000}$，所以最小差值为 $\text{999999}$。

示例 3：

输入：$\text{arr = [1,2,4,8,16], target = 0}$
输出：$\text{0}$

数据范围

• $\text{1}\le \text{arr.length}\le {\text{10}}^{\text{5}}$
• $\text{1}\le \text{arr[i]}\le {\text{10}}^{\text{6}}$
• $\text{0}\le \text{target}\le {\text{10}}^{\text{7}}$

解法

思路和算法

用 $n$ 表示数组 $\text{arr}$ 的长度。如果枚举所有的下标对 $(l,r)$，则时间复杂度至少是 $O(n^2)$，该时间复杂度过高，需要优化。

如果子数组的右侧端点 $r$ 固定，分别考虑两个左侧端点 $l_1$ 和 $l_2$ 对应的函数值。当 $l_1<l_2\le r$ 时，记 $v_1=\text{func}(\text{arr},l_1,r)$，$v_2=\text{func}(\text{arr},l_2,r)$，则一定有 $v_1\le v_2$，理由如下。

对于 $c=a\&b$，考虑二进制表示的每一位，只有当 $a$ 和 $b$ 在同一位的值都是 $1$ 时，$c$ 在该位的值才是 $1$，否则 $c$ 在该位的值是 $0$，因此 $c\le a$ 且 $c\le b$。根据 $\text{func}$ 的定义有 $v_1=v_2\&(\text{arr}[l_1]\&\text{arr}[l_1+1]\&\dots \&\text{arr}[l_2-1])$，利用按位与运算的性质可得 $v_1\le v_2$。

因此，当子数组的右侧端点固定时，当左侧端点向左移动时函数值不变或减少，当左侧端点向右移动时函数值不变或增加。当左侧端点向左移动时，函数值的二进制表示的每一位只可能不变或从 $1$ 变成 $0$，不可能从 $0$ 变成 $1$，因此当子数组的右侧端点 $r$ 固定时，不同的函数值个数不超过 $O(\log \text{arr}[r])$。

用 $m$ 表示数组 $\text{arr}$ 的最大值。利用上述结论，将数组 $\text{arr}$ 中的每个元素作为子数组的右侧端点时只需要考虑 $O(\log m)$ 个不同的函数值，不需要考虑 $O(n)$ 个不同的函数值，可以将时间复杂度从 $O(n^2)$ 降低到 $O(n\log m)$。

具体做法是，将子数组的右侧端点初始化为 $0$，此时函数值为 $\text{arr}[0]$，计算 $|\text{arr}[0]-\text{target}|$，作为函数值与目标值的最小差值。对于 $i$ 从 $1$ 到 $n-1$，将 $i$ 作为子数组的右侧端点，当前轮的函数值包括上一轮的每个函数值分别与 $\text{arr}[i]$ 的按位与运算结果，以及 $\text{arr}[i]$，计算当前轮的每个函数值与目标值的差的绝对值，更新最小差值。

实现方面，区分上一轮的函数值和当前轮的函数值的做法有多种，可以创建两个列表分别存储上一轮的函数值和当前轮的函数值，也可以使用队列存储函数值。使用队列的做法如下。

1. 当遍历到 $\text{arr}[i]$ 时，队列中的元素为上一轮的所有函数值，记录此时队列的大小 $\text{size}$。

2. 将 $\text{size}$ 个元素出队列，将每个出队列的元素和 $\text{arr}[i]$ 做按位与运算得到当前轮的函数值，将当前轮的函数值入队列。

3. 最后将 $\text{arr}[i]$ 入队列，表示 $l=r=i$ 的情况下对应的函数值。

将当前轮的函数值入队列时需要排除重复元素。由于遍历函数值的顺序具有单调性，因此相等的函数值在遍历顺序中一定相邻，每次将函数值入队列时判断当前函数值与上一个入队列的函数值是否相等，即可排除重重复元素。

代码

class Solution {
    public int closestToTarget(int[] arr, int target) {
        int minDiff = Math.abs(arr[0] - target);
        Queue<Integer> queue = new ArrayDeque<Integer>();
        queue.offer(arr[0]);
        int length = arr.length;
        for (int i = 1; i < length; i++) {
            int num = arr[i];
            int size = queue.size();
            int lastVal = -1;
            for (int j = 0; j < size; j++) {
                int prevVal = queue.poll();
                int currVal = prevVal & num;
                if (currVal != lastVal) {
                    minDiff = Math.min(minDiff, Math.abs(currVal - target));
                    queue.offer(currVal);
                    lastVal = currVal;
                }
            }
            if (num != lastVal) {
                minDiff = Math.min(minDiff, Math.abs(num - target));
                queue.offer(num);
            }
        }
        return minDiff;
    }
}

复杂度分析

• 时间复杂度：$O(n\log m)$，其中 $n$ 是数组 $\text{arr}$ 的长度，$m$ 是数组 $\text{arr}$ 的最大值。遍历数组的过程中，对于每个元素需要 $O(\log m)$ 的时间计算以当前元素作为结尾的所有函数值，因此时间复杂度是 $O(n\log m)$。

• 空间复杂度：$O(\log m)$，其中 $m$ 是数组 $\text{arr}$ 的最大值。空间复杂度主要取决于队列，队列中的元素个数不超过 $O(\log m)$。