add 2771

Author: Ashwagandha-coder

contest/src/main/java/com/github/contest/Execute.kt

@@ -1,7 +1,7 @@
 package com.github.contest
 
 
-import com.github.contest.math.closestPrimes
+import com.github.contest.dp.maxNonDecreasingLength
 import java.util.TreeMap
 
 
@@ -11,7 +11,7 @@ import java.util.TreeMap
 
 fun main() {
 
-    closestPrimes(19, 31).also { it.printArray() }
+    maxNonDecreasingLength(intArrayOf(11, 7, 7, 9), intArrayOf(19, 19, 1, 7))
 }
 
 fun generateTesting() {

contest/src/main/java/com/github/contest/dp/DpLeetcode.kt

@@ -454,4 +454,75 @@ fun longestMountain(arr: IntArray): Int {
     return longestMountain
 }
 
+/**
+ *
+ */
+
+fun longestSubArray(nums: IntArray): Int {
+    var left = 0
+    var zeroCount = 0
+    var maxLen = 0
+
+    for (right in nums.indices) {
+        if (nums[right] == 0) {
+            zeroCount++
+        }
+
+        while (zeroCount > 1) {
+            if (nums[left] == 0) {
+                zeroCount--
+            }
+            left++
+        }
+
+        maxLen = maxOf(maxLen, right - left)
+    }
+
+    return maxLen
+}
+
+/**
+ * 2771. Longest Non-decreasing Subarray From Two Arrays
+ */
+
+
+fun maxNonDecreasingLength(nums1: IntArray, nums2: IntArray): Int {
+    val n = nums1.size
+    // dp1[i]: Length of the longest non-decreasing subarray ending at index i, choosing nums1[i]
+    // dp2[i]: Length of the longest non-decreasing subarray ending at index i, choosing nums2[i]
+    val dp1 = IntArray(n) { 1 }
+    val dp2 = IntArray(n) { 1 }
+    var maxLen = 1
+
+    for (i in 1 until n) {
+        // Case 1: Extending from nums1[i-1] to nums1[i]
+        if (nums1[i] >= nums1[i - 1]) {
+            dp1[i] = dp1[i - 1] + 1
+        }
+
+        // Case 2: Extending from nums2[i-1] to nums1[i]
+        if (nums1[i] >= nums2[i - 1]) {
+            dp1[i] = maxOf(dp1[i], dp2[i - 1] + 1)
+        }
+
+        // Case 3: Extending from nums2[i-1] to nums2[i]
+        if (nums2[i] >= nums2[i - 1]) {
+            dp2[i] = dp2[i - 1] + 1
+        }
+
+        // Case 4: Extending from nums1[i-1] to nums2[i]
+        if (nums2[i] >= nums1[i - 1]) {
+            dp2[i] = maxOf(dp2[i], dp1[i - 1] + 1)
+        }
+
+        // Update the overall maximum length
+        maxLen = maxOf(maxLen, maxOf(dp1[i], dp2[i]))
+    }
+
+    return maxLen
+}
+
+
+
+