Minimum Sum of Values by Dividing Array

Minimum Sum of Values by Dividing Array - Problem

Array Binary Search Dynamic Programming Bit Manipulation Segment Tree Queue Hard

You are given two arrays nums and andValues of length n and m respectively.

The value of an array is equal to the last element of that array.

You have to divide nums into m disjoint contiguous subarrays such that for the i-th subarray [l_i, r_i], the bitwise AND of the subarray elements is equal to andValues[i].

In other words: nums[l_i] & nums[l_i + 1] & ... & nums[r_i] == andValues[i] for all 1 <= i <= m, where & represents the bitwise AND operator.

Return the minimum possible sum of the values of the m subarrays nums is divided into. If it is not possible to divide nums into m subarrays satisfying these conditions, return -1.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,4,3,3,2], andValues = [0,3,3,2]

› Output: 12

💡 Note: Divide into [1,4], [3], [3], [2]. AND values: 1&4=0, 3=3, 3=3, 2=2. Sum of last elements: 4+3+3+2=12.

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Cannot divide array into 3 subarrays with required AND values.

Example 3 — Single Elements

$ Input: nums = [1,2,3,4], andValues = [2]

› Output: -1

💡 Note: No single subarray can have AND value of 2 from these elements.

Constraints

1 ≤ n == nums.length ≤ 10⁴
1 ≤ m == andValues.length ≤ min(n, 10)
1 ≤ nums[i] < 10⁵
0 ≤ andValues[i] < 10⁵

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is to use dynamic programming with memoization to explore all valid array divisions efficiently. The AND operation has the property that it can only decrease or stay the same as we extend a subarray. Best approach is memoization with state (index, group, current_and). Time: O(n × m × 2^20), Space: O(n × m × 2^20)

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(2^n) Space: O(n)

Use recursion to try every possible division point. For each position, try to form a subarray that matches the required AND value, then recursively solve for the remaining array.

Dynamic Programming with Memoization

⏱️ Time: O(n × m × 2^20) Space: O(n × m × 2^20)

Use memoization to store results of subproblems defined by current index, group number, and current AND value. This eliminates redundant calculations in the recursive approach.

Brute Force Recursion — Algorithm Steps

Try each possible starting position for current subarray
Check if AND of subarray equals required value
If yes, recursively solve for remaining array
Return minimum sum among all valid divisions

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Division

Attempt to split array at each position

Check AND

Verify if subarray AND matches required value

Recurse

If valid, solve remaining array recursively

Code -

solution.c — C

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

#define MAX_N 10001
#define MAX_M 11
#define MAX_AND 100001

// Memoization using a hash map approach
// Key: (idx, group, currentAnd) -> value
typedef struct {
    int idx, group, currentAnd;
    int value;
    int valid;
} MemoEntry;

#define MEMO_SIZE 200003
MemoEntry memo[MEMO_SIZE];

void clearMemo() {
    memset(memo, 0, sizeof(memo));
}

unsigned int hashKey(int idx, int group, int currentAnd) {
    unsigned int h = idx * 100001 + currentAnd;
    h = h * 11 + group;
    return h % MEMO_SIZE;
}

int getMemo(int idx, int group, int currentAnd) {
    unsigned int h = hashKey(idx, group, currentAnd);
    for (int i = 0; i < 20; i++) {  // Linear probing
        int pos = (h + i) % MEMO_SIZE;
        if (!memo[pos].valid) return -2;  // Not found
        if (memo[pos].idx == idx && memo[pos].group == group && memo[pos].currentAnd == currentAnd) {
            return memo[pos].value;
        }
    }
    return -2;
}

void setMemo(int idx, int group, int currentAnd, int value) {
    unsigned int h = hashKey(idx, group, currentAnd);
    for (int i = 0; i < 20; i++) {
        int pos = (h + i) % MEMO_SIZE;
        if (!memo[pos].valid) {
            memo[pos].idx = idx;
            memo[pos].group = group;
            memo[pos].currentAnd = currentAnd;
            memo[pos].value = value;
            memo[pos].valid = 1;
            return;
        }
    }
}

int* g_nums;
int* g_andValues;
int g_n, g_m;

int dp(int idx, int group, int currentAnd) {
    // Successfully filled all m groups
    if (group == g_m) {
        return (idx == g_n) ? 0 : INT_MAX;
    }
    
    // Ran out of elements but still have groups to fill
    if (idx == g_n) {
        return INT_MAX;
    }
    
    // Pruning: not enough elements left for remaining groups
    if (g_n - idx < g_m - group) {
        return INT_MAX;
    }
    
    // Check memo
    int cached = getMemo(idx, group, currentAnd);
    if (cached != -2) {
        return cached;
    }
    
    // Update AND with current element
    int newAnd;
    if (currentAnd == -1) {
        newAnd = g_nums[idx];
    } else {
        newAnd = currentAnd & g_nums[idx];
    }
    
    int result = INT_MAX;
    int target = g_andValues[group];
    
    // Pruning: if newAnd is already less than target (in terms of bits),
    // and since AND can only turn bits OFF, we can never reach target
    if ((newAnd & target) != target) {
        setMemo(idx, group, currentAnd, INT_MAX);
        return INT_MAX;
    }
    
    // Option 1: End current subarray here if AND equals target
    if (newAnd == target) {
        int subResult = dp(idx + 1, group + 1, -1);
        if (subResult != INT_MAX) {
            int sum = g_nums[idx] + subResult;
            if (sum < result) {
                result = sum;
            }
        }
    }
    
    // Option 2: Continue current subarray (extend it)
    int continueResult = dp(idx + 1, group, newAnd);
    if (continueResult < result) {
        result = continueResult;
    }
    
    setMemo(idx, group, currentAnd, result);
    return result;
}

int minimumValueSum(int* nums, int numsSize, int* andValues, int andValuesSize) {
    g_nums = nums;
    g_andValues = andValues;
    g_n = numsSize;
    g_m = andValuesSize;
    
    clearMemo();
    
    int result = dp(0, 0, -1);
    return (result == INT_MAX) ? -1 : result;
}

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

int main() {
    char line[10000];
    int nums[MAX_N], numsSize;
    int andValues[MAX_M], andValuesSize;
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    parseArray(line, nums, &numsSize);
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    parseArray(line, andValues, &andValuesSize);
    
    printf("%d\n", minimumValueSum(nums, numsSize, andValues, andValuesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each position, we have choice to end subarray or continue, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

234 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler