2025-04-02：K 次乘运算后的最终数组Ⅱ。用go语言，给定一个整数数组 nums，以及两个整数 k 和 multipli

package main

import (
    "container/heap"
    "fmt"
    "sort"
)

func quickMul(x, y, m int64)int64 {
    res := int64(1)
    for y > 0 {
        if (y & 1) == 1 {
            res = (res * x) % m
        }
        y >>= 1
        x = (x * x) % m
    }
    return res
}

func getFinalState(nums []int, k int, multiplier int) []int {
    if multiplier == 1 {
        return nums
    }
    n, m := len(nums), int64(1e9+7)
    mx := 0
    var v minHeap
    for i, num := range nums {
        mx = max(mx, num)
        v = append(v, pair{int64(num), i})
    }
    heap.Init(&v)
    for ; v[0].first < int64(mx) && k > 0; k-- {
        x := heap.Pop(&v).(pair)
        x.first *= int64(multiplier)
        heap.Push(&v, x)
    }
    sort.Slice(v, func(i, j int)bool {
        return v[i].first < v[j].first || v[i].first == v[j].first && v[i].second < v[j].second
    })
    for i := 0; i < n; i++ {
        t := k / n
        if i < k%n {
            t++
        }
        nums[v[i].second] = int((v[i].first % m) * quickMul(int64(multiplier), int64(t), m) % m)
    }
    return nums
}

type pair struct {
    first  int64
    second int
}

type minHeap []pair

func (h minHeap) Len() int {
    returnlen(h)
}
func (h minHeap) Less(i, j int) bool {
    return h[i].first < h[j].first || h[i].first == h[j].first && h[i].second < h[j].second
}
func (h minHeap) Swap(i, j int) {
    h[i], h[j] = h[j], h[i]
}

func (h *minHeap) Push(x interface{}) {
    *h = append(*h, x.(pair))
}

func (h *minHeap) Pop() interface{} {
    n := len(*h)
    res := (*h)[n-1]
    *h = (*h)[0 : n-1]
    return res
}

func main() {
    nums := []int{2, 1, 3, 5, 6}
    k := 5
    multiplier := 2
    result := getFinalState(nums, k, multiplier)
    fmt.Println(result)
}

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

import heapq

defquick_mul(x, y, m):
    res = 1
    while y > 0:
        if y & 1:  # 如果 y 的最低位为 1
            res = (res * x) % m
        y >>= 1# y 右移一位
        x = (x * x) % m  # x 自身平方并取模
    return res

defget_final_state(nums, k, multiplier):
    if multiplier == 1:
        return nums
    
    n = len(nums)
    m = 10**9 + 7
    mx = max(nums)
    min_heap = []
    
    # 使用最小堆存储元组 (num, index)
    for index, num inenumerate(nums):
        heapq.heappush(min_heap, (num, index))
    
    # k 次替换操作
    while min_heap[0][0] < mx and k > 0:
        x = heapq.heappop(min_heap)  # 取出最小值
        x_value, x_index = x
        x_value *= multiplier  # 乘以 multiplier
        heapq.heappush(min_heap, (x_value, x_index))  # 将新值重新入堆
        k -= 1
    
    # 将堆中的元素按数值和原始索引排序
    sorted_heap = sorted(min_heap, key=lambda x: (x[0], x[1]))
    
    # 更新原数组的值
    for i inrange(n):
        t = k // n
        if i < k % n:
            t += 1
        nums[sorted_heap[i][1]] = (sorted_heap[i][0] % m) * quick_mul(multiplier, t, m) % m
    
    return nums

# 示例
nums = [2, 1, 3, 5, 6]
k = 5
multiplier = 2
result = get_final_state(nums, k, multiplier)
print(result)