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

Count Beautiful Splits in an Array

Difficulty: Medium

Problem Description

You are given an array nums. A split of an array nums is beautiful if:

  1. The array nums is split into three subarrays: nums1, nums2, and nums3, such that nums can be formed by concatenating nums1, nums2, and nums3 in that order.
  2. The subarray nums1 is a prefix of nums2 OR nums2 is a prefix of nums3.

Return the number of ways you can make this split.

Key Insights

  • A valid split requires the ability to form three non-empty subarrays.
  • The condition of prefixing between nums1, nums2, and nums3 significantly restricts the possible combinations.
  • Count the occurrences of each number to facilitate valid splits by maintaining frequency counts in the subarrays.
  • Utilize prefix sums to efficiently compute the number of valid splits at each potential split point.

Space and Time Complexity

Time Complexity: O(n)
Space Complexity: O(1) (if we only consider the frequency array as fixed size due to the constraint on nums[i])

Solution

To solve the problem, we can use a two-pointer technique combined with prefix sums. We maintain a count of each number in the nums array to determine valid splits. The key is to iterate through the possible split points and check the conditions for nums1, nums2, and nums3 using frequency counts.

  1. Count the occurrences of each number in the array.
  2. Iterate through the array to find potential split points.
  3. At each split point, check the conditions for beautiful splits and increment the count accordingly.

Code Solutions

def countBeautifulSplits(nums):
    from collections import defaultdict
    
    total_count = defaultdict(int)
    for num in nums:
        total_count[num] += 1
    
    current_count = defaultdict(int)
    beautiful_splits = 0
    n = len(nums)
    
    for i in range(n - 2):
        current_count[nums[i]] += 1
        total_count[nums[i]] -= 1
        
        if total_count[nums[i]] == 0:
            del total_count[nums[i]]
        
        if i + 1 < n - 1:  # Ensure nums2 and nums3 can be non-empty
            left_count = len(current_count)
            right_count = len(total_count)
            beautiful_splits += (left_count * right_count)
    
    return beautiful_splits
← Back to All Questions