3010. Divide an Array Into Subarrays With Minimum Cost I

/**
 * Problem: LeetCode 3010 - Divide an Array Into Subarrays With Minimum Cost I
 * Difficulty: Easy
 * Language: Java
 * Author: CodeByTushu
 */
class Solution {
    public int minimumCost(int[] nums) {
        // The first subarray always begins at index 0, so nums[0] is fixed.
        int firstCost = nums[0];

        // Find the two smallest elements in the remaining elements nums[1 ... n - 1].
        int min1 = Integer.MAX_VALUE;
        int min2 = Integer.MAX_VALUE;

        for (int i = 1; i < nums.length; i++) {
            if (nums[i] < min1) {
                min2 = min1;
                min1 = nums[i];
            } else if (nums[i] < min2) {
                min2 = nums[i];
            }
        }

        return firstCost + min1 + min2;
    }
}

"""
Problem: LeetCode 3010 - Divide an Array Into Subarrays With Minimum Cost I
Difficulty: Easy
Language: Python
Author: CodeByTushu
"""
from typing import List


class Solution:
    def minimumCost(self, nums: List[int]) -> int:
        # The first subarray must start at index 0, fixing nums[0] as its cost.
        # Find the two smallest values in nums[1:] in a single linear scan.
        min1 = float('inf')
        min2 = float('inf')

        for x in nums[1:]:
            if x < min1:
                min2 = min1
                min1 = x
            elif x < min2:
                min2 = x

        return nums[0] + min1 + min2

/**
 * Problem: LeetCode 3010 - Divide an Array Into Subarrays With Minimum Cost I
 * Difficulty: Easy
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <climits>
#include <algorithm>

using namespace std;

class Solution {
public:
    int minimumCost(vector<int>& nums) {
        // The first subarray always begins at index 0, fixing nums[0].
        int firstCost = nums[0];
        int min1 = INT_MAX;
        int min2 = INT_MAX;

        for (size_t i = 1; i < nums.size(); ++i) {
            if (nums[i] < min1) {
                min2 = min1;
                min1 = nums[i];
            } else if (nums[i] < min2) {
                min2 = nums[i];
            }
        }

        return firstCost + min1 + min2;
    }
};

/**
 * Problem: LeetCode 3010 - Divide an Array Into Subarrays With Minimum Cost I
 * Difficulty: Easy
 * Language: JavaScript
 * Author: CodeByTushu
 */
/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumCost = function(nums) {
    // The first subarray always begins at index 0, fixing nums[0].
    const firstCost = nums[0];
    let min1 = Infinity;
    let min2 = Infinity;

    for (let i = 1; i < nums.length; i++) {
        if (nums[i] < min1) {
            min2 = min1;
            min1 = nums[i];
        } else if (nums[i] < min2) {
            min2 = nums[i];
        }
    }

    return firstCost + min1 + min2;
};