https://leetcode.com/problems/pyramid-transition-matrix/

We are stacking blocks to form a pyramid. Each block has a color which is a one letter string.

We are allowed to place any color block C on top of two adjacent blocks of colors A and B, if and only if ABC is an allowed triple.

We start with a bottom row of bottom, represented as a single string. We also start with a list of allowed triples allowed. Each allowed triple is represented as a string of length 3.

Return true if we can build the pyramid all the way to the top, otherwise false.

Example 1:

Input: bottom = "BCD", allowed = ["BCG", "CDE", "GEA", "FFF"]
Output: true
Explanation:
We can stack the pyramid like this:
A
/ \
G   E
/ \ / \
B   C   D

We are allowed to place G on top of B and C because BCG is an allowed triple.  Similarly, we can place E on top of C and D, then A on top of G and E.

Example 2:

Input: bottom = "AABA", allowed = ["AAA", "AAB", "ABA", "ABB", "BAC"]:
Output: false
Explanation:
We can't stack the pyramid to the top.
Note that there could be allowed triples (A, B, C) and (A, B, D) with C != D....

Constraints:

• bottom will be a string with length in range [2, 8].
• allowed will have length in range [0, 200].
• Letters in all strings will be chosen from the set {'A', 'B', 'C', 'D', 'E', 'F', 'G'}.
class Solution {
Map<String, List<String>> map;

public boolean pyramidTransition(String bottom, List<String> allowed) {
map = new HashMap<>();
for(String s : allowed) {
String key = s.substring(0, 2);
String value = s.substring(2, 3);
map.putIfAbsent(key, new ArrayList<>());
}
return solve(bottom);
}

private boolean solve(String bottom) {
if(bottom.length() == 1) {
return true;
}
List<String> nextBottoms = new ArrayList<>();
generateNextBottoms(bottom, nextBottoms, "", 0);
for(String next : nextBottoms) {
if(solve(next)) {
return true;
}
}
return false;
}

private void generateNextBottoms(String bottom, List<String> res, String cur, int i) {
if(cur.length() == bottom.length() - 1) {