add new problems of DP

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

@@ -1,7 +1,7 @@
 package com.github.contest
 
 
-import com.github.contest.array.sortArrayByParityIIAlternativeSolution
+import com.github.contest.dp.longestArithSeqLength
 import java.util.TreeMap
 
 
@@ -11,8 +11,7 @@ import java.util.TreeMap
 
 fun main() {
 
-    sortArrayByParityIIAlternativeSolution(intArrayOf(4, 2, 5, 7)).also { it.printArray() }
-
+    longestArithSeqLength(intArrayOf(3, 6, 9, 12))
 }
 
 fun generateTesting() {

contest/src/main/java/com/github/contest/array/AlternativeSolutionArray.kt

@@ -39,4 +39,34 @@ fun sortArrayByParityIIAlternativeSolution(nums: IntArray): IntArray {
     }
 
     return nums
+}
+
+/**
+ * 2460. Apply Operations to an Array
+ * Alternative Solution
+ */
+
+fun applyOperationsAlternativeSolution(nums: IntArray): IntArray {
+    for (i in 0 until nums.size - 1) {
+        if (nums[i] == nums[i + 1]) {
+            nums[i] *= 2
+            nums[i + 1] = 0
+        }
+    }
+
+    var insertPosition = 0
+    for (i in nums.indices) {
+        if (nums[i] != 0) {
+            nums[insertPosition] = nums[i]
+            insertPosition++
+        }
+    }
+
+    while (insertPosition < nums.size) {
+        nums[insertPosition] = 0
+        insertPosition++
+    }
+
+    return nums
+
 }

contest/src/main/java/com/github/contest/array/ArrayLeetcode.kt

@@ -62,4 +62,37 @@ fun sortArrayByParityII(nums: IntArray): IntArray {
     return nums
 }
 
+/**
+ * 2460. Apply Operations to an Array
+ */
+
+fun applyOperations(nums: IntArray): IntArray {
+    for (i in 0 until nums.size - 1) {
+        if (nums[i] == nums[i + 1]) {
+            nums[i] *= 2
+            nums[i + 1] = 0
+        }
+    }
+    var i = 0
+    var j = 1
+    while (i < nums.size && j < nums.size) {
+        while (i < nums.size && nums[i] != 0) i++
+        j = i
+        while (j < nums.size && nums[j] == 0) j++
+        if (i < nums.size && j < nums.size) {
+            nums.swap(i, j)
+            i++
+            j++
+        }
+    }
+
+    return nums
+}
+
+private fun IntArray.swap(from: Int, to: Int) {
+    val temp = this[from]
+    this[from] = this[to]
+    this[to] = temp
+}
+
 

contest/src/main/java/com/github/contest/array/ArrayProdVariant.kt

@@ -24,3 +24,52 @@ fun getCommonProdVariant(nums1: IntArray, nums2: IntArray): Int {
 
 fun isArraySpecialProdVariant(nums: IntArray): Boolean =
     nums.isEmpty() || nums.toList().windowed(2).all { (a, b) -> a % 2 != b % 2 }
+
+
+/**
+ * 2460. Apply Operations to an Array
+ * Prod Variant
+ */
+
+fun applyOperationsProdVariant(nums: IntArray): IntArray {
+    (0 until nums.size - 1).forEach { index ->
+        if (nums[index] == nums[index + 1]) {
+            nums[index] *= 2
+            nums[index + 1] = 0
+        }
+    }
+
+    var insertIndex = 0
+    nums.indices.forEach {
+        if (it != 0) {
+            nums[insertIndex] = it
+            insertIndex++
+        }
+    }
+
+    (insertIndex until nums.size).forEach {
+        nums[it] = 0
+    }
+
+    return nums
+}
+
+
+fun applyOperationsProdVariantII(nums: IntArray): IntArray {
+    nums.indices.drop(1).forEach { i ->
+        if (nums[i - 1] == nums[i]) {
+            nums[i - 1] *= 2
+            nums[i] = 0
+        }
+    }
+
+    var insertPos = 0
+    nums.forEach { num ->
+        if (num != 0) {
+            nums[insertPos++] = num
+        }
+    }
+    nums.fill(0, insertPos)
+
+    return nums
+}

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

@@ -350,4 +350,70 @@ fun maxAbsoluteSum(nums: IntArray): Int {
     }
 
     return maxOf(maxSoFar, abs(minSoFar))
-}
+}
+
+/**
+ * 1143. Longest Common Subsequence
+ */
+
+fun longestCommonSubsequence(text1: String, text2: String): Int {
+    val n = text1.length
+    val m = text2.length
+    val dp = Array(n + 1) { IntArray(m + 1) }
+
+    for (i in 1..n) {
+        for (j in 1..m) {
+            if (text1[i - 1] == text2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            } else {
+                dp[i][j] = maxOf(dp[i][j - 1], dp[i - 1][j])
+            }
+        }
+    }
+
+    return dp[n][m]
+}
+
+/**
+ * 1048. Longest String Chain
+ */
+
+fun longestStrChain(words: Array<String>): Int {
+    val sortedWords = words.sortedBy { it.length }
+    val dp = mutableMapOf<String, Int>()
+    var longestChain = 0
+
+    for (word in sortedWords) {
+        var currentChain = 1
+        for (i in word.indices) {
+            val predecessor = word.removeRange(i, i + 1)
+            currentChain = maxOf(currentChain, dp.getOrDefault(predecessor, 0) + 1)
+        }
+        dp[word] = currentChain
+        longestChain = maxOf(longestChain, currentChain)
+    }
+
+    return longestChain
+}
+
+/**
+ * 1027. Longest Arithmetic Subsequence
+ */
+
+fun longestArithSeqLength(nums: IntArray): Int {
+    val n = nums.size
+
+    val dp = Array(n) { mutableMapOf<Int, Int>() }
+    var longest = 2
+
+    for (i in 1 until n) {
+        for (j in 0 until i) {
+            val diff = nums[i] - nums[j]
+            val length = dp[j].getOrDefault(diff, 1) + 1
+            dp[i][diff] = length
+            longest = maxOf(longest, length)
+        }
+    }
+
+    return longest
+}

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

@@ -85,3 +85,27 @@ fun longestIdealStringProdVariantII(s: String, k: Int): Int =
         }
     }.max()
 
+
+/**
+ * 1143. Longest Common Subsequence
+ * Prod Variant
+ */
+
+fun longestCommonSubsequenceProdVariant(text1: String, text2: String): Int {
+    val n = text1.length
+    val m = text2.length
+    val dp = Array(n + 1) { IntArray(m + 1) }
+
+    (1..n).forEach { row ->
+        (1..m).forEach { col ->
+            dp[row][col] = when {
+                text1[row - 1] == text2[col - 1] -> dp[row - 1][col - 1] + 1
+                else -> maxOf(dp[row - 1][col], dp[row][col - 1])
+            }
+        }
+    }
+
+    return dp.lastElement()
+}
+
+private fun Array<IntArray>.lastElement(): Int = this.last().last()