def min_cost_split_brute_force(numbers, k_value):

    def get_trimmed_length(subarray):
        counts = {}
        for number in subarray:
            counts[number] = counts.get(number, 0) + 1
        
        trimmed_len = 0
        for number in subarray:
            if counts[number] > 1:
                trimmed_len += 1
        return trimmed_len

    def get_subarray_cost(subarray):
        return k_value + get_trimmed_length(subarray)

    memoization_cache = {}

    def find_minimum_cost_from_index(start_index):
        if start_index >= len(numbers):
            return 0

        if start_index in memoization_cache:
            return memoization_cache[start_index]

        # Initialize minimum cost for the split starting at `start_index` to a very large number.

        minimum_split_cost = float('inf')

        # Iterate through all possible end points to define the first subarray of this recursive call.

        for end_index in range(start_index, len(numbers)):
            current_subarray = numbers[start_index : end_index + 1]
            cost_of_this_subarray = get_subarray_cost(current_subarray)

            # Recursively find the minimum cost for the rest of the array after the current split.

            cost_of_rest_of_array = find_minimum_cost_from_index(end_index + 1)

            total_cost_for_this_path = cost_of_this_subarray + cost_of_rest_of_array
            minimum_split_cost = min(minimum_split_cost, total_cost_for_this_path)
        
        # Store the result to avoid recomputing the minimum cost for this starting index.

        memoization_cache[start_index] = minimum_split_cost
        return minimum_split_cost

    return find_minimum_cost_from_index(0)

from collections import Counter

def min_cost(nums, k):
    array_length = len(nums)
    # This DP array stores the minimum cost to split the subarray from the start up to index i-1.
    min_cost_dp = [float('inf')] * (array_length + 1)
    min_cost_dp[0] = 0

    # Iterate through each possible end point of a split, building up the solution.
    for end_index in range(1, array_length + 1):
        current_min_total_cost = float('inf')
        frequency_counter = Counter()
        trimmed_length = 0

        # Consider all possible start points for the final subarray ending at end_index-1.
        for start_index in range(end_index - 1, -1, -1):
            current_num = nums[start_index]
            frequency_counter[current_num] += 1

            # Calculate the trimmed_length for the current subarray [start_index...end_index-1].
            if frequency_counter[current_num] == 2:
                trimmed_length += 2
            elif frequency_counter[current_num] > 2:
                trimmed_length += 1

            cost_of_last_subarray = k + trimmed_length
            # Combine the cost of the final subarray with the optimal cost of the preceding part.
            total_cost_for_this_split = min_cost_dp[start_index] + cost_of_last_subarray
            current_min_total_cost = min(current_min_total_cost, total_cost_for_this_split)
        
        min_cost_dp[end_index] = current_min_total_cost

    return min_cost_dp[array_length]