trapping rain water

Author: JoshuaJiangFD

src/main/java/joshua/leetcode/array/twopointers/TrappingRainWater.java

@@ -1,76 +1,77 @@
 package joshua.leetcode.array.twopointers;
 
+import joshua.leetcode.solutiontag.Stacks;
+import joshua.leetcode.solutiontag.TwoPointers;
+import sun.reflect.generics.reflectiveObjects.NotImplementedException;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
 /**
- * Trapping Rain Water 
- * 
- * @see < a href="https://leetcode.com/problems/trapping-rain-water/">leetcode link</a>
- * @author joy
+ * Trapping Rain Water
  *
+ * @author joy
+ * @see < a href="https://leetcode.com/problems/trapping-rain-water/">leetcode link</a>
  */
 public abstract class TrappingRainWater {
 
-	/**
-	 * Given n non-negative integers representing an elevation map where the width of each bar is 1,
-	 * 
-	 * compute how much water it is able to trap after raining.
-	 *
-	 * @param height
-	 * @return
-	 */
-	public abstract int trap(int[] height);
+    /**
+     * Given n non-negative integers representing an elevation map where the width of each bar is 1,
+     * <p/>
+     * compute how much water it is able to trap after raining.
+     * <p/>
+     *
+     * For example,
+     * Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.
+     *
+     * @param height
+     * @return
+     */
+    public abstract int trap(int[] height);
+
+    @TwoPointers
+    public static class Solution1 extends TrappingRainWater {
+
+        @Override
+        public int trap(int[] height) {
+            throw new NotImplementedException();
+        }
+    }
 
-	/**
-	 * stack, two pointers
-	 * 
-	 * @author joy
-	 *
-	 */
-	public static class Solution1 extends TrappingRainWater {
+    /**
+     * 使用栈，按元素从左到右，比栈顶元素小的话就入栈，直到比栈顶大的元素就开始对做出栈操作，每次计算两个元素之间水平方向
+     * 顶部聚集起来的水方块的个数
+     */
+    @Stacks
+    public static class Solution2 extends TrappingRainWater {
 
-		@Override
-		public int trap(int[] height) {
-			if (height == null || height.length <= 2)
-				return 0;
-			int leftIdx = 0, rightIdx = 1;
-			int totalSum = 0;
-			while (rightIdx < height.length) {
-				int subSum = 0;
-				while (rightIdx < height.length
-						&& height[rightIdx] < height[leftIdx]) {
-					subSum += height[leftIdx] - height[rightIdx];
-					rightIdx++;
-				}
-				if (rightIdx < height.length) {
-					totalSum += subSum;
-					leftIdx = rightIdx;
-					rightIdx++;
-				}
-			}
-			/*if leftIdx==height.length-1, then we handled all the elements in array, 
-			 * otherwise need to take care of the interval [leftIdx,height.Length-1]*/
-			while (leftIdx < height.length) {
-				int temp = leftIdx + 1;
-				int sum = 0;
-				while (temp < height.length && height[temp] < height[temp - 1]) {
-					sum += height[leftIdx] - height[temp];
-					temp++;
-				}
-				if (temp == height.length)
-					break;
-				while (temp < height.length && height[temp] >= height[temp - 1]) {
-					sum += height[leftIdx] - height[temp];
-					temp++;
-				}
-				sum -= (height[leftIdx] - height[temp - 1])
-						* (temp - 1 - leftIdx);
-				totalSum += sum;
-				if (temp < height.length) {
-					leftIdx = temp - 1;
-				} else {
-					break;
-				}
-			}
-			return totalSum;
-		}
-	}
+        @Override
+        public int trap(int[] height) {
+            if (height == null || height.length == 0) {
+                return 0;
+            }
+            Deque<Integer> stack = new LinkedList<Integer>();
+            // stack stores the index of element.
+            int water = 0;
+            stack.push(0);
+            for (int i = 1; i < height.length; i++) {
+                if(stack.isEmpty() || height[i] < height[stack.peek()]) {
+                    stack.push(i);
+                    continue;
+                }
+                int bottom = height[stack.pop()];
+                while (!stack.isEmpty()) {
+                    if ( height[stack.peek()] <= height[i]) {
+                        int idx = stack.pop();
+                        water += (i - idx - 1) * (height[idx] - bottom);
+                        bottom = height[idx];
+                    } else {
+                        break;
+                    }
+                }
+                stack.push(i);
+            }
+            return water;
+        }
+    }
 }

src/main/java/joshua/leetcode/solutiontag/Stacks.java

@@ -0,0 +1,7 @@
+package joshua.leetcode.solutiontag;
+
+/**
+ * Created by joshu on 2016/5/23.
+ */
+public @interface Stacks {
+}

src/test/java/joshua/leetcode/array/twopointers/TrappingRainWaterTest.java

@@ -2,19 +2,27 @@
 
 import static org.junit.Assert.*;
 
+import com.google.common.collect.Maps;
+import org.junit.Before;
 import org.junit.Test;
 
+import java.util.Map;
+
 public class TrappingRainWaterTest {
 
+	private Map<int[], Integer> cases = Maps.newHashMap();
+
+	@Before
+	public void setUp() {
+		cases.put(new int[]{0,1,0,2,1,0,1,3,2,1,2,1}, 6);
+	}
+
 	@Test
-	public void testSolution1() {
-		TrappingRainWater sol=new TrappingRainWater.Solution1();
-//		int[] height=new int[]{0,1,0,2,1,0,1,3,2,1,2,1};
-		int[] height=new int[]{9,6,8,8,5,6,3};
-		assertEquals(6,sol.trap(height));
-//		int[] height=new int[]{4,2,3};
-//		assertEquals(1,sol.trap(height));
-		
+	public void testSolution2() {
+		TrappingRainWater sol=new TrappingRainWater.Solution2();
+		for (int[] key : cases.keySet()) {
+			assertEquals((int)cases.get(key), sol.trap(key));
+		}
 	}
 
 }