diff --git a/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/Solution.kt b/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/Solution.kt
new file mode 100644
index 000000000..7fd190b87
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/Solution.kt
@@ -0,0 +1,18 @@
+package g3401_3500.s3423_maximum_difference_between_adjacent_elements_in_a_circular_array
+
+// #Easy #2025_01_19_Time_2_(100.00%)_Space_38.80_(100.00%)
+
+import kotlin.math.abs
+import kotlin.math.max
+
+class Solution {
+    fun maxAdjacentDistance(nums: IntArray): Int {
+        var maxDiff = 0
+        for (i in nums.indices) {
+            val nextIndex = (i + 1) % nums.size
+            val diff = abs((nums[i] - nums[nextIndex]))
+            maxDiff = max(maxDiff, diff)
+        }
+        return maxDiff
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/readme.md b/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/readme.md
new file mode 100644
index 000000000..924b26986
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/readme.md
@@ -0,0 +1,32 @@
+3423\. Maximum Difference Between Adjacent Elements in a Circular Array
+
+Easy
+
+Given a **circular** array `nums`, find the **maximum** absolute difference between adjacent elements.
+
+**Note**: In a circular array, the first and last elements are adjacent.
+
+**Example 1:**
+
+**Input:** nums = [1,2,4]
+
+**Output:** 3
+
+**Explanation:**
+
+Because `nums` is circular, `nums[0]` and `nums[2]` are adjacent. They have the maximum absolute difference of `|4 - 1| = 3`.
+
+**Example 2:**
+
+**Input:** nums = [-5,-10,-5]
+
+**Output:** 5
+
+**Explanation:**
+
+The adjacent elements `nums[0]` and `nums[1]` have the maximum absolute difference of `|-5 - (-10)| = 5`.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   `-100 <= nums[i] <= 100`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/Solution.kt b/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/Solution.kt
new file mode 100644
index 000000000..6921be99c
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/Solution.kt
@@ -0,0 +1,28 @@
+package g3401_3500.s3424_minimum_cost_to_make_arrays_identical
+
+// #Medium #Array #Sorting #Greedy #2025_01_23_Time_38_(100.00%)_Space_64.36_(97.14%)
+
+import kotlin.math.abs
+import kotlin.math.min
+
+class Solution {
+    fun minCost(arr: IntArray, brr: IntArray, k: Long): Long {
+        val n = arr.size
+        var sum1: Long = 0
+        var sum2: Long
+        for (i in 0..<n) {
+            sum1 = sum1 + abs((arr[i] - brr[i]))
+        }
+        if (k < sum1) {
+            arr.sort()
+            brr.sort()
+            sum2 = k
+            for (i in 0..<n) {
+                sum2 = sum2 + abs((arr[i] - brr[i]))
+            }
+        } else {
+            return sum1
+        }
+        return min(sum1, sum2)
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/readme.md b/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/readme.md
new file mode 100644
index 000000000..2cd554df5
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/readme.md
@@ -0,0 +1,43 @@
+3424\. Minimum Cost to Make Arrays Identical
+
+Medium
+
+You are given two integer arrays `arr` and `brr` of length `n`, and an integer `k`. You can perform the following operations on `arr` _any_ number of times:
+
+*   Split `arr` into _any_ number of **contiguous** **non-empty subarrays** and rearrange these subarrays in _any order_. This operation has a fixed cost of `k`.
+*   Choose any element in `arr` and add or subtract a positive integer `x` to it. The cost of this operation is `x`.
+    
+
+Return the **minimum** total cost to make `arr` **equal** to `brr`.
+
+**Example 1:**
+
+**Input:** arr = [-7,9,5], brr = [7,-2,-5], k = 2
+
+**Output:** 13
+
+**Explanation:**
+
+*   Split `arr` into two contiguous subarrays: `[-7]` and `[9, 5]` and rearrange them as `[9, 5, -7]`, with a cost of 2.
+*   Subtract 2 from element `arr[0]`. The array becomes `[7, 5, -7]`. The cost of this operation is 2.
+*   Subtract 7 from element `arr[1]`. The array becomes `[7, -2, -7]`. The cost of this operation is 7.
+*   Add 2 to element `arr[2]`. The array becomes `[7, -2, -5]`. The cost of this operation is 2.
+
+The total cost to make the arrays equal is `2 + 2 + 7 + 2 = 13`.
+
+**Example 2:**
+
+**Input:** arr = [2,1], brr = [2,1], k = 0
+
+**Output:** 0
+
+**Explanation:**
+
+Since the arrays are already equal, no operations are needed, and the total cost is 0.
+
+**Constraints:**
+
+*   <code>1 <= arr.length == brr.length <= 10<sup>5</sup></code>
+*   <code>0 <= k <= 2 * 10<sup>10</sup></code>
+*   <code>-10<sup>5</sup> <= arr[i] <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= brr[i] <= 10<sup>5</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3425_longest_special_path/Solution.kt b/src/main/kotlin/g3401_3500/s3425_longest_special_path/Solution.kt
new file mode 100644
index 000000000..7930edcc8
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3425_longest_special_path/Solution.kt
@@ -0,0 +1,91 @@
+package g3401_3500.s3425_longest_special_path
+
+// #Hard #2025_01_19_Time_106_(100.00%)_Space_187.68_(100.00%)
+
+class Solution {
+    private lateinit var adj: Array<ArrayList<IntArray>>
+    private lateinit var nums: IntArray
+    private lateinit var dist: IntArray
+    private lateinit var lastOccur: IntArray
+    private lateinit var pathStack: ArrayList<Int>
+    private var minIndex = 0
+    private var maxLen = 0
+    private var minNodesForMaxLen = 0
+
+    fun longestSpecialPath(edges: Array<IntArray>, nums: IntArray): IntArray {
+        val n = nums.size
+        this.nums = nums
+        adj = Array<ArrayList<IntArray>>(n) { ArrayList<IntArray>() }
+        for (i in 0..<n) {
+            adj[i] = ArrayList<IntArray>()
+        }
+        for (e in edges) {
+            val u = e[0]
+            val v = e[1]
+            val w = e[2]
+            adj[u].add(intArrayOf(v, w))
+            adj[v].add(intArrayOf(u, w))
+        }
+        dist = IntArray(n)
+        buildDist(0, -1, 0)
+        var maxVal = 0
+        for (`val` in nums) {
+            if (`val` > maxVal) {
+                maxVal = `val`
+            }
+        }
+        lastOccur = IntArray(maxVal + 1)
+        lastOccur.fill(-1)
+        pathStack = ArrayList<Int>()
+        minIndex = 0
+        maxLen = 0
+        minNodesForMaxLen = Int.Companion.MAX_VALUE
+        dfs(0, -1)
+        return intArrayOf(maxLen, minNodesForMaxLen)
+    }
+
+    private fun buildDist(u: Int, parent: Int, currDist: Int) {
+        dist[u] = currDist
+        for (edge in adj[u]) {
+            val v = edge[0]
+            val w = edge[1]
+            if (v == parent) {
+                continue
+            }
+            buildDist(v, u, currDist + w)
+        }
+    }
+
+    private fun dfs(u: Int, parent: Int) {
+        val stackPos = pathStack.size
+        pathStack.add(u)
+        val `val` = nums[u]
+        val oldPos = lastOccur[`val`]
+        val oldMinIndex = minIndex
+        lastOccur[`val`] = stackPos
+        if (oldPos >= minIndex) {
+            minIndex = oldPos + 1
+        }
+        if (minIndex <= stackPos) {
+            val ancestor = pathStack[minIndex]
+            val pathLength = dist[u] - dist[ancestor]
+            val pathNodes = stackPos - minIndex + 1
+            if (pathLength > maxLen) {
+                maxLen = pathLength
+                minNodesForMaxLen = pathNodes
+            } else if (pathLength == maxLen && pathNodes < minNodesForMaxLen) {
+                minNodesForMaxLen = pathNodes
+            }
+        }
+        for (edge in adj[u]) {
+            val v = edge[0]
+            if (v == parent) {
+                continue
+            }
+            dfs(v, u)
+        }
+        pathStack.removeAt(pathStack.size - 1)
+        lastOccur[`val`] = oldPos
+        minIndex = oldMinIndex
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3425_longest_special_path/readme.md b/src/main/kotlin/g3401_3500/s3425_longest_special_path/readme.md
new file mode 100644
index 000000000..53b174799
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3425_longest_special_path/readme.md
@@ -0,0 +1,48 @@
+3425\. Longest Special Path
+
+Hard
+
+You are given an undirected tree rooted at node `0` with `n` nodes numbered from `0` to `n - 1`, represented by a 2D array `edges` of length `n - 1`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> indicates an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with length <code>length<sub>i</sub></code>. You are also given an integer array `nums`, where `nums[i]` represents the value at node `i`.
+
+A **special path** is defined as a **downward** path from an ancestor node to a descendant node such that all the values of the nodes in that path are **unique**.
+
+**Note** that a path may start and end at the same node.
+
+Return an array `result` of size 2, where `result[0]` is the **length** of the **longest** special path, and `result[1]` is the **minimum** number of nodes in all _possible_ **longest** special paths.
+
+**Example 1:**
+
+**Input:** edges = [[0,1,2],[1,2,3],[1,3,5],[1,4,4],[2,5,6]], nums = [2,1,2,1,3,1]
+
+**Output:** [6,2]
+
+**Explanation:**
+
+#### In the image below, nodes are colored by their corresponding values in `nums`
+
+![](https://assets.leetcode.com/uploads/2024/11/02/tree3.jpeg)
+
+The longest special paths are `2 -> 5` and `0 -> 1 -> 4`, both having a length of 6. The minimum number of nodes across all longest special paths is 2.
+
+**Example 2:**
+
+**Input:** edges = [[1,0,8]], nums = [2,2]
+
+**Output:** [0,1]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/11/02/tree4.jpeg)
+
+The longest special paths are `0` and `1`, both having a length of 0. The minimum number of nodes across all longest special paths is 1.
+
+**Constraints:**
+
+*   <code>2 <= n <= 5 * 10<sup>4</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 3`
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>1 <= length<sub>i</sub> <= 10<sup>3</sup></code>
+*   `nums.length == n`
+*   <code>0 <= nums[i] <= 5 * 10<sup>4</sup></code>
+*   The input is generated such that `edges` represents a valid tree.
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/Solution.kt b/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/Solution.kt
new file mode 100644
index 000000000..3d2044eb5
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/Solution.kt
@@ -0,0 +1,40 @@
+package g3401_3500.s3426_manhattan_distances_of_all_arrangements_of_pieces
+
+// #Hard #2025_01_19_Time_21_(100.00%)_Space_34.61_(100.00%)
+
+class Solution {
+    private fun comb(a: Long, b: Long, mod: Long): Long {
+        if (b > a) {
+            return 0
+        }
+        var numer: Long = 1
+        var denom: Long = 1
+        for (i in 0..<b) {
+            numer = numer * (a - i) % mod
+            denom = denom * (i + 1) % mod
+        }
+        var denomInv: Long = 1
+        var exp = mod - 2
+        while (exp > 0) {
+            if (exp % 2 > 0) {
+                denomInv = denomInv * denom % mod
+            }
+            denom = denom * denom % mod
+            exp /= 2
+        }
+        return numer * denomInv % mod
+    }
+
+    fun distanceSum(m: Int, n: Int, k: Int): Int {
+        var res: Long = 0
+        val mod: Long = 1000000007
+        val base = comb(m.toLong() * n - 2, k - 2L, mod)
+        for (d in 1..<n) {
+            res = (res + d.toLong() * (n - d) % mod * m % mod * m % mod) % mod
+        }
+        for (d in 1..<m) {
+            res = (res + d.toLong() * (m - d) % mod * n % mod * n % mod) % mod
+        }
+        return (res * base % mod).toInt()
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/readme.md b/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/readme.md
new file mode 100644
index 000000000..4e262e62c
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/readme.md
@@ -0,0 +1,53 @@
+3426\. Manhattan Distances of All Arrangements of Pieces
+
+Hard
+
+You are given three integers `m`, `n`, and `k`.
+
+There is a rectangular grid of size `m × n` containing `k` identical pieces. Return the sum of Manhattan distances between every pair of pieces over all **valid arrangements** of pieces.
+
+A **valid arrangement** is a placement of all `k` pieces on the grid with **at most** one piece per cell.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+The Manhattan Distance between two cells <code>(x<sub>i</sub>, y<sub>i</sub>)</code> and <code>(x<sub>j</sub>, y<sub>j</sub>)</code> is <code>|x<sub>i</sub> - x<sub>j</sub>| + |y<sub>i</sub> - y<sub>j</sub>|</code>.
+
+**Example 1:**
+
+**Input:** m = 2, n = 2, k = 2
+
+**Output:** 8
+
+**Explanation:**
+
+The valid arrangements of pieces on the board are:
+
+![](https://assets.leetcode.com/uploads/2024/12/25/4040example1.drawio)![](https://assets.leetcode.com/uploads/2024/12/25/untitled-diagramdrawio.png)
+
+*   In the first 4 arrangements, the Manhattan distance between the two pieces is 1.
+*   In the last 2 arrangements, the Manhattan distance between the two pieces is 2.
+
+Thus, the total Manhattan distance across all valid arrangements is `1 + 1 + 1 + 1 + 2 + 2 = 8`.
+
+**Example 2:**
+
+**Input:** m = 1, n = 4, k = 3
+
+**Output:** 20
+
+**Explanation:**
+
+The valid arrangements of pieces on the board are:
+
+![](https://assets.leetcode.com/uploads/2024/12/25/4040example2drawio.png)
+
+*   The first and last arrangements have a total Manhattan distance of `1 + 1 + 2 = 4`.
+*   The middle two arrangements have a total Manhattan distance of `1 + 2 + 3 = 6`.
+
+The total Manhattan distance between all pairs of pieces across all arrangements is `4 + 6 + 6 + 4 = 20`.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>2 <= m * n <= 10<sup>5</sup></code>
+*   `2 <= k <= m * n`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/Solution.kt b/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/Solution.kt
new file mode 100644
index 000000000..408438da4
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/Solution.kt
@@ -0,0 +1,15 @@
+package g3401_3500.s3427_sum_of_variable_length_subarrays
+
+// #Easy #Array #Prefix_Sum #2025_01_22_Time_0_(100.00%)_Space_43.77_(58.41%)
+
+class Solution {
+    fun subarraySum(nums: IntArray): Int {
+        var res = nums[0]
+        for (i in 1..<nums.size) {
+            val j = i - nums[i] - 1
+            nums[i] += nums[i - 1]
+            res += nums[i] - (if (j < 0) 0 else nums[j])
+        }
+        return res
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/readme.md b/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/readme.md
new file mode 100644
index 000000000..b40691b8c
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/readme.md
@@ -0,0 +1,94 @@
+3427\. Sum of Variable Length Subarrays
+
+Easy
+
+You are given an integer array `nums` of size `n`. For **each** index `i` where `0 <= i < n`, define a **non-empty subarrays** `nums[start ... i]` where `start = max(0, i - nums[i])`.
+
+Return the total sum of all elements from the subarray defined for each index in the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1]
+
+**Output:** 11
+
+**Explanation:**
+
+i
+
+Subarray
+
+Sum
+
+0
+
+`nums[0] = [2]`
+
+2
+
+1
+
+`nums[0 ... 1] = [2, 3]`
+
+5
+
+2
+
+`nums[1 ... 2] = [3, 1]`
+
+4
+
+**Total Sum**
+
+11
+
+The total sum is 11. Hence, 11 is the output.
+
+**Example 2:**
+
+**Input:** nums = [3,1,1,2]
+
+**Output:** 13
+
+**Explanation:**
+
+i
+
+Subarray
+
+Sum
+
+0
+
+`nums[0] = [3]`
+
+3
+
+1
+
+`nums[0 ... 1] = [3, 1]`
+
+4
+
+2
+
+`nums[1 ... 2] = [1, 1]`
+
+2
+
+3
+
+`nums[1 ... 3] = [1, 1, 2]`
+
+4
+
+**Total Sum**
+
+13
+
+The total sum is 13. Hence, 13 is the output.
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 100`
+*   `1 <= nums[i] <= 1000`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/Solution.kt b/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/Solution.kt
new file mode 100644
index 000000000..f7c52ad15
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/Solution.kt
@@ -0,0 +1,72 @@
+package g3401_3500.s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences
+
+// #Medium #Array #Dynamic_Programming #Math #Sorting #Combinatorics
+// #2025_01_22_Time_167_(77.78%)_Space_75.34_(66.67%)
+
+class Solution {
+    private lateinit var fact: LongArray
+    private lateinit var inv: LongArray
+
+    private fun precomputeFactorials(n: Int) {
+        fact = LongArray(n + 1)
+        inv = LongArray(n + 1)
+        fact[0] = 1
+        for (i in 1..n) {
+            fact[i] = (fact[i - 1] * i) % MOD
+        }
+        inv[n] = power(fact[n], (MOD - 2).toLong(), MOD)
+        for (i in n - 1 downTo 0) {
+            inv[i] = (inv[i + 1] * (i + 1)) % MOD
+        }
+    }
+
+    private fun power(a: Long, b: Long, m: Int): Long {
+        var a = a
+        var b = b
+        var `val`: Long = 1
+        a = a % m
+        while (b > 0) {
+            if ((b and 1L) == 1L) `val` = (`val` * a) % m
+            b = b shr 1
+            a = (a * a) % m
+        }
+        return `val`
+    }
+
+    private fun nCr(n: Int, r: Int): Long {
+        if (r < 0 || r > n) return 0
+        return (fact[n] * inv[r] % MOD * inv[n - r]) % MOD
+    }
+
+    fun minMaxSums(nums: IntArray, k: Int): Int {
+        val n = nums.size
+        nums.sort()
+        precomputeFactorials(n)
+        var sum: Long = 0
+        for (i in 0..<n) {
+            var `val`: Long = 0
+            val a = i
+            val b = n - 1 - i
+            run {
+                var j = 0
+                while (j < k && j <= a) {
+                    `val` = (`val` + nCr(a, j)) % MOD
+                    j++
+                }
+            }
+            sum = (sum + (`val` * nums[i]) % MOD) % MOD
+            `val` = 0
+            var j = 0
+            while (j < k && j <= b) {
+                `val` = (`val` + nCr(b, j)) % MOD
+                j++
+            }
+            sum = (sum + (`val` * nums[i]) % MOD) % MOD
+        }
+        return sum.toInt()
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/readme.md b/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/readme.md
new file mode 100644
index 000000000..83f0095da
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/readme.md
@@ -0,0 +1,59 @@
+3428\. Maximum and Minimum Sums of at Most Size K Subsequences
+
+Medium
+
+You are given an integer array `nums` and a positive integer `k`. Return the sum of the **maximum** and **minimum** elements of all
+
+**subsequences**
+
+of `nums` with **at most** `k` elements.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], k = 2
+
+**Output:** 24
+
+**Explanation:**
+
+The subsequences of `nums` with at most 2 elements are:
+
+| **Subsequence** | Minimum | Maximum | Sum  |
+|-----------------|---------|---------|------|
+| `[1]`           | 1       | 1       | 2    |
+| `[2]`           | 2       | 2       | 4    |
+| `[3]`           | 3       | 3       | 6    |
+| `[1, 2]`        | 1       | 2       | 3    |
+| `[1, 3]`        | 1       | 3       | 4    |
+| `[2, 3]`        | 2       | 3       | 5    |
+| **Final Total** |         |         | 24   |
+
+The output would be 24.
+
+**Example 2:**
+
+**Input:** nums = [5,0,6], k = 1
+
+**Output:** 22
+
+**Explanation:**
+
+For subsequences with exactly 1 element, the minimum and maximum values are the element itself. Therefore, the total is `5 + 5 + 0 + 0 + 6 + 6 = 22`.
+
+**Example 3:**
+
+**Input:** nums = [1,1,1], k = 2
+
+**Output:** 12
+
+**Explanation:**
+
+The subsequences `[1, 1]` and `[1]` each appear 3 times. For all of them, the minimum and maximum are both 1. Thus, the total is 12.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   `1 <= k <= min(70, nums.length)`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3429_paint_house_iv/Solution.kt b/src/main/kotlin/g3401_3500/s3429_paint_house_iv/Solution.kt
new file mode 100644
index 000000000..3ea8d3d5e
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3429_paint_house_iv/Solution.kt
@@ -0,0 +1,41 @@
+package g3401_3500.s3429_paint_house_iv
+
+// #Medium #Array #Dynamic_Programming #2025_01_22_Time_10_(100.00%)_Space_119.77_(84.62%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minCost(n: Int, cost: Array<IntArray>): Long {
+        var dp0: Long = 0
+        var dp1: Long = 0
+        var dp2: Long = 0
+        var dp3: Long = 0
+        var dp4: Long = 0
+        var dp5: Long = 0
+        for (i in 0..<n / 2) {
+            val nextdp0: Long =
+                min(min(dp2, dp3), dp4) + cost[i][0] + cost[n - i - 1][1]
+            val nextdp1: Long =
+                min(min(dp2, dp4), dp5) + cost[i][0] + cost[n - i - 1][2]
+            val nextdp2: Long =
+                min(min(dp0, dp1), dp5) + cost[i][1] + cost[n - i - 1][0]
+            val nextdp3: Long =
+                min(min(dp0, dp4), dp5) + cost[i][1] + cost[n - i - 1][2]
+            val nextdp4: Long =
+                min(min(dp0, dp1), dp3) + cost[i][2] + cost[n - i - 1][0]
+            val nextdp5: Long =
+                min(min(dp1, dp2), dp3) + cost[i][2] + cost[n - i - 1][1]
+            dp0 = nextdp0
+            dp1 = nextdp1
+            dp2 = nextdp2
+            dp3 = nextdp3
+            dp4 = nextdp4
+            dp5 = nextdp5
+        }
+        var ans = Long.Companion.MAX_VALUE
+        for (x in longArrayOf(dp0, dp1, dp2, dp3, dp4, dp5)) {
+            ans = min(ans, x).toLong()
+        }
+        return ans
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3429_paint_house_iv/readme.md b/src/main/kotlin/g3401_3500/s3429_paint_house_iv/readme.md
new file mode 100644
index 000000000..8610512fd
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3429_paint_house_iv/readme.md
@@ -0,0 +1,53 @@
+3429\. Paint House IV
+
+Medium
+
+You are given an **even** integer `n` representing the number of houses arranged in a straight line, and a 2D array `cost` of size `n x 3`, where `cost[i][j]` represents the cost of painting house `i` with color `j + 1`.
+
+The houses will look **beautiful** if they satisfy the following conditions:
+
+*   No **two** adjacent houses are painted the same color.
+*   Houses **equidistant** from the ends of the row are **not** painted the same color. For example, if `n = 6`, houses at positions `(0, 5)`, `(1, 4)`, and `(2, 3)` are considered equidistant.
+
+Return the **minimum** cost to paint the houses such that they look **beautiful**.
+
+**Example 1:**
+
+**Input:** n = 4, cost = [[3,5,7],[6,2,9],[4,8,1],[7,3,5]]
+
+**Output:** 9
+
+**Explanation:**
+
+The optimal painting sequence is `[1, 2, 3, 2]` with corresponding costs `[3, 2, 1, 3]`. This satisfies the following conditions:
+
+*   No adjacent houses have the same color.
+*   Houses at positions 0 and 3 (equidistant from the ends) are not painted the same color `(1 != 2)`.
+*   Houses at positions 1 and 2 (equidistant from the ends) are not painted the same color `(2 != 3)`.
+
+The minimum cost to paint the houses so that they look beautiful is `3 + 2 + 1 + 3 = 9`.
+
+**Example 2:**
+
+**Input:** n = 6, cost = [[2,4,6],[5,3,8],[7,1,9],[4,6,2],[3,5,7],[8,2,4]]
+
+**Output:** 18
+
+**Explanation:**
+
+The optimal painting sequence is `[1, 3, 2, 3, 1, 2]` with corresponding costs `[2, 8, 1, 2, 3, 2]`. This satisfies the following conditions:
+
+*   No adjacent houses have the same color.
+*   Houses at positions 0 and 5 (equidistant from the ends) are not painted the same color `(1 != 2)`.
+*   Houses at positions 1 and 4 (equidistant from the ends) are not painted the same color `(3 != 1)`.
+*   Houses at positions 2 and 3 (equidistant from the ends) are not painted the same color `(2 != 3)`.
+
+The minimum cost to paint the houses so that they look beautiful is `2 + 8 + 1 + 2 + 3 + 2 = 18`.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `n` is even.
+*   `cost.length == n`
+*   `cost[i].length == 3`
+*   <code>0 <= cost[i]\[j] <= 10<sup>5</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/Solution.kt b/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/Solution.kt
new file mode 100644
index 000000000..0bbb76e1e
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/Solution.kt
@@ -0,0 +1,47 @@
+package g3401_3500.s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays
+
+// #Hard #Array #Math #Stack #Monotonic_Stack #2025_01_22_Time_31_(100.00%)_Space_74.84_(24.24%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minMaxSubarraySum(nums: IntArray, k: Int): Long {
+        val sum = solve(nums, k)
+        for (i in nums.indices) {
+            nums[i] = -nums[i]
+        }
+        return sum - solve(nums, k)
+    }
+
+    private fun solve(nums: IntArray, k: Int): Long {
+        val n = nums.size
+        val left = IntArray(n)
+        val right = IntArray(n)
+        val st = IntArray(n)
+        var top = -1
+        for (i in 0..<n) {
+            val num = nums[i]
+            while (top != -1 && num < nums[st[top]]) {
+                right[st[top--]] = i
+            }
+            left[i] = if (top == -1) -1 else st[top]
+            st[++top] = i
+        }
+        while (0 <= top) {
+            right[st[top--]] = n
+        }
+        var ans: Long = 0
+        for (i in 0..<n) {
+            val num = nums[i]
+            val l = min((i - left[i]), k)
+            val r = min((right[i] - i), k)
+            if (l + r - 1 <= k) {
+                ans += num.toLong() * l * r
+            } else {
+                val cnt = (k - r + 1).toLong() * r + (l + r - k - 1).toLong() * (r + k - l) / 2
+                ans += num * cnt
+            }
+        }
+        return ans
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/readme.md b/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/readme.md
new file mode 100644
index 000000000..a728efe17
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/readme.md
@@ -0,0 +1,53 @@
+3430\. Maximum and Minimum Sums of at Most Size K Subarrays
+
+Hard
+
+You are given an integer array `nums` and a **positive** integer `k`. Return the sum of the **maximum** and **minimum** elements of all **non-empty subarrays** with **at most** `k` elements.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], k = 2
+
+**Output:** 20
+
+**Explanation:**
+
+The subarrays of `nums` with at most 2 elements are:
+
+| **Subarray** | Minimum | Maximum | Sum |
+|--------------|---------|---------|-----|
+| `[1]`        | 1       | 1       | 2   |
+| `[2]`        | 2       | 2       | 4   |
+| `[3]`        | 3       | 3       | 6   |
+| `[1, 2]`     | 1       | 2       | 3   |
+| `[2, 3]`     | 2       | 3       | 5   |
+| **Final Total** |         |         | 20  |
+
+The output would be 20.
+
+**Example 2:**
+
+**Input:** nums = [1,-3,1], k = 2
+
+**Output:** \-6
+
+**Explanation:**
+
+The subarrays of `nums` with at most 2 elements are:
+
+| **Subarray**   | Minimum | Maximum | Sum  |
+|----------------|---------|---------|------|
+| `[1]`          | 1       | 1       | 2    |
+| `[-3]`         | -3      | -3      | -6   |
+| `[1]`          | 1       | 1       | 2    |
+| `[1, -3]`      | -3      | 1       | -2   |
+| `[-3, 1]`      | -3      | 1       | -2   |
+| **Final Total**|         |         | -6   |
+
+The output would be -6.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 80000`
+*   `1 <= k <= nums.length`
+*   <code>-10<sup>6</sup> <= nums[i] <= 10<sup>6</sup></code>
\ No newline at end of file
diff --git a/src/test/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/SolutionTest.kt
new file mode 100644
index 000000000..22cf8d1da
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3423_maximum_difference_between_adjacent_elements_in_a_circular_array/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3423_maximum_difference_between_adjacent_elements_in_a_circular_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxAdjacentDistance() {
+        assertThat<Int>(
+            Solution().maxAdjacentDistance(intArrayOf(1, 2, 4)),
+            equalTo<Int>(3),
+        )
+    }
+
+    @Test
+    fun maxAdjacentDistance2() {
+        assertThat<Int>(
+            Solution().maxAdjacentDistance(intArrayOf(-5, -10, -5)),
+            equalTo<Int>(5),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/SolutionTest.kt
new file mode 100644
index 000000000..d04b95eb0
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3424_minimum_cost_to_make_arrays_identical
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minCost() {
+        assertThat<Long>(
+            Solution().minCost(intArrayOf(-7, 9, 5), intArrayOf(7, -2, -5), 2),
+            equalTo<Long>(13L),
+        )
+    }
+
+    @Test
+    fun minCost2() {
+        assertThat<Long>(
+            Solution().minCost(intArrayOf(2, 1), intArrayOf(2, 1), 0),
+            equalTo<Long>(0L),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3425_longest_special_path/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3425_longest_special_path/SolutionTest.kt
new file mode 100644
index 000000000..510154170
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3425_longest_special_path/SolutionTest.kt
@@ -0,0 +1,33 @@
+package g3401_3500.s3425_longest_special_path
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun longestSpecialPath() {
+        assertThat<IntArray>(
+            Solution()
+                .longestSpecialPath(
+                    arrayOf<IntArray>(
+                        intArrayOf(0, 1, 2),
+                        intArrayOf(1, 2, 3),
+                        intArrayOf(1, 3, 5),
+                        intArrayOf(1, 4, 4),
+                        intArrayOf(2, 5, 6),
+                    ),
+                    intArrayOf(2, 1, 2, 1, 3, 1),
+                ),
+            equalTo<IntArray>(intArrayOf(6, 2)),
+        )
+    }
+
+    @Test
+    fun longestSpecialPath2() {
+        assertThat<IntArray>(
+            Solution().longestSpecialPath(arrayOf<IntArray>(intArrayOf(1, 0, 8)), intArrayOf(2, 2)),
+            equalTo<IntArray>(intArrayOf(0, 1)),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/SolutionTest.kt
new file mode 100644
index 000000000..dd9344e10
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3426_manhattan_distances_of_all_arrangements_of_pieces/SolutionTest.kt
@@ -0,0 +1,17 @@
+package g3401_3500.s3426_manhattan_distances_of_all_arrangements_of_pieces
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun distanceSum() {
+        assertThat<Int>(Solution().distanceSum(2, 2, 2), equalTo<Int>(8))
+    }
+
+    @Test
+    fun distanceSum2() {
+        assertThat<Int>(Solution().distanceSum(1, 4, 3), equalTo<Int>(20))
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/SolutionTest.kt
new file mode 100644
index 000000000..9fd8df42f
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/SolutionTest.kt
@@ -0,0 +1,17 @@
+package g3401_3500.s3427_sum_of_variable_length_subarrays
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun subarraySum() {
+        assertThat<Int>(Solution().subarraySum(intArrayOf(2, 3, 1)), equalTo<Int>(11))
+    }
+
+    @Test
+    fun subarraySum2() {
+        assertThat<Int>(Solution().subarraySum(intArrayOf(3, 1, 1, 2)), equalTo<Int>(13))
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/SolutionTest.kt
new file mode 100644
index 000000000..fca5e6394
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/SolutionTest.kt
@@ -0,0 +1,17 @@
+package g3401_3500.s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minMaxSums() {
+        assertThat<Int>(Solution().minMaxSums(intArrayOf(1, 2, 3), 2), equalTo<Int>(24))
+    }
+
+    @Test
+    fun minMaxSums2() {
+        assertThat<Int>(Solution().minMaxSums(intArrayOf(5, 0, 6), 1), equalTo<Int>(22))
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3429_paint_house_iv/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3429_paint_house_iv/SolutionTest.kt
new file mode 100644
index 000000000..0eba3a6b2
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3429_paint_house_iv/SolutionTest.kt
@@ -0,0 +1,37 @@
+package g3401_3500.s3429_paint_house_iv
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minCost() {
+        assertThat<Long>(
+            Solution().minCost(
+                4,
+                arrayOf<IntArray>(intArrayOf(3, 5, 7), intArrayOf(6, 2, 9), intArrayOf(4, 8, 1), intArrayOf(7, 3, 5)),
+            ),
+            equalTo<Long>(9L),
+        )
+    }
+
+    @Test
+    fun minCost2() {
+        assertThat<Long>(
+            Solution()
+                .minCost(
+                    6,
+                    arrayOf<IntArray>(
+                        intArrayOf(2, 4, 6),
+                        intArrayOf(5, 3, 8),
+                        intArrayOf(7, 1, 9),
+                        intArrayOf(4, 6, 2),
+                        intArrayOf(3, 5, 7),
+                        intArrayOf(8, 2, 4),
+                    ),
+                ),
+            equalTo<Long>(18L),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/SolutionTest.kt
new file mode 100644
index 000000000..f909a54ad
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minMaxSubarraySum() {
+        assertThat<Long>(
+            Solution().minMaxSubarraySum(intArrayOf(1, 2, 3), 2),
+            equalTo<Long>(20L),
+        )
+    }
+
+    @Test
+    fun minMaxSubarraySum2() {
+        assertThat<Long>(
+            Solution().minMaxSubarraySum(intArrayOf(1, -3, 1), 2),
+            equalTo<Long>(-6L),
+        )
+    }
+}