Pyramid Transition Matrix

Pyramid Transition Matrix - Problem

Imagine you're an ancient architect tasked with building a sacred pyramid using colored stone blocks. Each block has a unique color represented by a single letter (A, B, C, etc.).

The pyramid follows strict architectural rules:

Each level has one fewer block than the level below it
Blocks are perfectly centered on the level beneath
Most importantly, only specific triangular patterns are allowed by the ancient building codes

You're given:

bottom: A string representing the bottom row of blocks (e.g., "AABA")
allowed: A list of 3-character strings representing valid patterns (e.g., ["ABC", "ABD", "BAC"])

Each pattern like "ABC" means: if you have block 'A' on the left and block 'B' on the right at the bottom, you can place block 'C' on top of them.

Goal: Determine if you can build the complete pyramid from bottom to top (ending with a single block) such that every triangular pattern used is in the allowed list.

Return true if the pyramid can be completed, false otherwise.

Input & Output

example_1.py — Simple Valid Pyramid

$ Input: bottom = "AABA", allowed = ["ABC", "ACA", "CAA", "AAB"]

› Output: false

💡 Note: Starting with AABA, we need patterns for AA, AB, and BA pairs. We have AAB (A+A→B), ABC (A+B→C), but no pattern for BA (B+A→?). Since we cannot find a valid pattern for the BA pair, pyramid construction fails.

example_2.py — No Valid Path

$ Input: bottom = "AABA", allowed = ["ABC", "BAC"]

› Output: false

💡 Note: Starting with AABA, we need patterns for AA, AB, and BA pairs. We have ABC (A+B→C) and BAC (B+A→C), but no pattern for AA. Cannot build the first level up from bottom.

example_3.py — Single Block Base

$ Input: bottom = "A", allowed = ["ABC", "DEF"]

› Output: true

💡 Note: Edge case: If bottom already has only one block, the pyramid is already complete. No building required, so return true regardless of allowed patterns.

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 values of allowed are unique

Visualization

Tap to expand

Asked in

G Google 15 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses memoized backtracking to solve this pyramid construction problem. We first build a hash map from allowed patterns, then use recursive backtracking to try building each level. The key optimization is memoization - caching results for each row configuration to avoid recomputing the same subproblems. This reduces the exponential search space significantly while guaranteeing we find a solution if one exists.

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(k^n) Space: O(n)

This approach uses pure backtracking to explore all possible ways to build each level of the pyramid. For each pair of adjacent blocks in the current level, we try all possible top blocks that are allowed by the given patterns. We recursively build the next level until we either reach the top (single block) or determine it's impossible.

Memoized Backtracking

⏱️ Time: O(k^n * n) Space: O(k^n * n)

This approach enhances the backtracking solution by adding memoization. We cache the results of whether a particular row configuration can lead to a complete pyramid. This dramatically reduces the search space by avoiding recomputation of the same subproblems. The first 'pass' builds the pattern mapping, and the second 'pass' performs memoized backtracking.

Brute Force Backtracking — Algorithm Steps

Create a mapping from bottom pairs to possible top blocks
Start with the bottom row and recursively build upward
For each level, try all valid combinations of blocks for the next level
If any combination leads to a complete pyramid, return true
If no combination works, backtrack and try alternatives

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Pattern Map

Create mapping from (left,right) pairs to possible top blocks

Start with Bottom

Begin with the given bottom row

Try Combinations

For each adjacent pair, try all valid top blocks

Recurse or Backtrack

If level is complete, recurse; otherwise backtrack and try alternatives

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_PATTERNS 1000
#define MAX_BLOCKS 10

typedef struct {
    char left, right;
    char tops[MAX_BLOCKS];
    int count;
} Pattern;

static Pattern patterns[MAX_PATTERNS];
static int patternCount = 0;

bool buildNextLevel(char* currentLevel, int pos, int currentLen, char* nextLevel, int nextPos);
bool backtrack(char* currentLevel, int len);

bool pyramidTransition(char* bottom, char** allowed, int allowedSize) {
    patternCount = 0;
    
    // Build patterns mapping
    for (int i = 0; i < allowedSize; i++) {
        char left = allowed[i][0], right = allowed[i][1], top = allowed[i][2];
        
        // Find existing pattern or create new one
        int idx = -1;
        for (int j = 0; j < patternCount; j++) {
            if (patterns[j].left == left && patterns[j].right == right) {
                idx = j;
                break;
            }
        }
        
        if (idx == -1) {
            idx = patternCount++;
            patterns[idx].left = left;
            patterns[idx].right = right;
            patterns[idx].count = 0;
        }
        
        patterns[idx].tops[patterns[idx].count++] = top;
    }
    
    return backtrack(bottom, strlen(bottom));
}

bool backtrack(char* currentLevel, int len) {
    if (len == 1) return true;
    
    char nextLevel[MAX_BLOCKS];
    return buildNextLevel(currentLevel, 0, len, nextLevel, 0);
}

bool buildNextLevel(char* currentLevel, int pos, int currentLen, char* nextLevel, int nextPos) {
    if (pos == currentLen - 1) {
        nextLevel[nextPos] = '\0';
        return backtrack(nextLevel, nextPos);
    }
    
    char left = currentLevel[pos], right = currentLevel[pos + 1];
    
    // Find matching pattern
    for (int i = 0; i < patternCount; i++) {
        if (patterns[i].left == left && patterns[i].right == right) {
            for (int j = 0; j < patterns[i].count; j++) {
                nextLevel[nextPos] = patterns[i].tops[j];
                if (buildNextLevel(currentLevel, pos + 1, currentLen, nextLevel, nextPos + 1)) {
                    return true;
                }
            }
            return false;
        }
    }
    
    return false;
}

int main() {
    char bottom[100], allowedLine[1000];
    fgets(bottom, sizeof(bottom), stdin);
    fgets(allowedLine, sizeof(allowedLine), stdin);
    
    // Remove newlines
    bottom[strcspn(bottom, "\n")] = 0;
    allowedLine[strcspn(allowedLine, "\n")] = 0;
    
    char* allowed[300];
    int allowedSize = 0;
    
    if (strlen(allowedLine) > 0) {
        char* token = strtok(allowedLine, ",");
        while (token != NULL) {
            allowed[allowedSize++] = token;
            token = strtok(NULL, ",");
        }
    }
    
    printf("%s\n", pyramidTransition(bottom, allowed, allowedSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is average number of possible blocks per position and n is length of bottom row. In worst case, we explore all possible combinations.

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n levels (height of pyramid)

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler