LeetCode 2350: Shortest Impossible Sequence of Rolls Solution

Master LeetCode problem 2350 (Shortest Impossible Sequence of Rolls), a hard challenge, with our optimized solutions in Java, C++, and Python. Explore detailed explanations, test your code in our interactive editor, and prepare for coding interviews.

2350. Shortest Impossible Sequence of Rolls

Hard

Array Hash Table Greedy

Problem Explanation

Explanation:

To find the length of the shortest sequence of rolls that cannot be found as a subsequence in the given rolls, we can use dynamic programming. We will iterate through all possible sequences of rolls and check if each sequence can be found as a subsequence in the given rolls array. If a sequence cannot be found, we update the answer with the minimum length found so far.

Algorithm:

Initialize a set to store all unique subsequences of rolls.
Initialize a queue to store sequences of rolls.
Push all single rolls into the queue and set.
While the queue is not empty, pop a sequence from the queue.
For each possible next roll, create a new sequence by appending the next roll to the current sequence.
If the new sequence is not in the set of subsequences, add it to the set and the queue.
Update the answer with the length of the sequence if it cannot be found in the given rolls array.
Return the minimum length found.

Time Complexity: O(n * k^2) Space Complexity: O(n * k)

Solution Code

class Solution {
    public int shortestSeq(int[] rolls, int k) {
        Set<List<Integer>> set = new HashSet<>();
        Queue<List<Integer>> queue = new LinkedList<>();
        for (int roll : rolls) {
            List<Integer> seq = new ArrayList<>();
            seq.add(roll);
            set.add(seq);
            queue.offer(seq);
        }
        int ans = Integer.MAX_VALUE;
        while (!queue.isEmpty()) {
            List<Integer> seq = queue.poll();
            if (seq.size() >= ans) {
                continue;
            }
            for (int i = 1; i <= k; i++) {
                List<Integer> newSeq = new ArrayList<>(seq);
                newSeq.add(i);
                if (!set.contains(newSeq)) {
                    set.add(newSeq);
                    queue.offer(newSeq);
                    boolean found = true;
                    for (int j = 0; j <= newSeq.size() - rolls.length; j++) {
                        found = true;
                        for (int l = 0; l < rolls.length; l++) {
                            if (newSeq.get(j + l) != rolls[l]) {
                                found = false;
                                break;
                            }
                        }
                        if (found) {
                            break;
                        }
                    }
                    if (!found) {
                        ans = Math.min(ans, newSeq.size());
                    }
                }
            }
        }
        return ans;
    }
}

Try It Yourself

Loading code editor...

Frequently Asked Questions

How to solve LeetCode 2350 (Shortest Impossible Sequence of Rolls)?

This page provides optimized solutions for LeetCode problem 2350 (Shortest Impossible Sequence of Rolls) in Java, C++, and Python, along with a detailed explanation and an interactive code editor to test your code.

What is the time complexity of LeetCode 2350 (Shortest Impossible Sequence of Rolls)?

The time complexity for LeetCode 2350 (Shortest Impossible Sequence of Rolls) varies by solution. Check the detailed explanation section for specific complexities in Java, C++, and Python implementations.

Can I run code for LeetCode 2350 on DevExCode?

Yes, DevExCode provides an interactive code editor where you can write, test, and run your code for LeetCode 2350 in Java, C++, or Python.

Back to LeetCode Solutions