Trapping Rain Water & Spiral Matrix II

fishercoder1534 · fishercoder1534 · commit 0b41f7e4e5d2 · 2017-01-01T09:24:34.000-08:00
diff --git a/README.md b/README.md
@@ -203,6 +203,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |68|[Text Justification](https://leetcode.com/problems/text-justification/)|[Solution](../../blob/master/src/stevesun/algorithms/TextJustification.java)|O(n)|O(1)|Hard|
 |67|[Add Binary](https://leetcode.com/problems/add-binary/)|[Solution](../../blob/master/src/stevesun/algorithms/AddBinary.java)|O(n)|O(1)|Easy|
 |60|[Permutation Sequence](https://leetcode.com/problems/permutation-sequence/)|[Solution](../../blob/master/src/stevesun/algorithms/PermutationSequence.java)|?|?|Medium|
+|59|[Spiral Matrix II](https://leetcode.com/problems/spiral-matrix-ii/)|[Solution](../../blob/master/src/stevesun/algorithms/SpiralMatrixII.java)|O(n)|O(n)|Medium|
 |58|[Length of Last Word](https://leetcode.com/problems/length-of-last-word/)|[Solution](../../blob/master/src/stevesun/algorithms/LengthofLastWord.java)|O(n)|O(1)|Easy|
 |56|[Merge Intervals](https://leetcode.com/problems/merge-intervals/)|[Solution](../../blob/master/src/stevesun/algorithms/MergeIntervals.java)|O(n*logn)|O(1)|Hard|
 |54|[Spiral Matrix](https://leetcode.com/problems/spiral-matrix/)|[Solution](../../blob/master/src/stevesun/algorithms/SpiralMatrix.java)|O(m*n)|O(m*n)|Medium|
@@ -211,6 +212,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |47|[Permutations II](https://leetcode.com/problems/permutations-ii/)|[Solution](../../blob/master/src/stevesun/algorithms/PermutationsII.java)|O(n*n!)|O(n)|Medium|Backtracking
 |45|[Jump Game II](https://leetcode.com/problems/jump-game-ii/)|[Solution](../../blob/master/src/stevesun/algorithms/JumpGameII.java)|O(?)|O(?)|Hard|
 |43|[Multiply Strings](https://leetcode.com/problems/multiply-strings/)|[Solution]|||Medium
+|42|[Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/)|[Solution](../../blob/master/src/stevesun/algorithms/TrappingRainWater.java)|O(n)|O(1)|Hard|
 |41|[First Missing Positive](https://leetcode.com/problems/first-missing-positive/)|[Solution](../../blob/master/src/stevesun/algorithms/FirstMissingPositive.java)|O(n)|O(1)|Hard|
 |39|[Combination Sum](https://leetcode.com/problems/combination-sum/)|[Solution](../../blob/master/src/stevesun/algorithms/CombinationSum.java)|O(k*n^k)|O(k)|Medium|Backtracking
 |38|[Count and Say](https://leetcode.com/problems/count-and-say/)|[Solution](../../blob/master/src/stevesun/algorithms/CountandSay.java)|O(n*2^n)|O(2^n)|Easy| Recursion, LinkedList
diff --git a/src/stevesun/algorithms/SpiralMatrixII.java b/src/stevesun/algorithms/SpiralMatrixII.java
@@ -0,0 +1,120 @@
+package stevesun.algorithms;
+
+/**
+ * Given an integer n, generate a square matrix filled with elements from 1 to n2 in spiral order.
+
+ For example,
+ Given n = 3,
+
+ You should return the following matrix:
+ [
+ [ 1, 2, 3 ],
+ [ 8, 9, 4 ],
+ [ 7, 6, 5 ]
+ ]
+ */
+public class SpiralMatrixII {
+
+    public int[][] generateMatrix(int num) {
+        int temp = num;
+        int fourEdges[][] = new int[num][num];
+        int  value = 1;
+        int i = 0, j = 0;
+        if(num%2 == 0)//when num is even
+        {
+            while(i < num/2 && j < num/2 && temp >= 0)
+            {
+				/* Assign the top row */
+                while(j < temp)
+                {
+                    fourEdges[i][j] = value;
+                    j++;
+                    value++;
+
+                }
+
+				/* Assign the right column */
+                while(i < temp - 1){
+                    i++;
+                    fourEdges[i][j - 1] = value;
+                    value++;
+                }
+                j = j - 2;
+
+				/* Assign the bottom row */
+                while(j >= num - temp){
+                    fourEdges[i][j] = value;
+                    j--;
+                    value++;
+                }
+                i--;
+                j++;
+
+				/* Assign the left column */
+                while(i > num - temp){
+                    fourEdges[i][j] = value;
+                    i--;
+                    value++;
+                }
+                //}
+                i++;
+                j++;
+                temp--;
+            }
+
+        }
+        else//when num is odd
+        {
+            while(i < num/2 && j < num/2 && temp >= 0)
+            {
+				/* Assign the top row */
+                while(j < temp)
+                {
+                    fourEdges[i][j] = value;
+                    j++;
+                    value++;
+
+                }
+
+				/* Assign the right column */
+                while(i < temp - 1){
+                    i++;
+                    fourEdges[i][j - 1] = value;
+                    value++;
+                }
+                j = j - 2;
+
+				/* Assign the bottom row */
+                while(j >= num - temp){
+                    fourEdges[i][j] = value;
+                    j--;
+                    value++;
+                }
+                i--;
+                j++;
+
+				/* Assign the left column */
+                while(i > num - temp){
+                    fourEdges[i][j] = value;
+                    i--;
+                    value++;
+                }
+                //}
+                i++;
+                j++;
+                temp--;
+            }
+            fourEdges[num/2][num/2] = num*num;
+        }
+
+        for(int m = 0; m < num; m++){
+            for(int n = 0; n < num; n++){
+                System.out.print(fourEdges[m][n] + "\t");
+                if((n+1) % num == 0)
+                    System.out.println();
+            }
+        }
+        return fourEdges;
+    }
+
+}
diff --git a/src/stevesun/algorithms/TrappingRainWater.java b/src/stevesun/algorithms/TrappingRainWater.java
@@ -0,0 +1,41 @@
+package stevesun.algorithms;
+
+/**
+ * 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.
+
+ For example,
+ Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.
+
+
+ The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!
+ */
+public class TrappingRainWater {
+
+    public int trap(int[] height) {
+        int len = height.length;
+        if(len == 0){
+            return 0;
+        }
+        int res = 0;
+
+        //first use DP to calculate out left and right arrays
+        int[] left = new int[height.length];
+        int[] right = new int[height.length];
+
+        left[0] = height[0];
+        for(int i = 1; i < height.length; i++){
+            left[i] = Math.max(left[i-1], height[i]);
+        }
+
+        right[height.length-1] = height[height.length-1];
+        for(int i = height.length-2; i >= 0; i--){
+            right[i] = Math.max(right[i+1], height[i]);
+        }
+
+        for(int i = 1; i < height.length-1; i++){
+            res += Math.min(left[i], right[i]) - height[i];
+        }
+        return res;
+    }
+
+}
