[Leetcode] 756. Pyramid Transition Matrix 解题报告

题目：

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'}.

思路：

为了加速，我们首先建立一个哈希表，存储所有前缀的候选字符集。然后就采用DFS+ backtracking进行搜索了。这里面就是标准模板了，见下面的代码片段。有问题的可以直接留言。

代码：

class Solution {
public:
    bool pyramidTransition(string bottom, vector<string>& allowed) {
        unordered_map<string, vector<char>> hash;   // construct the hash map for acceleration
        for (auto &s : allowed) {
            hash[s.substr(0, 2)].push_back(s[2]);
        }
        string curr("");
        return DFS(bottom, curr, 0, hash);
    }
private:
    bool DFS(string &prev, string &curr, int k, 
             unordered_map<string, vector<char>> &hash) {
        if (prev.length() == 1) {                   // the total pyramid has been constructed
            return true;
        }
        if (k + 1 == prev.length()) {               // the current layer has been constructed
            string next("");
            return DFS(curr, next, 0, hash);
        }
        else {
            string key = prev.substr(k, 2);
            if (hash.count(key) == 0) {             // no candidate
                return false;
            }
            else {                                  // try each candidate
                const vector<char> &chars = hash[key];
                for (int i = 0; i < chars.size(); ++i) {
                    curr.push_back(chars[i]);
                    if (DFS(prev, curr, k + 1, hash)) {
                        return true;
                    }
                    curr.pop_back();                // backtracking
                }
                return false;
            }
        }
    }
};