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

Shortest Impossible Sequence of Rolls

Difficulty: Hard

Problem Description

You are given an integer array rolls of length n and an integer k. You roll a k sided dice numbered from 1 to k, n times, where the result of the ith roll is rolls[i]. Return the length of the shortest sequence of rolls so that there's no such subsequence in rolls. A sequence of rolls of length len is the result of rolling a k sided dice len times.

Key Insights

  • A sequence can be formed from rolls if it can be constructed using the numbers present in the rolls array.
  • The shortest impossible sequence can be found by exploring the combinations of numbers that can be formed.
  • We need to determine the first sequence that cannot be constructed from the given rolls.

Space and Time Complexity

Time Complexity: O(n)
Space Complexity: O(k)

Solution

To solve the problem, we can utilize a greedy approach with the help of a hash table (or a set) to track the occurrences of each number in the rolls. The goal is to identify the smallest length of a sequence (starting from length 1) that cannot be formed using the numbers available in rolls. We'll iterate through possible lengths of sequences and check if each sequence of that length can be formed using the available numbers.

Code Solutions

def shortestImpossibleSequence(rolls, k):
    # Count occurrences of each number in rolls
    count = {}
    for roll in rolls:
        count[roll] = count.get(roll, 0) + 1

    # Check for the shortest impossible sequence
    length = 1
    while True:
        # Generate all combinations of sequences of the current length
        possible_sequences = set()
        def generate_sequences(current_sequence):
            if len(current_sequence) == length:
                possible_sequences.add(tuple(current_sequence))
                return
            for i in range(1, k + 1):
                if count.get(i, 0) > 0:
                    current_sequence.append(i)
                    generate_sequences(current_sequence)
                    current_sequence.pop()

        generate_sequences([])
        
        # If the number of possible sequences is less than k^length,
        # then there is an impossible sequence of this length
        if len(possible_sequences) < k ** length:
            return length
        length += 1
← Back to All Questions