JAVA程序设计：金字塔转换矩阵（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'}。

思路：深搜，存好两个字母和他们能承载的另一个字母的映射关系，添加一个优化：保存一下已经遍历过的状态。

class Solution {
	
	int[][] T;
	Set<Long> st;
	
    public boolean pyramidTransition(String bottom, List<String> allowed) {
    	
    	T=new int[7][7];
    	for(String s : allowed)
    		T[s.charAt(0)-'A'][s.charAt(1)-'A'] |=1<<(s.charAt(2)-'A');
    	
    	st=new HashSet<>();
    	int len=bottom.length();
    	int[][] A=new int[len][len];
    	int t=0;
    	for(char c : bottom.toCharArray())
    		A[len-1][t++]=c-'A';
    	
    	return dfs(A,0,len-1,0);
    }
    
    private boolean dfs(int[][] A,long R,int N,int i) {
    	
    	if(N==1 && i==1) 
    		return true;
    	else if(i==N) {
    		if(st.contains(R)) return false;
    		st.add(R);
    		return dfs(A,0,N-1,0);
    	}
    	else {
    		int w=T[A[N][i]][A[N][i+1]];
    		for(int j=0;j<7;j++) 
    			if(((w>>j) & 1)!=0) {
    				A[N-1][i]=j;
    				if(dfs(A,R*8+(j+1),N,i+1)) 
    					return true;
    			}
    		return false;
    	}
    }
    
}

方法二：