We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Minimum Sum of Values by Dividing Array

Difficulty: Hard

Problem Description

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 ith subarray [l_i, r_i], the bitwise AND of the subarray elements is equal to andValues[i]. Return the minimum possible sum of the values of the m subarrays. If it is not possible to divide nums into m subarrays satisfying these conditions, return -1.

Key Insights

  • The last element of each subarray determines the subarray's value.
  • The bitwise AND operation must match the corresponding value in andValues.
  • Subarrays must be contiguous and disjoint.
  • The problem can be approached using dynamic programming or greedy techniques to minimize the sum of the last elements.

Space and Time Complexity

Time Complexity: O(n * m)
Space Complexity: O(m)

Solution

The solution involves iterating through the nums array and checking potential subarrays that can produce the required AND values. Using a two-pointer technique or dynamic programming, we can track the minimum sum of the last elements for valid subarray configurations that meet the AND requirements. For each potential subarray, we calculate the AND and update the minimum sum if it matches the required value.

Code Solutions

def min_sum_of_values(nums, andValues):
    n = len(nums)
    m = len(andValues)
    
    # Initialize DP array with infinity
    dp = [float('inf')] * (m + 1)
    dp[0] = 0  # Base case: no subarrays yield sum 0
    
    # Iterate over possible end points for each subarray
    for i in range(1, m + 1):
        and_val = andValues[i - 1]
        current_and = 0
        
        # Check all possible subarrays ending at j
        for j in range(n - 1, -1, -1):
            current_and &= nums[j] if j < n - 1 else nums[j]
            if current_and == and_val:
                dp[i] = min(dp[i], dp[i - 1] + nums[n - 1])
                
    return dp[m] if dp[m] != float('inf') else -1
← Back to All Questions