Find the Maximum Sequence Value of Array

Find the Maximum Sequence Value of Array - Problem

You are given an integer array nums and a positive integer k.

The value of a sequence seq of size 2 * x is defined as:

(seq[0] OR seq[1] OR ... OR seq[x - 1]) XOR (seq[x] OR seq[x + 1] OR ... OR seq[2 * x - 1])

Return the maximum value of any subsequence of nums having size 2 * k.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,6,7], k = 1

› Output: 5

💡 Note: Choose subsequence [2,7]. First half: OR(2) = 2. Second half: OR(7) = 7. XOR: 2 ^ 7 = 5

Example 2 — Larger k

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

› Output: 2

💡 Note: Choose subsequence [4,5,6,7]. First half: OR(4,5) = 5. Second half: OR(6,7) = 7. XOR: 5 ^ 7 = 2

Example 3 — All Same Values

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

› Output: 0

💡 Note: Any subsequence gives OR(3,3) = 3 for both halves. XOR: 3 ^ 3 = 0

Constraints

1 ≤ k ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 2⁶
nums.length is even
2 * k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is to use dynamic programming to efficiently build all possible OR combinations for subsequences of each size, then find the maximum XOR between two sets of size k. The optimal approach uses space-optimized DP with pruning. Time: O(n * k * V), Space: O(k * V).

Common Approaches

✓ Brute Force - Generate All Subsequences

⏱️ Time: O(C(n,2k) * k) Space: O(1)

For each possible subsequence of size 2k, split it into two halves, compute OR of each half, then XOR the results. Track the maximum value found.

Dynamic Programming with Bitmask

⏱️ Time: O(n * k * V²) Space: O(n * k * V)

Build a DP table where dp[i][j][mask] represents whether we can achieve OR value 'mask' using j elements from first i elements. Then combine results optimally.

Optimized DP with Early Pruning

⏱️ Time: O(n * k * V) Space: O(k * V)

Use space-optimized DP with early pruning of impossible states and bit manipulation tricks to reduce both time and space complexity.

Brute Force - Generate All Subsequences — Algorithm Steps

Step 1: Generate all combinations of 2k elements from nums
Step 2: For each combination, split into two halves of size k
Step 3: Compute OR of first k elements and OR of last k elements
Step 4: XOR the two OR results and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose 2k elements

Split & Compute OR

Split each combination into two halves and compute OR of each

XOR & Track Max

XOR the two OR results and keep track of maximum

Code -

solution.c — C

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

static int combinations[1000][20];
static int combCount;
static int kcombinations[1000][10];
static int kcombCount;

void getCombinations(int* candidates, int candSize, int k, int* current, int currentSize, int start) {
    if (currentSize == k) {
        for (int i = 0; i < k; i++) {
            combinations[combCount][i] = current[i];
        }
        combCount++;
        return;
    }
    
    for (int i = start; i < candSize; i++) {
        current[currentSize] = candidates[i];
        getCombinations(candidates, candSize, k, current, currentSize + 1, i + 1);
    }
}

void getKCombinations(int* candidates, int candSize, int k, int* current, int currentSize, int start) {
    if (currentSize == k) {
        for (int i = 0; i < k; i++) {
            kcombinations[kcombCount][i] = current[i];
        }
        kcombCount++;
        return;
    }
    
    for (int i = start; i < candSize; i++) {
        current[currentSize] = candidates[i];
        getKCombinations(candidates, candSize, k, current, currentSize + 1, i + 1);
    }
}

int contains(int* arr, int size, int val) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == val) return 1;
    }
    return 0;
}

int solution(int* nums, int numsSize, int k) {
    int maxValue = 0;
    
    // Generate indices
    int indices[100];
    for (int i = 0; i < numsSize; i++) {
        indices[i] = i;
    }
    
    // Generate all combinations of 2k elements
    combCount = 0;
    int current[20];
    getCombinations(indices, numsSize, 2 * k, current, 0, 0);
    
    for (int c = 0; c < combCount; c++) {
        // Try all ways to split 2k elements into two groups of k
        kcombCount = 0;
        int kcurrent[10];
        getKCombinations(combinations[c], 2 * k, k, kcurrent, 0, 0);
        
        for (int kc = 0; kc < kcombCount; kc++) {
            int secondHalf[10];
            int secondSize = 0;
            
            for (int i = 0; i < 2 * k; i++) {
                if (!contains(kcombinations[kc], k, combinations[c][i])) {
                    secondHalf[secondSize++] = combinations[c][i];
                }
            }
            
            // Calculate OR of each half
            int or1 = 0;
            for (int i = 0; i < k; i++) {
                or1 |= nums[kcombinations[kc][i]];
            }
            
            int or2 = 0;
            for (int i = 0; i < secondSize; i++) {
                or2 |= nums[secondHalf[i]];
            }
            
            // XOR the results
            int value = or1 ^ or2;
            if (value > maxValue) {
                maxValue = value;
            }
        }
    }
    
    return maxValue;
}

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[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    parseArray(line, nums, &numsSize);
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,2k) * k)

C(n,2k) combinations, each requiring O(k) operations to compute ORs

✓ Linear Growth

Space Complexity

O(1)

Only storing current maximum and temporary variables

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

485 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 - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler