2026-07-23：产生至少 K 个峰值的最少操作次数。用go语言，给定一个长度为 n 的整数数组，该数组在逻辑上是首尾相连的（即下标 0 的前一

package main

import (
    "fmt"
    "math"
)

// 非环形版本
func solve(a []int, k int) int {
    n := len(a)
    f := make([]int, n)
    for left := 1; left <= k; left++ {
        f0, f1 := f[left*2-2], f[left*2-1]
        f[left*2-1] = math.MaxInt / 2
        for i := left*2 - 1; i < n-1-(k-left)*2; i++ {
            // 选或不选
            notChoose := f[i]
            choose := f0 + max(max(a[i-1], a[i+1])-a[i]+1, 0)
            f0 = f1
            f1 = f[i+1] // 保存旧数据
            f[i+1] = min(notChoose, choose)
        }
    }
    return f[n-1]
}

func minOperations(nums []int, k int) int {
    n := len(nums)
    if k > n/2 {
        return -1
    }

    cnt := 0
    for i, x := range nums {
        if nums[(i-1+n)%n] < x && x > nums[(i+1)%n] {
            cnt++
        }
    }
    if cnt >= k { // 优化：已经有至少 k 个峰值了，无需操作
        return 0
    }

    // 如果 nums[0] 是峰值，那么 nums[n-1] 不是峰值
    ans1 := solve(append([]int{nums[n-1]}, nums...), k)
    // 如果 nums[0] 不是峰值
    ans2 := solve(append(nums, nums[0]), k)
    return min(ans1, ans2)
}

func main() {
    nums := []int{2, 1, 2}
    k := 1
    result := minOperations(nums, k)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

import math
from typing import List

def solve(a: List[int], k: int) -> int:
    """非环形版本：在数组 a 中选出 k 个不相邻的峰值所需的最小操作数"""
    n = len(a)
    f = [0] * n
    for left in range(1, k + 1):
        f0, f1 = f[left * 2 - 2], f[left * 2 - 1]
        f[left * 2 - 1] = math.inf
        end = n - 1 - (k - left) * 2
        for i in range(left * 2 - 1, end):
            not_choose = f[i]
            choose = f0 + max(max(a[i - 1], a[i + 1]) - a[i] + 1, 0)
            f0, f1 = f1, f[i + 1]  # 保存旧值并滑动
            f[i + 1] = min(not_choose, choose)
    return f[n - 1]

def minOperations(nums: List[int], k: int) -> int:
    n = len(nums)
    if k > n // 2:
        return -1

    # 已有峰值计数
    cnt = 0
    for i in range(n):
        if nums[(i - 1) % n] < nums[i] > nums[(i + 1) % n]:
            cnt += 1
    if cnt >= k:
        return 0

    # 情况1：假设原数组的首元素是峰值 -> 尾元素不能是峰值
    arr1 = [nums[-1]] + nums
    ans1 = solve(arr1, k)

    # 情况2：原数组的首元素不是峰值
    arr2 = nums + [nums[0]]
    ans2 = solve(arr2, k)

    return min(ans1, ans2)

if __name__ == "__main__":
    nums = [2, 1, 2]
    k = 1
    print(minOperations(nums, k))

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

/**
 * 非环形版本：在数组 a 中选出 k 个不相邻的峰值所需的最小操作数
 * @param a 整数数组
 * @param k 需要的峰值个数
 * @return 最小操作数
 */
int solve(const vector<int>& a, int k) {
    int n = a.size();
    vector<int> f(n, 0);
    for (int left = 1; left <= k; ++left) {
        int f0 = f[left * 2 - 2];
        int f1 = f[left * 2 - 1];
        f[left * 2 - 1] = INT_MAX / 2;  // 相当于正无穷
        int end = n - 1 - (k - left) * 2;
        for (int i = left * 2 - 1; i < end; ++i) {
            int notChoose = f[i];
            int choose = f0 + max(max(a[i - 1], a[i + 1]) - a[i] + 1, 0);
            f0 = f1;
            f1 = f[i + 1];   // 保存旧数据
            f[i + 1] = min(notChoose, choose);
        }
    }
    return f[n - 1];
}

/**
 * 计算使循环数组包含至少 k 个峰值的最小操作数
 * @param nums 循环整数数组
 * @param k 目标峰值个数
 * @return 最小操作数，不可能则返回 -1
 */
int minOperations(const vector<int>& nums, int k) {
    int n = nums.size();
    // 峰值必须不相邻，因此最多 n/2 个
    if (k > n / 2) return -1;

    // 统计已有的峰值个数
    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (nums[(i - 1 + n) % n] < nums[i] && nums[i] > nums[(i + 1) % n]) {
            ++cnt;
        }
    }
    if (cnt >= k) return 0;   // 已经满足要求

    // 情况1：假设原数组的首元素是峰值，则尾元素不能是峰值
    vector<int> a1;
    a1.push_back(nums[n - 1]);
    a1.insert(a1.end(), nums.begin(), nums.end());
    int ans1 = solve(a1, k);

    // 情况2：原数组的首元素不是峰值
    vector<int> a2 = nums;
    a2.push_back(nums[0]);
    int ans2 = solve(a2, k);

    return min(ans1, ans2);
}

int main() {
    vector<int> nums = {2, 1, 2};
    int k = 1;
    cout << minOperations(nums, k) << endl;
    return 0;
}