[LEET-554] add 554

Author: fishercoder1534

leetcode-algorithms/README.md

@@ -4,6 +4,7 @@
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
 |557|[Reverse Words in a String III](https://leetcode.com/problems/reverse-words-in-a-string-iii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ReverseWordsinaStringIII.java) | O(n) |O(n) | Easy | String
+|554|[Brick Wall](https://leetcode.com/problems/brick-wall/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BrickWall.java) | O(n) (n is total number of bricks in the wall) |O(m) (m is width of the wall) | Medium | HashMap
 |548|[Split Array with Equal Sum](https://leetcode.com/problems/split-array-with-equal-sum/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SplitArraywithEqualSum.java) | O(n^2) |O(1) | Medium | Array
 |547|[Friend Circles](https://leetcode.com/problems/friend-circles/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FriendCircles.java) | O(n^2) |O(n) | Medium | Union Find
 |545|[Boundary of Binary Tree](https://leetcode.com/problems/boundary-of-binary-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BoundaryofBinaryTree.java) | O(n) |O(n) | Medium | Recursion

leetcode-algorithms/src/main/java/com/stevesun/solutions/BrickWall.java

@@ -0,0 +1,65 @@
+package com.stevesun.solutions;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * There is a brick wall in front of you. The wall is rectangular and has several rows of bricks. The bricks have the same height but different width. You want to draw a vertical line from the top to the bottom and cross the least bricks.
+
+ The brick wall is represented by a list of rows. Each row is a list of integers representing the width of each brick in this row from left to right.
+
+ If your line go through the edge of a brick, then the brick is not considered as crossed. You need to find out how to draw the line to cross the least bricks and return the number of crossed bricks.
+
+ You cannot draw a line just along one of the two vertical edges of the wall, in which case the line will obviously cross no bricks.
+
+ Example:
+ Input:
+ [[1,2,2,1],
+ [3,1,2],
+ [1,3,2],
+ [2,4],
+ [3,1,2],
+ [1,3,1,1]]
+ Output: 2
+ Explanation:
+
+ Note:
+ The width sum of bricks in different rows are the same and won't exceed INT_MAX.
+ The number of bricks in each row is in range [1,10,000]. The height of wall is in range [1,10,000]. Total number of bricks of the wall won't exceed 20,000.
+ */
+public class BrickWall {
+    //credit to: https://leetcode.com/articles/brick-wall/
+
+    /**we make use of a HashMap
+     map which is used to store entries in the form:
+     (sum,count). Here,
+     sum refers to the cumulative sum of the bricks' widths encountered in the current row, and
+     count refers to the number of times the corresponding sum is obtained. Thus,
+     sum in a way, represents the positions of the bricks's boundaries relative to the leftmost boundary.
+
+     This is done based on the following observation:
+     We will never obtain the same value of sum twice while traversing over a particular row.
+     Thus, if the sum value is repeated while traversing over the rows, it means some row's brick boundary coincides with some previous row's brick boundary.
+     This fact is accounted for by incrementing the corresponding count value.
+
+     But, for every row, we consider the sum only upto the second last brick, since the last boundary isn't a valid boundary for the solution.*/
+
+    public int leastBricks(List<List<Integer>> wall) {
+        Map<Integer, Integer> map = new HashMap();
+        for (List<Integer> row : wall) {
+            int sum = 0;
+            for (int i = 0; i < row.size()-1; i++) {//NOTE: i < row.size()-1
+                sum += row.get(i);
+                if (map.containsKey(sum)) map.put(sum, map.get(sum)+1);
+                else map.put(sum, 1);
+            }
+        }
+        int result = wall.size();
+        for (int key : map.keySet()) {
+            result = Math.min(result, wall.size() - map.get(key));
+        }
+        return result;
+    }
+
+}

leetcode-algorithms/src/test/java/com/stevesun/BrickWallTest.java

@@ -0,0 +1,41 @@
+package com.stevesun;
+
+import com.stevesun.solutions.BrickWall;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+
+public class BrickWallTest {
+    private static BrickWall test;
+    private static int expected;
+    private static int actual;
+    private static List<List<Integer>> wall;
+
+    @BeforeClass
+    public static void setup(){
+        test = new BrickWall();
+    }
+
+    @Before
+    public void setupForEachTest(){}
+
+    @Test
+    public void test1(){
+        wall = new ArrayList<>();
+        wall.add(Arrays.asList(1,2,2,1));
+        wall.add(Arrays.asList(3,1,2));
+        wall.add(Arrays.asList(1,3,2));
+        wall.add(Arrays.asList(2,4));
+        wall.add(Arrays.asList(3,1,2));
+        wall.add(Arrays.asList(1,3,1,1));
+        expected = 2;
+        actual = test.leastBricks(wall);
+        assertEquals(expected, actual);
+    }
+}