Leetcode 756：金字塔转化矩阵

题目描述

现在，我们用一些方块来堆砌一个金字塔。 每个方块用仅包含一个字母的字符串表示。

使用三元组表示金字塔的堆砌规则如下：

对于三元组(A, B, C) ，“C”为顶层方块，方块“A”、“B”分别作为方块“C”下一层的的左、右子块。当且仅当(A, B, C)是被允许的三元组，我们才可以将其堆砌上。

初始时，给定金字塔的基层 bottom，用一个字符串表示。一个允许的三元组列表 allowed，每个三元组用一个长度为 3 的字符串表示。

如果可以由基层一直堆到塔尖就返回 true，否则返回 false。

 

示例 1:

输入: bottom = "BCD", allowed = ["BCG", "CDE", "GEA", "FFF"]
输出: true
解析:
可以堆砌成这样的金字塔:
    A
   / \
  G   E
 / \ / \
B   C   D

因为符合('B', 'C', 'G'), ('C', 'D', 'E') 和 ('G', 'E', 'A') 三种规则。
示例 2:

输入: bottom = "AABA", allowed = ["AAA", "AAB", "ABA", "ABB", "BAC"]
输出: false
解析:
无法一直堆到塔尖。
注意, 允许存在像 (A, B, C) 和 (A, B, D) 这样的三元组，其中 C != D。
 

注意：

bottom 的长度范围在 [2, 8]。
allowed 的长度范围在[0, 200]。
方块的标记字母范围为{'A', 'B', 'C', 'D', 'E', 'F', 'G'}。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pyramid-transition-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

 

解题思路

超时解法

class Solution {
public:
    bool flag;
    unordered_map<string,string> mp;
    void dfs(string str,int i,string s){
        if(i>=str.length()-1){
            if(s.length() == 1) flag=true;
            dfs(s,0,"");
            return;
        }
        string sub = str.substr(i,2);
        if(mp.find(sub)==mp.end()) return;
        for(auto it : mp[sub]){
            s.push_back(it);
            dfs(str,i+1,s);
            s.pop_back();
        }
    }
    bool pyramidTransition(string bottom, vector<string>& allowed) {
        for(auto it : allowed) mp[it.substr(0,2)].push_back(it[2]);
        flag = false;
        dfs(bottom,0,"");
        return flag;
    }
};

 

参考大佬解法

class Solution {
public:
    unordered_map<string,set<char>> mp;
    bool dfs(string str){
        if(str.length()==1) return true;
        queue<string> que;
        que.push("");
        for(int i=0;i<str.length()-1;++i){
            string tmp = str.substr(i,2);
            if(mp.find(tmp) == mp.end()) return false;
            int size = que.size(),idx = 1;
            while(idx++ <= size){
                string s = que.front();
                que.pop();
                for(auto it : mp[tmp]) que.push(s+it);
            }
        }
        if(que.empty()) return false;
        while(!que.empty()){
            bool flag = dfs(que.front());
            que.pop();
            if(flag) return true;
        }
        return false;
    }
    bool pyramidTransition(string bottom, vector<string>& allowed) {
        for(auto it : allowed) mp[it.substr(0,2)].insert(it[2]);
        bool flag = dfs(bottom);
        return flag;
    }
};