Pyramid Transition Matrix - Practice Coding Problems

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: true

💡 Note: We can build: AABA → ACA → AA → A. First level: A+A→A (AAB), A+B→C (ABC), B+A→A (not needed). Second level: A+C→A (ACA). Third level: A+A→A (AAB). Success!

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

Understanding the Visualization

Parse Patterns

Convert allowed patterns into a lookup map: (left, right) → [possible tops]

Start from Bottom

Begin with the given bottom row and identify all adjacent pairs

Build Next Level

For each adjacent pair, look up valid top blocks from our pattern map

Try Combinations

Use backtracking to try different combinations of valid blocks

Recurse or Backtrack

If a complete level is built, recurse to next level; otherwise backtrack

Memoization

Cache results for each row configuration to avoid redundant calculations

Key Takeaway

🎯 Key Insight: By using memoized backtracking with a pattern lookup table, we can efficiently explore all possible pyramid constructions while avoiding redundant calculations, achieving optimal performance for this constraint-satisfaction problem.

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

Approach	Time	Space	Notes
✓ Memoized Backtracking	O(k^n * n)	O(k^n * n)	Use memoization to cache results of pyramid configurations, avoiding repeated calculations
Brute Force Backtracking	O(k^n)	O(n)	Try all possible combinations at each level using recursive backtracking

Memoized Backtracking — Algorithm Steps

Build pattern mapping from allowed triangular patterns
Use memoization to cache results for each row configuration
For each level, try all valid combinations while checking cache
Store results in cache to avoid recomputing same configurations
Return cached result if subproblem was solved before

Visualization

Tap to expand

Step-by-Step Walkthrough

First Computation

Calculate result for a specific row configuration

Cache Result

Store the result in memoization cache

Cache Hit

When same configuration appears again, return cached result

Speedup

Avoid redundant calculations for exponential speedup

Code -

solution.c — C

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

#define MAX_PATTERNS 1000
#define MAX_BLOCKS 10
#define MAX_MEMO 10000

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

typedef struct {
    char key[MAX_BLOCKS];
    bool result;
} MemoEntry;

Pattern patterns[MAX_PATTERNS];
MemoEntry memo[MAX_MEMO];
int patternCount = 0;
int memoCount = 0;

bool findMemo(char* key) {
    for (int i = 0; i < memoCount; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].result;
        }
    }
    return false; // Not found
}

void addMemo(char* key, bool result) {
    if (memoCount < MAX_MEMO) {
        strcpy(memo[memoCount].key, key);
        memo[memoCount].result = result;
        memoCount++;
    }
}

bool hasMemo(char* key) {
    for (int i = 0; i < memoCount; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return true;
        }
    }
    return false;
}

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;
    memoCount = 0;
    
    // Build patterns mapping
    for (int i = 0; i < allowedSize; i++) {
        char left = allowed[i][0], right = allowed[i][1], top = allowed[i][2];
        
        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) {
    char key[MAX_BLOCKS];
    strncpy(key, currentLevel, len);
    key[len] = '\0';
    
    if (hasMemo(key)) {
        return findMemo(key);
    }
    
    if (len == 1) {
        addMemo(key, true);
        return true;
    }
    
    char nextLevel[MAX_BLOCKS];
    bool result = buildNextLevel(currentLevel, 0, len, nextLevel, 0);
    addMemo(key, result);
    return result;
}

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];
    
    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;
                }
            }
            break;
        }
    }
    
    return false;
}

int main() {
    char bottom[] = "AABA";
    char* allowed[] = {"ABC", "ACA", "CAA", "AAB"};
    printf("%s\n", pyramidTransition(bottom, allowed, 4) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n * n)

With memoization, we avoid recomputing the same configurations. Each unique configuration is computed once, leading to significant speedup in practice.

✓ Linear Growth

Space Complexity

O(k^n * n)

Space for memoization cache plus recursion stack. Cache stores results for unique row configurations.

⚡ 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

Memoized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler