算法：非负数组中两个数相与的最大结果

题目描述

给定一个非负数组成的数组，长度一定大于1
想知道数组中哪两个数&的结果最大

返回这个最大结果

时间复杂度O(N),额外空间复杂度O(1)

题目解析

分析

• 这里可以用前缀树来实现，但是要求额外空间复杂度O(1)

思路

• 一个int来说可以写成一个31位的二进制数

• 贪心：
  • 从30位开始尽量让高位变1（因为是非负整数，所以不用考虑符号位）
  • 因为如果选一些数让30位变成0，它就不如让30位变成0的值大

步骤

• 先遍历一遍所有的数字，只考察第30位是1的有几个，分情况
  • 1）<=1个，说明第30位肯定不是1（1&0=0，0&0=0），所以这些数一个也不淘汰
  • 2）刚好2个，就是这两个数相与最大，直接返回即可
  • 3）大于2个。比如如果有23个数第30位是1，那么淘汰剩下的那些数，只保留这23个数

• 接着遍历这32个数，只考察第29位是1的有几个…

时间复杂度：考虑最难的情况，假如每次都不淘汰数字，那么一个需要遍历32次个N，因此时间复杂度是O(32N)

因为空间复杂度要求O(1)，所以我们应该在原数组上操作。

• 那应该怎么淘汰数组呢？在最右边维护一个垃圾区
• 如果发现某个数应该被淘汰，那么就将它交换到右边去

实现

// 时间复杂度O(N)
int maxAndValue(std::vector<int>  arr){
    int M = arr.size();
    int ans = 0;
    for (int bit = 30; bit >= 0; --bit) {
        int tmp = M; //还剩下M个数

        int i = 0;
        while (i < M){ // arr[0...M-1]
            if((arr[i] & (1 << bit)) == 0){
                std::swap(arr[i], arr[--M]);//需要淘汰
            }else{
                i++;
            }
        }


        //还剩下M个数
        if(M == 2){
            return arr[0] & arr[1];
        }
        if(M < 2){//不淘汰
            M = tmp;
        }else{ // > 2个数  bit位上有1
            ans |= (1 << bit);
        }
    }
    return ans;
}

对数器

// O(N^2)的暴力解
int maxAndValue_test(std::vector<int>  arr){
    int M = arr.size();
    int max = INT32_MIN;
    for (int i = 0; i < M; ++i) {
        for (int j = i + 1; j < M; ++j) {
            max = std::max(max, arr[i] & arr[j]);
        }
    }
    return max;
}

std::default_random_engine e;
std::vector<int>  generateRandom(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(2, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    std::vector<int> arr;
    int size = distS(e);
    arr.resize(size);
    for (int i = 0; i < size; ++i) {
        arr[i] = distV(e);
    }

    return arr;
}
int showbit2(int a){
    int ret = 0;
    while(a){
        ret = ret*10 + (a % 2);
        a = a / 2;
    }
    return ret;
}
template<typename T>
void display(std::vector<T>& vec) {
    for (auto it: vec) {
        std::cout << it  << "("<< showbit2(it) << "),";
    }
    std::cout << "\n";
}
int main() {
    e.seed(time(NULL));
    int testCount(100);    // epoch
    int maxSize(1000);    // max size of the vector
    int minValue(0);
    int maxValue(1000);     // maxvalue
    for (int i = 0; i < testCount; ++i) {
        std::vector<int> vec1 = generateRandom(maxSize,  minValue, maxValue);
        int ans1 = maxAndValue_test(vec1);
        int ans2 = maxAndValue(vec1);
        if(ans1 != ans2){
            printf("error!  right : %d, but : %d. test arr:\n", ans1, ans2);
            display(vec1);
            return 0;
        }
    }


    printf("finish!");
    return 0;
}