Introduction

In this blog post, we will explore how to solve the LeetCode problem "756" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are stacking blocks to form a pyramid. Each block has a color, which is represented by a single letter. Each row of blocks contains one less block than the row beneath it and is centered on top. To make the pyramid aesthetically pleasing, there are only specific triangular patterns that are allowed. A triangular pattern consists of a single block stacked on top of two blocks. The patterns are given as a list of three-letter strings allowed, where the first two characters of a pattern represent the left and right bottom blocks respectively, and the third character is the top block. For example, "ABC" represents a triangular pattern with a 'C' block stacked on top of an 'A' (left) and 'B' (right) block. Note that this is different from "BAC" where 'B' is on the left bottom and 'A' is on the right bottom. You start with a bottom row of blocks bottom, given as a single string, that you must use as the base of the pyramid. Given bottom and allowed, return true if you can build the pyramid all the way to the top such that every triangular pattern in the pyramid is in allowed, or false otherwise. Example 1: Input: bottom = "BCD", allowed = ["BCC","CDE","CEA","FFF"] Output: true Explanation: The allowed triangular patterns are shown on the right. Starting from the bottom (level 3), we can build "CE" on level 2 and then build "A" on level 1. There are three triangular patterns in the pyramid, which are "BCC", "CDE", and "CEA". All are allowed. Example 2: Input: bottom = "AAAA", allowed = ["AAB","AAC","BCD","BBE","DEF"] Output: false Explanation: The allowed triangular patterns are shown on the right. Starting from the bottom (level 4), there are multiple ways to build level 3, but trying all the possibilites, you will get always stuck before building level 1. Constraints: 2 <= bottom.length <= 6 0 <= allowed.length <= 216 allowed[i].length == 3 The letters in all input strings are from the set {'A', 'B', 'C', 'D', 'E', 'F'}. All the values of allowed are unique.

Explanation

Here's the breakdown of the problem and the Python solution:

• High-Level Approach:

  • Recursively build the pyramid from the bottom up, one level at a time.
  • At each level, explore all possible combinations of blocks based on the allowed triangular patterns.
  • If a complete pyramid can be built, return True; otherwise, backtrack and try a different path.

• Complexity:

  • Runtime: O(6^N), where N is the length of the bottom string. In the worst case, each position in a level could have up to 6 possible characters and we have N levels to build.
  • Space: O(N), mainly due to the recursion depth.

Code

    def pyramidTransition(bottom: str, allowed: list[str]) -> bool:
    """
    Determines if a pyramid can be built from a given bottom string and allowed triangular patterns.
    """

    allowed_map = {}
    for pattern in allowed:
        base = pattern[:2]
        top = pattern[2]
        if base not in allowed_map:
            allowed_map[base] = set()
        allowed_map[base].add(top)

    def can_build(current_level: str) -> bool:
        """
        Recursively attempts to build the pyramid from the given level.
        """
        if len(current_level) == 1:
            return True

        next_level = []
        possible_chars = []
        for i in range(len(current_level) - 1):
            base = current_level[i:i+2]
            if base in allowed_map:
                possible_chars.append(allowed_map[base])
            else:
                return False # No possible top block for this base.

        def build_next_level(index: int):
            """
            Backtracking function to explore all possible next levels.
            """
            if index == len(current_level) - 1:
                return can_build("".join(next_level))

            for char in possible_chars[index]:
                next_level.append(char)
                if build_next_level(index + 1):
                    return True
                next_level.pop()  # Backtrack
            return False

        return build_next_level(0)

    return can_build(bottom)