[N-0] add 689

Author: fishercoder1534

README.md

@@ -36,6 +36,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |693|[Binary Number with Alternating Bits](https://leetcode.com/problems/binary-number-with-alternating-bits/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_693.java) | O(n) | O(1) | Easy | 
 |692|[Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_692.java) | O(nlogk) | O(n) | Medium | 
 |690|[Employee Importance](https://leetcode.com/problems/employee-importance/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_690.java) | O(n) | O(h) | Easy | DFS
+|689|[Maximum Sum of 3 Non-Overlapping Subarrays](https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_689.java) | O(n) | O(n) | Hard | DP
 |688|[Knight Probability in Chessboard](https://leetcode.com/problems/knight-probability-in-chessboard/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_688.java) | O(n^2) | O(n^2) | Medium | DP
 |687|[Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_687.java) | O(n) | O(h) | Easy | DFS
 |686|[Repeated String Match](https://leetcode.com/problems/repeated-string-match/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_686.java) | O(n*(m+n)) | O(m+n) | Easy | 

src/main/java/com/fishercoder/solutions/_689.java

@@ -21,9 +21,64 @@
  */
 public class _689 {
     public static class Solution1 {
+        /**we basically need to find the interval (i, i+k-1) as the middle interval, where k <= i <= n-2k
+         * then this interval (0, i-1) will be the left interval
+         * the interval (i+k, n-1) will be the right interval.
+         *
+         * Please pay special attention to the variable name I use here: this `k` is not a random one, it's the `k`
+         * from the passed in parameter.
+         *
+         * Credit: https://discuss.leetcode.com/topic/105577/c-java-dp-with-explanation-o-n/*/
         public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
+            if (nums == null || nums.length == 0) {
+                return new int[]{};
+            }
+            int n = nums.length;
+            int[] sums = new int[n + 1];
+            for (int i = 0; i < n; i++) {
+                sums[i + 1] = sums[i] + nums[i];
+            }
 
-            return new int[]{};
+            int[] leftMax = new int[n];
+            for (int i = k, total = sums[k] - sums[0]; i < n; i++) {
+                if (sums[i + 1] - sums[i + 1 - k] > total) {
+                    leftMax[i] = i + 1 - k;
+                    total = sums[i + 1] - sums[i + 1 - k];
+                } else {
+                    leftMax[i] = leftMax[i - 1];
+                }
+            }
+
+            int[] rightMax = new int[n];
+            rightMax[n - k] = n - k;
+            for (int i = n - k - 1, total = sums[n] - sums[n - k]; i >= 0; i--) {
+                if (sums[i + k] - sums[i] >= total) {
+                    rightMax[i] = i;
+                    total = sums[i + k] - sums[i];
+                } else {
+                    rightMax[i] = rightMax[i + 1];
+                }
+            }
+
+            //try to find all possible middle intervals
+            int[] result = new int[3];
+            int max = 0;
+            for (int i = k; i <= n - 2 * k; i++) {
+                int left = leftMax[i - 1];
+                int right = rightMax[i + k];
+                int total = (sums[i + k] - sums[i]) + (sums[left + k] - sums[left]) + (sums[right + k] - sums[right]);
+                if (total > max) {
+                    max = total;
+                    result[0] = left;
+                    result[1] = i;
+                    result[2] = right;
+                }
+            }
+            return result;
         }
     }
+
+    public static class Solution2 {
+        /**reference: https://leetcode.com/articles/maximum-sum-of-3-non-overlapping-intervals*/
+    }
 }

src/test/java/com/fishercoder/_689Test.java

@@ -0,0 +1,27 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._689;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class _689Test {
+    private static _689.Solution1 solution1;
+    private static int[] nums;
+    private static int[] expected;
+    private static int k;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _689.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{1, 2, 1, 2, 6, 7, 5, 1};
+        expected = new int[]{0, 3, 5};
+        k = 2;
+        assertArrayEquals(expected, solution1.maxSumOfThreeSubarrays(nums, 2));
+    }
+}