LeetCode 756. Pyramid Transition Matrix

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhaohaibo_/article/details/85341112

题目链接： 金字塔转换矩阵 - 力扣 (LeetCode)

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
   / \
  D   E
 / \ / \
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’}.

---

class Solution {
public:
    vector<char> allows[7][7];
    bool pyramidTransition(string bottom, vector<string>& allowed) {
        for(auto allow : allowed){
            int a = allow[0] - 'A', b = allow[1] - 'A';
            char c = allow[2];
            allows[a][b].push_back(c);
        }
        return dfs(bottom, "");
    }
    bool dfs(string &bottom, string curline){
        if(bottom.size() == 1) return true;
        if(curline.size() + 1 == bottom.size()) return dfs(curline, "");
        int a = bottom[curline.size()] - 'A', b = bottom[curline.size() + 1] - 'A';
        for(auto c : allows[a][b]){
            if(dfs(bottom, curline + c)) return true;
        }
        return false;
    }
};