add 756

fishercoder1534 · fishercoder1534 · commit e4307d78084b · 2018-01-16T08:57:16.000-08:00
diff --git a/README.md b/README.md
@@ -26,6 +26,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |763|[Partition Labels](https://leetcode.com/problems/partition-labels/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_763.java) | O(n) | O(1) | |Medium|
 |762|[Prime Number of Set Bits in Binary Representation](https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_762.java) | O(n) | O(1) | |Easy|
 |760|[Find Anagram Mappings](https://leetcode.com/problems/find-anagram-mappings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_760.java) | O(n^2) | O(1) | |Easy| 
+|756|[Pyramid Transition Matrix](https://leetcode.com/problems/pyramid-transition-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_756.java) | O(?) | O(?) | |Medium| Backtracking
 |755|[Pour Water](https://leetcode.com/problems/pour-water/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_755.java) | O(V*N) | O(1) | |Medium| Array
 |754|[Reach a Number](https://leetcode.com/problems/reach-a-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_754.java) | O(n) | O(1) | |Medium| Math
 |750|[Number Of Corner Rectangles](https://leetcode.com/problems/number-of-corner-rectangles/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_750.java) | O((m*n)^2) | O(1) | |Medium|
diff --git a/src/main/java/com/fishercoder/solutions/_756.java b/src/main/java/com/fishercoder/solutions/_756.java
@@ -0,0 +1,91 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 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:
+ bottom will be a string with length in range [2, 8].
+ allowed will have length in range [0, 200].
+ Letters in all strings will be chosen from the set {'A', 'B', 'C', 'D', 'E', 'F', 'G'}.
+ */
+public class _756 {
+  public static class Solution1 {
+    /**credit: https://discuss.leetcode.com/topic/116042/java-solution-map-backtracking*/
+    public boolean pyramidTransition(String bottom, List<String> allowed) {
+      Map<String, List<String>> map = new HashMap<>();
+      for (String s : allowed) {
+        String key = s.substring(0, 2);
+        if (!map.containsKey(key)) {
+          map.put(key, new ArrayList<>());
+        }
+        map.get(key).add(s.substring(2));
+      }
+
+      return helper(bottom, map);
+    }
+
+    private boolean helper(String bottom, Map<String, List<String>> map) {
+      if (bottom.length() == 1) return true;
+      for (int i = 0; i < bottom.length() - 1; i++) {
+        if (!map.containsKey(bottom.substring(i, i + 2))) {
+          return false;
+        }
+      }
+      List<String> ls = new ArrayList<>();
+      getList(bottom, 0, new StringBuilder(), ls, map);
+      for (String s : ls) {
+        if (helper(s, map)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private void getList(String bottom, int idx, StringBuilder sb, List<String> ls,
+        Map<String, List<String>> map) {
+      if (idx == bottom.length() - 1) {
+        ls.add(sb.toString());
+        return;
+      }
+      for (String s : map.get(bottom.substring(idx, idx + 2))) {
+        sb.append(s);
+        getList(bottom, idx + 1, sb, ls, map);
+        sb.deleteCharAt(sb.length() - 1);
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_756Test.java b/src/test/java/com/fishercoder/_756Test.java
@@ -0,0 +1,37 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._756;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _756Test {
+  private static _756.Solution1 solution1;
+  private static List<String> allowed;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _756.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    allowed = Arrays.asList("XYD", "YZE", "DEA", "FFF");
+    assertEquals(true, solution1.pyramidTransition("XYZ", allowed));
+  }
+
+  @Test
+  public void test2() {
+    allowed = Arrays.asList("XXX", "XXY", "XYX", "XYY", "YXZ");
+    assertEquals(false, solution1.pyramidTransition("XXYX", allowed));
+  }
+
+  @Test
+  public void test3() {
+    allowed = Arrays.asList("BCE", "BCF", "ABA", "CDA", "AEG", "FAG", "GGG");
+    assertEquals(false, solution1.pyramidTransition("ABCD", allowed));
+  }
+}
