Solution to "Trionic Array II" hard problem

Author: dkoval

src/main/java/com/github/dkoval/leetcode/challenge/TrionicArray2.java

@@ -0,0 +1,85 @@
+package com.github.dkoval.leetcode.challenge;
+
+import java.util.ArrayList;
+import java.util.function.BiFunction;
+
+/**
+ * <a href="https://leetcode.com/problems/trionic-array-ii/">Trionic Array II (Hard)</a>
+ * <p>
+ * You are given an integer array nums of length n.
+ * <p>
+ * A trionic subarray is a contiguous subarray nums[l...r] (with 0 <= l < r < n) for which there exist indices l < p < q < r such that:
+ * <ul>
+ *  <li>nums[l...p] is strictly increasing,</li>
+ *  <li>nums[p...q] is strictly decreasing,</li>
+ *  <li>nums[q...r] is strictly increasing.</li>
+ * </ul>
+ * Return the maximum sum of any trionic subarray in nums.
+ * <p>
+ * Constraints:
+ * <ul>
+ *  <li>4 <= n = nums.length <= 10^5</li>
+ *  <li>-10^9 <= nums[i] <= 10^9</li>
+ *  <li>It is guaranteed that at least one trionic subarray exists.</li>
+ * </ul>
+ */
+public interface TrionicArray2 {
+
+    long maxSumTrionic(int[] nums);
+
+    class TrionicArray2Rev1 implements TrionicArray2 {
+
+        @Override
+        public long maxSumTrionic(int[] nums) {
+            final var n = nums.length;
+
+            // step 1: find decreasing chunks
+            final var decreasing = new ArrayList<Interval>();
+            var start = -1;
+            var sum = 0L;
+            for (var i = 0; i < n - 1; i++) {
+                if (nums[i] > nums[i + 1]) {
+                    if (start < 0) {
+                        start = i;
+                    }
+                    sum += nums[i];
+                } else {
+                    if (start >= 0) {
+                        sum += nums[i];
+                        decreasing.add(new Interval(start, i, sum));
+                        start = -1;
+                        sum = 0;
+                    }
+                }
+            }
+
+            // step 2: find increasing chunks to the left and to the right of a decreasing one
+            var best = Long.MIN_VALUE;
+            for (var interval : decreasing) {
+                if (interval.start == 0 || interval.end == n - 1) {
+                    continue;
+                }
+
+                var leftSum = maxSumOfIncreasing(nums, interval.start, -1, (a, b) -> a > b);
+                var rightSum = maxSumOfIncreasing(nums, interval.end, 1, (a, b) -> a < b);
+                best = Math.max(best, interval.sum + leftSum + rightSum);
+            }
+            return best;
+        }
+
+        private long maxSumOfIncreasing(int[] nums, int start, int step, BiFunction<Integer, Integer, Boolean> comparator) {
+            var i = start;
+            var total = 0L;
+            var best = Long.MIN_VALUE;
+            while (i > 0 && i < nums.length - 1 && comparator.apply(nums[i], nums[i + step])) {
+                i += step;
+                total += nums[i];
+                best = Math.max(best, total);
+            }
+            return best;
+        }
+
+        record Interval(int start, int end, long sum) {
+        }
+    }
+}

src/test/kotlin/com/github/dkoval/leetcode/challenge/TrionicArray2Test.kt

@@ -0,0 +1,48 @@
+package com.github.dkoval.leetcode.challenge
+
+import com.github.dkoval.leetcode.challenge.TrionicArray2.TrionicArray2Rev1
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.Arguments.arguments
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
+import org.junit.jupiter.params.support.ParameterDeclarations
+import java.util.stream.Stream
+
+internal class TrionicArray2Test {
+
+    class InputArgumentsProvider : ArgumentsProvider {
+
+        override fun provideArguments(
+            parameters: ParameterDeclarations,
+            context: ExtensionContext
+        ): Stream<out Arguments> = Stream.of(
+            arguments(
+                intArrayOf(0, -2, -1, -3, 0, 2, -1),
+                -4L
+            ),
+            arguments(
+                intArrayOf(1, 4, 2, 7),
+                14L
+            )
+        )
+    }
+
+    @Nested
+    inner class TrionicArray2Rev1Test {
+
+        @ParameterizedTest
+        @ArgumentsSource(InputArgumentsProvider::class)
+        fun `should return the maximum sum of any trionic subarray in nums`(nums: IntArray, expected: Long) {
+            TrionicArray2Rev1().test(nums, expected)
+        }
+    }
+}
+
+private fun TrionicArray2.test(nums: IntArray, expected: Long) {
+    val actual = maxSumTrionic(nums)
+    assertEquals(expected, actual)
+}