diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README.md b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README.md index 5eb5c34e33388..2d05d860d9c06 100644 --- a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README.md +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README.md @@ -62,6 +62,16 @@ +**方法一：预处理 + 枚举** + +我们可以预处理出每个位置右侧的最小值，记录在数组 $right[i]$ 中，即 $right[i]$ 表示 $nums[i+1..n-1]$ 中的最小值。 + +接下来，我们从左到右枚举山形三元组的中间元素 $nums[i]$，用一个变量 $left$ 表示 $nums[0..i-1]$ 中的最小值，用一个变量 $ans$ 表示当前找到的最小元素和。对于每个 $i$，我们需要找到满足 $left < nums[i]$ 且 $right[i+1] < nums[i]$ 的元素 $nums[i]$，并更新 $ans$。 + +最后，如果 $ans$ 仍然为初始值，则说明不存在山形三元组，返回 $-1$。 + +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。 + ### **Python3** @@ -69,7 +79,18 @@ ```python - +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans ``` ### **Java** @@ -77,19 +98,102 @@ ```java - +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} ``` ### **C++** ```cpp - +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; ``` ### **Go** ```go +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} +``` +### **TypeScript** + +```ts +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +} ``` ### **...** diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README_EN.md b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README_EN.md index 0f79476c69e59..583806491795a 100644 --- a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README_EN.md +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README_EN.md @@ -56,30 +56,134 @@ And the sum of this triplet is nums[1] + nums[3] + nums[5] = 13. It can be shown ## Solutions +**Solution 1: Preprocessing + Enumeration** + +We can preprocess the minimum value on the right side of each position and record it in the array $right[i]$, where $right[i]$ represents the minimum value in $nums[i+1..n-1]$. + +Next, we enumerate the middle element $nums[i]$ of the mountain triplet from left to right, and use a variable $left$ to represent the minimum value in $ums[0..i-1]$, and a variable $ans$ to represent the current minimum element sum found. For each $i$, we need to find the element $nums[i]$ that satisfies $left < nums[i]$ and $right[i+1] < nums[i]$, and update $ans$. + +Finally, if $ans$ is still the initial value, it means that there is no mountain triplet, and we return $-1$. + +The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array. + ### **Python3** ```python - +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans ``` ### **Java** ```java - +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} ``` ### **C++** ```cpp - +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; ``` ### **Go** ```go +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} +``` +### **TypeScript** + +```ts +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +} ``` ### **...** diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.cpp b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.cpp new file mode 100644 index 0000000000000..512906c4b9662 --- /dev/null +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; \ No newline at end of file diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.go b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.go new file mode 100644 index 0000000000000..8219e0875c885 --- /dev/null +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.go @@ -0,0 +1,27 @@ +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} \ No newline at end of file diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.java b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.java new file mode 100644 index 0000000000000..b0ffc7442db20 --- /dev/null +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.java @@ -0,0 +1,19 @@ +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} \ No newline at end of file diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.py b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.py new file mode 100644 index 0000000000000..8cde41f7cefd4 --- /dev/null +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.py @@ -0,0 +1,12 @@ +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans diff --git a/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.ts b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.ts new file mode 100644 index 0000000000000..68a560190a935 --- /dev/null +++ b/solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.ts @@ -0,0 +1,15 @@ +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +} diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README.md b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README.md index 0da09b72b3de1..870fee13e82b2 100644 --- a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README.md +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README.md @@ -62,6 +62,16 @@ +**方法一：预处理 + 枚举** + +我们可以预处理出每个位置右侧的最小值，记录在数组 $right[i]$ 中，即 $right[i]$ 表示 $nums[i+1..n-1]$ 中的最小值。 + +接下来，我们从左到右枚举山形三元组的中间元素 $nums[i]$，用一个变量 $left$ 表示 $nums[0..i-1]$ 中的最小值，用一个变量 $ans$ 表示当前找到的最小元素和。对于每个 $i$，我们需要找到满足 $left < nums[i]$ 且 $right[i+1] < nums[i]$ 的元素 $nums[i]$，并更新 $ans$。 + +最后，如果 $ans$ 仍然为初始值，则说明不存在山形三元组，返回 $-1$。 + +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。 + ### **Python3** @@ -69,7 +79,18 @@ ```python - +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans ``` ### **Java** @@ -77,19 +98,102 @@ ```java - +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} ``` ### **C++** ```cpp - +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; ``` ### **Go** ```go +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} +``` +### **TypeScript** + +```ts +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +} ``` ### **...** diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README_EN.md b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README_EN.md index 58715a586ecd0..3b7728286d7a9 100644 --- a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README_EN.md +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/README_EN.md @@ -56,30 +56,134 @@ And the sum of this triplet is nums[1] + nums[3] + nums[5] = 13. It can be shown ## Solutions +**Solution 1: Preprocessing + Enumeration** + +We can preprocess the minimum value on the right side of each position and record it in the array $right[i]$, where $right[i]$ represents the minimum value in $nums[i+1..n-1]$. + +Next, we enumerate the middle element $nums[i]$ of the mountain triplet from left to right, and use a variable $left$ to represent the minimum value in $ums[0..i-1]$, and a variable $ans$ to represent the current minimum element sum found. For each $i$, we need to find the element $nums[i]$ that satisfies $left < nums[i]$ and $right[i+1] < nums[i]$, and update $ans$. + +Finally, if $ans$ is still the initial value, it means that there is no mountain triplet, and we return $-1$. + +The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array. + ### **Python3** ```python - +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans ``` ### **Java** ```java - +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} ``` ### **C++** ```cpp - +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; ``` ### **Go** ```go +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} +``` +### **TypeScript** + +```ts +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +} ``` ### **...** diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.cpp b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.cpp new file mode 100644 index 0000000000000..512906c4b9662 --- /dev/null +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + int minimumSum(vector& nums) { + int n = nums.size(); + const int inf = 1 << 30; + int right[n + 1]; + right[n] = inf; + for (int i = n - 1; ~i; --i) { + right[i] = min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = min(ans, left + nums[i] + right[i + 1]); + } + left = min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +}; \ No newline at end of file diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.go b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.go new file mode 100644 index 0000000000000..8219e0875c885 --- /dev/null +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.go @@ -0,0 +1,27 @@ +func minimumSum(nums []int) int { + n := len(nums) + const inf = 1 << 30 + right := make([]int, n+1) + right[n] = inf + for i := n - 1; i >= 0; i-- { + right[i] = min(right[i+1], nums[i]) + } + ans, left := inf, inf + for i, x := range nums { + if left < x && right[i+1] < x { + ans = min(ans, left+x+right[i+1]) + } + left = min(left, x) + } + if ans == inf { + return -1 + } + return ans +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} \ No newline at end of file diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.java b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.java new file mode 100644 index 0000000000000..b0ffc7442db20 --- /dev/null +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.java @@ -0,0 +1,19 @@ +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] right = new int[n + 1]; + final int inf = 1 << 30; + right[n] = inf; + for (int i = n - 1; i >= 0; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + int ans = inf, left = inf; + for (int i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans == inf ? -1 : ans; + } +} \ No newline at end of file diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.py b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.py new file mode 100644 index 0000000000000..8cde41f7cefd4 --- /dev/null +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.py @@ -0,0 +1,12 @@ +class Solution: + def minimumSum(self, nums: List[int]) -> int: + n = len(nums) + right = [inf] * (n + 1) + for i in range(n - 1, -1, -1): + right[i] = min(right[i + 1], nums[i]) + ans = left = inf + for i, x in enumerate(nums): + if left < x and right[i + 1] < x: + ans = min(ans, left + x + right[i + 1]) + left = min(left, x) + return -1 if ans == inf else ans diff --git a/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.ts b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.ts new file mode 100644 index 0000000000000..68a560190a935 --- /dev/null +++ b/solution/2900-2999/2909.Minimum Sum of Mountain Triplets II/Solution.ts @@ -0,0 +1,15 @@ +function minimumSum(nums: number[]): number { + const n = nums.length; + const right: number[] = Array(n + 1).fill(Infinity); + for (let i = n - 1; ~i; --i) { + right[i] = Math.min(right[i + 1], nums[i]); + } + let [ans, left] = [Infinity, Infinity]; + for (let i = 0; i < n; ++i) { + if (left < nums[i] && right[i + 1] < nums[i]) { + ans = Math.min(ans, left + nums[i] + right[i + 1]); + } + left = Math.min(left, nums[i]); + } + return ans === Infinity ? -1 : ans; +}