Algorithm-box
diff --git a/‎README.md
Lines changed: 2 additions & 1 deletion b/‎README.md
Lines changed: 2 additions & 1 deletion
diff --git a/‎src/main/java/com/fishercoder/solutions/_892.java
Lines changed: 46 additions & 0 deletions b/‎src/main/java/com/fishercoder/solutions/_892.java
Lines changed: 46 additions & 0 deletions
diff --git a/‎src/test/java/com/fishercoder/_892Test.java
Lines changed: 43 additions & 0 deletions b/‎src/test/java/com/fishercoder/_892Test.java
Lines changed: 43 additions & 0 deletions
@@ -453,8 +453,9 @@ _If you like this project, please leave me a star._ &#9733;
 |897|[Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_897.java) | |Easy| DFS, recursion
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) |  |Easy|
 |895|[Maximum Frequency Stack](https://leetcode.com/problems/maximum-frequency-stack/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_895.java) | HashTable, Stack |Hard|
-|890|[Find and Replace Pattern](https://leetcode.com/problems/find-and-replace-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_890.java) |  |Medium|
 |893|[Groups of Special-Equivalent Strings](https://leetcode.com/problems/groups-of-special-equivalent-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_893.java) | [:tv:](https://youtu.be/tbtXPKkA2Zw) |Easy|
+|892|[Surface Area of 3D Shapes](https://leetcode.com/problems/surface-area-of-3d-shapes/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_892.java) |  Array, Math, Geometry, Matrix|Easy|
+|890|[Find and Replace Pattern](https://leetcode.com/problems/find-and-replace-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_890.java) |  |Medium|
 |888|[Fair Candy Swap](https://leetcode.com/problems/fair-candy-swap/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_888.java) |  |Easy|
 |885|[Spiral Matrix III](https://leetcode.com/problems/spiral-matrix-iii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_885.java)  |[:tv:](https://www.youtube.com/watch?v=0qep3f9cqVs) |Medium|
 |884|[Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_884.java) | |Easy|
 
@@ -0,0 +1,46 @@
+package com.fishercoder.solutions;
+
+public class _892 {
+    public static class Solution1 {
+        /**
+         * It's the way that you approach a problem like this matters. This is why we practice LeetCode - train your thought process, i.e. how do you approach a seemingly complex problem.
+         * <p>
+         * Inspired by: https://leetcode.com/problems/surface-area-of-3d-shapes/discuss/163414/C%2B%2BJava1-line-Python-Minus-Hidden-Area
+         * <p>
+         * Idea is:
+         * 1. Each tower's surface is 4*height + 2, because each tower has 6 surfaces: 4 standing ones and 1 on the top and 1 on the bottom;
+         * 2. For the adjacent areas between two towers, we can deduct the overlapped area by using the smaller area * 2;
+         * 3. How to achieve #2, for each tower, we can its against rightside neighbor, and then check against its bottom neighbor, this will cover all.
+         * Of course, the three for loops could be combined into one, I put it like this for easier understanding.
+         */
+        public int surfaceArea(int[][] grid) {
+            int area = 0;
+            int m = grid.length;
+            int n = grid[0].length;
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (grid[i][j] != 0) {
+                        area += (grid[i][j] * 4 + 2);
+                    }
+                }
+            }
+            //check its right side neighbors
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n - 1; j++) {
+                    if (grid[i][j] != 0 && grid[i][j + 1] != 0) {
+                        area -= 2 * Math.min(grid[i][j], grid[i][j + 1]);
+                    }
+                }
+            }
+            //check its downside neighbors
+            for (int i = 0; i < m - 1; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (grid[i][j] != 0 && grid[i + 1][j] != 0) {
+                        area -= 2 * Math.min(grid[i][j], grid[i + 1][j]);
+                    }
+                }
+            }
+            return area;
+        }
+    }
+}
@@ -0,0 +1,43 @@
+package com.fishercoder;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions._892;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _892Test {
+    private static _892.Solution1 solution1;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _892.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(10, solution1.surfaceArea(new int[][]{{2}}));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(34, solution1.surfaceArea(CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,2],[3,4]")));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(16, solution1.surfaceArea(CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,0],[0,2]")));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(32, solution1.surfaceArea(CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,1,1],[1,0,1],[1,1,1]")));
+    }
+
+    @Test
+    public void test5() {
+        assertEquals(46, solution1.surfaceArea(CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[2,2,2],[2,1,2],[2,2,2]")));
+    }
+
+}