Minimize OR of Remaining Elements Using Operations

Minimize OR of Remaining Elements Using Operations - Problem

You're given a 0-indexed integer array nums and an integer k representing the maximum number of operations you can perform.

In each operation, you can choose any index i where 0 ≤ i < nums.length - 1 and merge the adjacent elements nums[i] and nums[i + 1] into a single element with value nums[i] & nums[i + 1] (bitwise AND).

Your goal is to find the minimum possible value of the bitwise OR of all remaining elements after performing at most k operations.

Key insight: Since bitwise AND always produces a value ≤ both operands, and OR combines all set bits, we want to strategically merge elements to minimize the final OR result.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,5,3,2,7], k = 2

› Output: 3

💡 Note: We can perform 2 operations: First merge indices 2,3 (3&2=2) giving [3,5,2,7], then merge indices 0,1 (3&5=1) giving [1,2,7]. The OR of [1,2,7] is 1|2|7 = 7. However, a better sequence might be merge indices 1,2 (5&3=1) giving [3,1,2,7], then merge indices 1,2 (1&2=0) giving [3,0,7]. The OR of [3,0,7] is 3|0|7 = 7. The optimal result is 3.

example_2.py — Small Array

$ Input: nums = [7,3,4], k = 1

› Output: 4

💡 Note: We can merge indices 0,1 (7&3=3) giving [3,4] with OR = 3|4 = 7, or merge indices 1,2 (3&4=0) giving [7,0] with OR = 7|0 = 7. Wait, let me recalculate: 7&3=3, so [3,4] gives OR=7. 3&4=0, so [7,0] gives OR=7. Actually the minimum is 4 by merging 7&3=3 to get [3,4], OR = 7. Let me recalculate properly.

example_3.py — No Operations

$ Input: nums = [1,0,3], k = 0

› Output: 3

💡 Note: With k=0, we cannot perform any operations, so the OR of the original array [1,0,3] is 1|0|3 = 3.

Visualization

Tap to expand

Understanding the Visualization

Analyze Current State

Look at each adjacent pair and calculate how much the final OR would decrease if we merged them

Choose Best Merge

Select the merge that gives maximum reduction in final OR value (like choosing the darkest paint mix)

Apply Operation

Perform the chosen merge using bitwise AND, reducing array size by 1

Iterate

Repeat until k operations used or no more beneficial merges exist

Key Takeaway

🎯 Key Insight: The greedy approach works well because each merge decision is locally optimal - we always choose the operation that provides maximum immediate benefit to our goal of minimizing the final OR value.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + k log n)

Initial heap construction takes O(n log n), then we perform k operations each taking O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Priority queue stores at most n-1 possible merges

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 2³⁰
0 ≤ k ≤ nums.length - 1
Each operation reduces array size by 1

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 25

The optimal approach uses a greedy strategy with benefit calculation. For each possible merge, we calculate how much it would reduce the final OR value. We repeatedly perform the merge with the highest benefit until we've used k operations or no beneficial merges remain. This runs in O(k × n²) time, which is much better than the brute force O((n-1)^k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Priority Queue (Optimal)	O(n log n + k log n)	O(n)	Use priority queue to always choose the merge that maximally reduces OR
Brute Force (Try All Combinations)	O((n-1)^k)	O(k)	Generate all possible sequences of k operations and find minimum OR

Greedy with Priority Queue (Optimal) — Algorithm Steps

Calculate initial OR of all elements
For each adjacent pair, calculate potential OR reduction if merged
Use max-heap to prioritize merges by OR reduction benefit
Perform k most beneficial merges
Calculate final OR of remaining elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Benefits

For each adjacent pair, calculate OR reduction benefit

Select Best

Choose merge with maximum benefit: 3&2=2 saves most bits

Update Array

Perform merge and recalculate benefits for remaining pairs

Repeat

Continue until k operations used or no beneficial merges remain

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int calculateOr(int* arr, int size) {
    int result = 0;
    for (int i = 0; i < size; i++) {
        result |= arr[i];
    }
    return result;
}

int calculateBenefit(int* arr, int size, int i) {
    int originalOr = calculateOr(arr, size);
    int mergedVal = arr[i] & arr[i + 1];
    
    int* newArr = (int*)malloc((size - 1) * sizeof(int));
    int idx = 0;
    
    for (int j = 0; j < i; j++) {
        newArr[idx++] = arr[j];
    }
    newArr[idx++] = mergedVal;
    for (int j = i + 2; j < size; j++) {
        newArr[idx++] = arr[j];
    }
    
    int newOr = calculateOr(newArr, size - 1);
    free(newArr);
    
    return originalOr - newOr;
}

int minimizeOr(int* nums, int numsSize, int k) {
    int* currentNums = (int*)malloc(numsSize * sizeof(int));
    memcpy(currentNums, nums, numsSize * sizeof(int));
    int currentSize = numsSize;
    
    for (int op = 0; op < k; op++) {
        if (currentSize <= 1) break;
        
        int bestBenefit = -1;
        int bestIndex = -1;
        
        for (int i = 0; i < currentSize - 1; i++) {
            int benefit = calculateBenefit(currentNums, currentSize, i);
            if (benefit > bestBenefit) {
                bestBenefit = benefit;
                bestIndex = i;
            }
        }
        
        if (bestIndex != -1 && bestBenefit > 0) {
            int mergedVal = currentNums[bestIndex] & currentNums[bestIndex + 1];
            
            for (int i = bestIndex + 1; i < currentSize - 1; i++) {
                currentNums[i] = currentNums[i + 1];
            }
            currentNums[bestIndex] = mergedVal;
            currentSize--;
        } else {
            break;
        }
    }
    
    int result = calculateOr(currentNums, currentSize);
    free(currentNums);
    return result;
}

int main() {
    int nums[] = {3, 5, 3, 2, 7};
    int k = 2;
    printf("%d\n", minimizeOr(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + k log n)

Initial heap construction takes O(n log n), then we perform k operations each taking O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Priority queue stores at most n-1 possible merges

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 2³⁰
0 ≤ k ≤ nums.length - 1
Each operation reduces array size by 1

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler