product of array except self

Author: JoshuaJiangFD

src/main/java/joshua/leetcode/array/DualSum.java

@@ -1,5 +1,7 @@
 package joshua.leetcode.array;
 
+import joshua.leetcode.solutiontag.TwoPointers;
+
 import java.util.Arrays;
 import java.util.HashMap;
 
@@ -64,6 +66,7 @@ public int[] twoSum(int[] numbers, int target) {
 	 * @author joy
 	 *
 	 */
+	@TwoPointers
 	static class Solution2 extends DualSum{
 
 		@Override

src/main/java/joshua/leetcode/array/ProductOfArrayExceptSelf.java

@@ -0,0 +1,62 @@
+package joshua.leetcode.array;
+
+/**
+ * 238. Product of Array Except Self<br/>
+ * <p/>
+ * <a href = "https://leetcode.com/problems/product-of-array-except-self/">leetcode link</a>
+ * <p/>
+ * Created by joshu on 2016/5/27.
+ */
+public abstract class ProductOfArrayExceptSelf {
+
+    /**
+     * Given an array of n integers where n > 1, nums,
+     * return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].
+     * <p/>
+     * Solve it without division and in O(n).
+     * <p/>
+     * For example, given [1,2,3,4], return [24,12,8,6].
+     * <p/>
+     * Follow up:
+     * Could you solve it with constant space complexity?
+     * (Note: The output array does not count as extra space for the purpose of space complexity analysis.)
+     *
+     * @param nums
+     * @return
+     */
+    public abstract int[] productExceptSelf(int[] nums);
+
+    /**
+     * o(n)的算法，但是需要n的额外空间。
+     * 维护两个数组，保存从左到右和从右到左的元素的乘积，即[0,..,k]和[k,..,nums.length-1]的乘积。
+     * 最后将两个数组上相同位置上的值相乘即可。
+     */
+    public static class Solution1 extends ProductOfArrayExceptSelf {
+
+        @Override
+        public int[] productExceptSelf(int[] nums) {
+            int[] fromLeft = new int[nums.length];
+            int[] fromRight = new int[nums.length];
+
+            for(int i = 0 ;i < nums.length; i++) {
+                if(i == 0) {
+                    fromLeft[i] = 1;
+                } else {
+                    fromLeft[i] = fromLeft[i-1] * nums[i-1];
+                }
+            }
+            for(int i = nums.length -1 ;i > -1; i--) {
+                if(i == nums.length-1) {
+                    fromRight[i] = 1;
+                } else {
+                    fromRight[i] = fromRight[i+1] * nums[i+1];
+                }
+            }
+            // multiple the two array calculated above
+            for(int i = 0; i < nums.length; i++) {
+                fromLeft[i] *= fromRight[i];
+            }
+            return fromLeft;
+        }
+    }
+}

src/main/java/joshua/leetcode/array/FindCelebrity.java renamed to src/main/java/joshua/leetcode/array/twopointers/FindCelebrity.java

@@ -1,4 +1,4 @@
-package joshua.leetcode.array;
+package joshua.leetcode.array.twopointers;
 
 import joshua.leetcode.solutiontag.TwoPointers;
 

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

@@ -37,6 +37,7 @@ public static class Solution1 extends TrappingRainWater {
          * 因此可以继续移动低的一侧的指针，同时判断移动的过程中能够trap的水量（小方块），直到到达最低点。
          * 这时候再次判断left pointer和right pointer的大小。
          * 直到两个指针相遇。
+         * <a href ="https://leetcode.com/discuss/16171/sharing-my-simple-c-code-o-n-time-o-1-space">leetcode link</a>
          */
         @Override
         public int trap(int[] height) {
@@ -108,4 +109,42 @@ public int trap(int[] height) {
             return water;
         }
     }
+
+    /**
+     * 一个更直观的two pointer分解之后的解法
+     *
+     * <a href="https://leetcode.com/discuss/104352/java-2ms-o-n-time-o-1-space">leetcode link</a>
+     */
+    @TwoPointers
+    public static class Solution3 extends TrappingRainWater {
+
+        @Override
+        public int trap(int[] height) {
+            int water = 0;
+            if (height.length < 3) return water;
+
+            int maxHeight = 0;
+            int maxHeightPos = 0;
+            for (int i = 0; i < height.length; i++) {
+                if (height[i] > maxHeight) {
+                    maxHeight = height[i];
+                    maxHeightPos = i;
+                }
+            }
+
+            int prevHeight = height[0];
+            for (int i = 1; i < maxHeightPos; i++) {
+                if (height[i] < prevHeight) water += prevHeight - height[i];
+                else prevHeight = height[i];
+            }
+
+            prevHeight = height[height.length - 1];
+            for (int i = height.length - 1; i > maxHeightPos; i--) {
+                if (height[i] < prevHeight) water += prevHeight - height[i];
+                else prevHeight = height[i];
+            }
+
+            return water;
+        }
+    }
 }

src/test/java/joshua/leetcode/array/ProductOfArrayExceptSelfTest.java

@@ -0,0 +1,27 @@
+package joshua.leetcode.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by joshu on 2016/5/27.
+ */
+public class ProductOfArrayExceptSelfTest {
+
+    ProductOfArrayExceptSelf solution;
+
+    @Before
+    public void setUp() {
+        solution = new ProductOfArrayExceptSelf.Solution1();
+    }
+
+    @Test
+    public void testSolution() {
+        int[] input = new int[]{1,2,3,4};
+        int[] output = solution.productExceptSelf(input);
+        assertArrayEquals(new int[]{24,12,8,6}, output);
+    }
+
+}