Pyramid Transition Matrix

question:

We are stacking blocks to form a pyramid. Each block has a color which is a one letter string, like `'Z'`.

For every block of color `C` we place not in the bottom row, we are placing it on top of a left block of color `A` and right block of color `B`. We are allowed to place the block there only if `(A, B, C)` 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 = "XYZ", allowed = ["XYD", "YZE", "DEA", "FFF"]
Output: true
Explanation:
We can stack the pyramid like this:
    A
   / \
  DE
 / \ / \
X   Y   Z
This works because ('X', 'Y', 'D'), ('Y', 'Z', 'E'), and ('D', 'E', 'A') are allowed triples.

Example 2:

Input: bottom = "XXYX", allowed = ["XXX", "XXY", "XYX", "XYY", "YXZ"]
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.

Note:

1. bottom will be a string with length in range [2, 8].
2. allowed will have length in range [0, 200].
3. Letters in all strings will be chosen from the set {'A', 'B', 'C', 'D', 'E', 'F', 'G'}.

solve:

【Title】

There is a pyramidal triangle similar to Yanghui's triangle, giving the base, and some rules. The format of the rule is (ABC) , Cthe left child is allowed to Aappear, and Cthe right child is allowed to Bappear. According to the bottom and these rules, find out whether it is possible to construct a pyramid triangle

① Use map to record the combination of all left and right child nodes and the root node, dfs traverses to find the root node, and records the strings of each layer until the string length of the last layer is 1.

class Solution { //11ms
    public boolean pyramidTransition(String bottom, List<String> allowed) {
        Map<String,List<String>> map = new HashMap<>();//The key is the left and right node strings, and the value is the root collection of nodes
        for (String str : allowed){
            String key = str.substring(0,2);
            if (! map.containsKey(key)){
                map.put(key,new ArrayList<>());
            }
            map .get(key).add(str.substring(2));
        }
        return dfs(map,bottom,new StringBuilder(),0);
    }
    public boolean dfs(Map<String,List<String>> map,String bottom ,StringBuilder nextBottom,int p){
        if (p == bottom.length() - 1){//Complete a line, update bottom and p
            bottom = nextBottom.toString();
            nextBottom = new StringBuilder();
            p = 0;
        }
        if (bottom.length() == 1) return true;
        String key = bottom.substring(p,p + 2);
        if (map.containsKey(key)){
            for (String val : map.get(key)){
                nextBottom.append(val);
                if (dfs(map,bottom,nextBottom,p + 1)) return true;
                nextBottom.setLength(nextBottom.length() - 1);//还原
            }
        }
        return false;
    }
}