Minimize OR of Remaining Elements Using Operations

Minimize OR of Remaining Elements Using Operations - Problem

You are given a 0-indexed integer array nums and an integer k.

In one operation, you can pick any index i of nums such that 0 <= i < nums.length - 1 and replace nums[i] and nums[i + 1] with a single occurrence of nums[i] & nums[i + 1], where & represents the bitwise AND operator.

Return the minimum possible value of the bitwise OR of the remaining elements of nums after applying at most k operations.

Input & Output

Example 1 — Basic Case

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

› Output: 15

💡 Note: We can merge adjacent elements using AND. For instance, merge 3&15=3, resulting in [7,3,14]. The OR of this array is 7|3|14 = 15.

Example 2 — Multiple Operations

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

› Output: 7

💡 Note: First operation: merge 10&7=2, getting [2,10,3,9]. Second operation: merge 10&3=2, getting [2,2,9]. Final OR: 2|2|9 = 11. Actually, better strategy gives OR = 7.

Example 3 — No Operations Needed

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

› Output: 5

💡 Note: Array has only one element, so no operations can be performed. The OR is simply 5.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ k ≤ nums.length - 1
1 ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 A Amazon 8

The key insight is that AND operations can only reduce bits, making strategic adjacent merges crucial for minimizing the final OR. The greedy approach works well by always choosing merges that result in the smallest OR value. Best approach achieves Time: O(k × n²), Space: O(n).

Common Approaches

✓ Brute Force - Try All Operation Sequences

⏱️ Time: O(n^k × n) Space: O(k)

Generate all possible ways to perform k operations and calculate the OR for each resulting array. This explores the complete search space but is extremely inefficient.

Greedy - Priority Queue Approach

⏱️ Time: O(k × n²) Space: O(n)

For each possible adjacent pair, calculate what the OR would be if we merged them. Use a priority queue to always choose the merge that results in the smallest OR value.

Optimized Bit Analysis

⏱️ Time: O(k × n × log(max(nums))) Space: O(n)

Instead of trying all combinations, analyze which bit positions can be eliminated through strategic AND operations. Focus on merging pairs that eliminate the most significant bits from the final OR.

Brute Force - Try All Operation Sequences — Algorithm Steps

Generate all valid operation sequences of length ≤ k
For each sequence, apply operations and calculate final OR
Return minimum OR found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Sequences

Create all possible operation sequences up to length k

Apply Operations

For each sequence, perform AND operations on adjacent pairs

Find Minimum

Calculate OR for each result and return minimum

Code -

solution.c — C

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

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

int backtrack(int* arr, int size, int operationsLeft) {
    if (operationsLeft == 0 || size <= 1) {
        return calculateOR(arr, size);
    }
    
    int minOR = calculateOR(arr, size);
    
    for (int i = 0; i < size - 1; i++) {
        int newVal = arr[i] & arr[i + 1];
        int* newArr = (int*)malloc((size - 1) * sizeof(int));
        int newSize = 0;
        
        for (int j = 0; j < i; j++) newArr[newSize++] = arr[j];
        newArr[newSize++] = newVal;
        for (int j = i + 2; j < size; j++) newArr[newSize++] = arr[j];
        
        int result = backtrack(newArr, newSize, operationsLeft - 1);
        if (result < minOR) minOR = result;
        
        free(newArr);
    }
    
    return minOR;
}

int solution(int* nums, int numsSize, int k) {
    return backtrack(nums, numsSize, k);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    parseArray(line, nums, &numsSize);
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k × n)

At each step we have up to n-1 choices, repeated k times, plus O(n) to calculate OR

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth up to k for exploring operation sequences

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Operation Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler