add 918

fishercoder1534 · fishercoder1534 · commit 20fede4c82a2 · 2021-09-29T11:36:42.000-07:00
diff --git a/README.md b/README.md
@@ -480,6 +480,7 @@ _If you like this project, please leave me a star._ &#9733;
 |923|[3Sum With Multiplicity](https://leetcode.com/problems/3sum-with-multiplicity/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_923.java) | |Medium|Two Pointers
 |922|[Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_922.java) |  |Easy|
 |921|[Minimum Add to Make Parentheses Valid](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_921.java) | |Medium|Stack, Greedy
+|918|[Maximum Sum Circular Subarray](https://leetcode.com/problems/maximum-sum-circular-subarray/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_918.java) |  |Medium|Array, DP, Monotonic Queue
 |917|[Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_917.java) |  |Easy|
 |914|[X of a Kind in a Deck of Cards](https://leetcode.com/problems/x-of-a-kind-in-a-deck-of-cards/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_914.java) |  |Easy|
 |912|[Sort an Array](https://leetcode.com/problems/sort-an-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_912.java) |  |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_918.java b/src/main/java/com/fishercoder/solutions/_918.java
@@ -0,0 +1,83 @@
+package com.fishercoder.solutions;
+
+public class _918 {
+    public static class Solution1 {
+        /**
+         * This is my original solution, but results in TLE on LeetCode.
+         * Time: O(n^2)
+         */
+        public int maxSubarraySumCircular(int[] nums) {
+            int[] prefixSums;
+            int maxSum = Integer.MIN_VALUE;
+            for (int i = 0; i < nums.length; i++) {
+                prefixSums = new int[nums.length];
+                for (int j = i, k = 0; j < (i + nums.length); j++) {
+                    if (k == 0) {
+                        prefixSums[k] = nums[(j + nums.length) % nums.length];
+                    } else {
+                        prefixSums[k] = prefixSums[k - 1] + nums[(j + nums.length) % nums.length];
+                    }
+                    maxSum = Math.max(maxSum, prefixSums[k++]);
+                }
+            }
+            return maxSum;
+        }
+    }
+
+    public static class Solution2 {
+        /**
+         * Credit: https://leetcode.com/problems/maximum-sum-circular-subarray/discuss/178422/One-Pass
+         * Think of two cases:
+         * 1. the max comes from the contiguous part of the original array
+         * 2. the max comes from connecting the tail part and the head part of the original array.
+         * See graph from the above link.
+         * <p>
+         * Time: O(n)
+         * <p>
+         * This is a follow-up from https://leetcode.com/problems/maximum-subarray/ which is solved by Kadane's algorithm.
+         */
+        public int maxSubarraySumCircular(int[] nums) {
+            int currMax = 0;
+            int globalMax = nums[0];
+            int currMin = 0;
+            int globalMin = nums[0];
+            int total = 0;
+            for (int i = 0; i < nums.length; i++) {
+                currMax = Math.max(nums[i], currMax + nums[i]);
+                globalMax = Math.max(globalMax, currMax);
+                currMin = Math.min(currMin + nums[i], nums[i]);
+                globalMin = Math.min(currMin, globalMin);
+                total += nums[i];
+            }
+            return globalMax > 0 ? Math.max(globalMax, total - globalMin) : globalMax;
+        }
+    }
+
+    public static class Solution3 {
+        /**
+         * Credit: https://leetcode.com/problems/maximum-sum-circular-subarray/discuss/633058/Java-or-C%2B%2B-or-Python3-or-With-detailed-explanation-or-O(N)-time-or-O(1)
+         * This one is similar to the above Solution2, but only slightly differs in that it starts from i = 1 instead of i = 0
+         * And it listed out a few examples to help illustrate why this algorithm makes sense.
+         * Which I think is easier to make sense of.
+         * <p>
+         * Time: O(n)
+         * <p>
+         * This is a follow-up from https://leetcode.com/problems/maximum-subarray/ which is solved by Kadane's algorithm.
+         */
+        public int maxSubarraySumCircular(int[] nums) {
+            int currMax = nums[0];
+            int globalMax = nums[0];
+            int currMin = nums[0];
+            int globalMin = nums[0];
+            int total = nums[0];
+            for (int i = 1; i < nums.length; i++) {
+                currMax = Math.max(nums[i], currMax + nums[i]);
+                globalMax = Math.max(globalMax, currMax);
+                currMin = Math.min(currMin + nums[i], nums[i]);
+                globalMin = Math.min(currMin, globalMin);
+                total += nums[i];
+            }
+            return globalMax > 0 ? Math.max(globalMax, total - globalMin) : globalMax;
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_918Test.java b/src/test/java/com/fishercoder/_918Test.java
@@ -0,0 +1,60 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._918;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _918Test {
+    private static _918.Solution1 solution1;
+    private static _918.Solution2 solution2;
+    private static _918.Solution3 solution3;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _918.Solution1();
+        solution2 = new _918.Solution2();
+        solution3 = new _918.Solution3();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(3, solution1.maxSubarraySumCircular(new int[]{1, -2, 3, -2}));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(10, solution1.maxSubarraySumCircular(new int[]{5, -3, 5}));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(4, solution1.maxSubarraySumCircular(new int[]{3, -1, 2, -1}));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(3, solution1.maxSubarraySumCircular(new int[]{3, -2, 2, -3}));
+    }
+
+    @Test
+    public void test5() {
+        assertEquals(-1, solution1.maxSubarraySumCircular(new int[]{-2, -3, -1}));
+    }
+
+    @Test
+    public void test6() {
+        assertEquals(10, solution1.maxSubarraySumCircular(new int[]{5, -3, 5}));
+    }
+
+    @Test
+    public void test7() {
+        assertEquals(10, solution2.maxSubarraySumCircular(new int[]{5, -3, 5}));
+    }
+
+    @Test
+    public void test8() {
+        assertEquals(10, solution3.maxSubarraySumCircular(new int[]{5, -3, 5}));
+    }
+}
