2026-05-19：增加操作后最大按位与的结果。用go语言，已知一个整数数组 nums，以及两个整数 k 和 m。你可以进行至多 k 次操作：每次操作

package main

import (
    "fmt"
    "math/bits"
    "slices"
)

func maximumAND(nums []int, k, m int) (ans int) {
    slices.Sort(nums)
    n := len(nums)
    maxAns := nums[n-1] + k/m
    if nums[n-m] == nums[n-1] { // 最大的 m 个数都相等
        return maxAns
    }

    ops := make([]int, n) // 每个数的操作次数
    maxWidth := bits.Len(uint(maxAns))
    for bit := maxWidth - 1; bit >= 0; bit-- {
        target := ans | 1<<bit // 注意 target 要带着 ans 已经填好的 1
        for i, x := range nums {
            j := bits.Len(uint(target &^ x))
            // j-1 是从高到低第一个 target 是 1 且 x 是 0 的比特位
            // target = 10110
            //      x = 11010
            //            ^
            //           j-1
            // x 二进制中的高于 j-1 的位不变，其余位增大到和 target 一样
            // 上面的例子要把 010 变成 110
            mask := 1<<j - 1
            ops[i] = target&mask - x&mask
        }

        // 贪心，取前 m 小的操作次数
        slices.Sort(ops)
        sum := 0
        for _, x := range ops[:m] {
            sum += x
        }
        if sum <= k {
            ans = target // 答案的 bit 位可以填 1
        }
    }
    return
}

func main() {
    nums := []int{3, 1, 2}
    k := 8
    m := 2
    result := maximumAND(nums, k, m)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

def maximumAND(nums, k, m):
    nums.sort()
    n = len(nums)
    maxAns = nums[n-1] + k // m
    
    # 最大的 m 个数都相等
    if nums[n-m] == nums[n-1]:
        return maxAns
    
    ans = 0
    ops = [0] * n  # 每个数的操作次数
    maxWidth = maxAns.bit_length()
    
    for bit in range(maxWidth - 1, -1, -1):
        target = ans | (1 << bit)  # 注意 target 要带着 ans 已经填好的 1
        
        for i, x in enumerate(nums):
            # j 是从高到低第一个 target 是 1 且 x 是 0 的比特位
            # 计算 target &^ x 的最高位位置
            diff = target & ~x
            if diff == 0:
                j = 0
            else:
                j = diff.bit_length()
            
            # x 二进制中的高于 j-1 的位不变，其余位增大到和 target 一样
            mask = (1 << j) - 1
            ops[i] = (target & mask) - (x & mask)
        
        # 贪心，取前 m 小的操作次数
        ops.sort()
        total_sum = sum(ops[:m])
        
        if total_sum <= k:
            ans = target  # 答案的 bit 位可以填 1
    
    return ans


if __name__ == "__main__":
    nums = [3, 1, 2]
    k = 8
    m = 2
    result = maximumAND(nums, k, m)
    print(result)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <bitset>

using namespace std;

int maximumAND(vector<int>& nums, int k, int m) {
    sort(nums.begin(), nums.end());
    int n = nums.size();
    int maxAns = nums[n - 1] + k / m;

    // 最大的 m 个数都相等
    if (nums[n - m] == nums[n - 1]) {
        return maxAns;
    }

    int ans = 0;
    vector<int> ops(n, 0);  // 每个数的操作次数
    int maxWidth = 32 - __builtin_clz(maxAns);  // 计算二进制位数

    for (int bit = maxWidth - 1; bit >= 0; bit--) {
        int target = ans | (1 << bit);  // 注意 target 要带着 ans 已经填好的 1

        for (int i = 0; i < n; i++) {
            int x = nums[i];
            // 计算 target & ^x 的最高位位置
            int diff = target & ~x;
            int j = 0;
            if (diff != 0) {
                j = 32 - __builtin_clz(diff);  // 计算 diff 的二进制位数
            }
            // j-1 是从高到低第一个 target 是 1 且 x 是 0 的比特位
            // target = 10110
            //      x = 11010
            //            ^
            //           j-1
            // x 二进制中的高于 j-1 的位不变，其余位增大到和 target 一样
            // 上面的例子要把 010 变成 110
            int mask = (1 << j) - 1;
            ops[i] = (target & mask) - (x & mask);
        }

        // 贪心，取前 m 小的操作次数
        sort(ops.begin(), ops.end());
        int sum = 0;
        for (int i = 0; i < m; i++) {
            sum += ops[i];
        }

        if (sum <= k) {
            ans = target;  // 答案的 bit 位可以填 1
        }
    }

    return ans;
}

int main() {
    vector<int> nums = {3, 1, 2};
    int k = 8;
    int m = 2;
    int result = maximumAND(nums, k, m);
    cout << result << endl;
    return0;
}