力扣3171.找到最近或最接近k的子数组--模板题（从O(n²）到O(nlogU)）-优快云博客

本文链接：https://blog.youkuaiyun.com/ying_yusi/article/details/142832108

上来我首先想的是滑动窗口，然而发现因为或运算不存在逆运算，所以其实是没有办法用常规的滑动窗口来进行计算的。在灵神的题解中，有一个方法是滑动窗口，不过我现在水平不够，暂且搁置

考虑暴力做法：

只有三个元素：

很明显就是遍历所有的子数组，从 [0] 到 [0] ,从 [0] 到 [1] ,从 [0] 到 [2]，从 [1] 到 [1] ，从 [1] 到 [2]，从[2]到[2]，得到的所有子数组的值和k进行或运算，假设数组元素的值分别是：1,3,4

因为常规的遍历方式是左序号增大，然后增大右序号，即只有在左序号固定的情况下把所有的可能的子数组都遍历完毕才进行增加，这种遍历方式得到的子数组的值是：

从 [0] 到 [0] ：1

从 [0] 到 [1] ：1|3

从 [0] 到 [2]：1|3|4

从 [1] 到 [1] ：3

从 [1] 到 [2]：3|4

从 [2] 到 [2]：4

这是没什么规律的

但是换个想法，先固定右序号，再增加左序号，得到的序列值是：

从 [0] 到 [0] ：1

从 [0] 到 [1] ：1|3

从 [1] 到 [1] ：3

从 [2] 到 [2]：4

从 [1] 到 [2]：3|4

从 [0] 到 [2]：1|3|4

发现，其实 1 | 3 | 4 可以从 1 | 3 再or个 4 计算得来

使用一个数组来保存或运算的结果，称为or_num

设立一个变量i来遍历nums的右端点（枚举右，维护左）

在遍历到1的时候，or_num数组：

1 [] []

在遍历到3的时候：

1|3 3 []

在遍历到4的时候：

1|3|4 3|4 4

恰好对应了所有的子数组的按位或的值

可以写出如下代码：

class Solution {
public:
    int minimumDifference(vector<int>& nums, int k) {
        int ans=INT_MAX;
        vector<int> or_num(nums.size());
        for(int i=0;i<nums.size();i++){
            for(int j=i;j>=0;j--){
                if(i==j){
                    or_num[j]=nums[j];
                }
                else{
                    or_num[j]=or_num[j] | nums[i];
                }
                ans=min(ans,abs(k-or_num[j]));
            }
        }
        return ans;
    }
};

这个代码可以过大部分的用例了，剩下几个会超时，那么需要优化

(其实仔细一想，这个算法的复杂度还是n²。。)

以下是我本人应该是完全想不到的做法：

因为我们这个做法，是不断按位与，假设有四个数a,b,c,d，我们的计算结果依次是：

a|b b

a|b|c b|c c

a|b|c|d b|c|d c|d d

考虑在计算第四行的时候，如果c&d=c，会发生什么？

在这种情况下，我们可以化简为：

a|b b

a|b|c b|c c

a|b|c b|c c d

第四行的前三个值是和第三行一样的

所以,为了方便循环的计算，我们在遇到出现c&d=d这种情况，即or_num[i] | nums[j] 的时候，就可以不用再遍历当前这一层了，可以直接break掉,从而节省了运行的时间

AC代码：

class Solution {
public:
    int minimumDifference(vector<int>& nums, int k) {
        int ans=INT_MAX;
        vector<int> or_num(nums.size());
        for(int i=0;i<nums.size();i++){
            int flag=1;
            for(int j=i;j>=0;j--){
                if(i==j){
                    or_num[j]=nums[j];
                }
                else{
                    flag=(or_num[j] | nums[i]) - or_num[j];
                    or_num[j]=or_num[j] | nums[i];
                }
                ans=min(ans,abs(k-or_num[j]));
                if(!flag) break;
            }
        }
        return ans;
    }
};

不妨来考虑一下，为什么在这种情况下，时间复杂度会是O(nlongU)?(U是当前nums数组的最大值)

我们每次更新or_num[i]，都必然是让当前的这个or_num[i]变大

那么，这个变大是否是有上限的？

当然有，题目里给出了，1 <= nums[i] <= $10^9$