Arrays 找到将所有K个数转换为[L，R]（即L）范围内所需操作数的最佳方法≤x≤（R）

我正在解决这个问题，这需要一些优化的技术来解决 解决它。我能想到的暴力方法只需要 组合学

给定一个由n个整数组成的数组。我们称一个整数为good 如果它位于[L，R]范围内，即≤x≤R.我们需要确保 从数组中选取任意K个整数，其中至少一个应为 好的整数

为了实现这一目标，我们可以在一次行动中 将数组的任何元素增加/减少一

我们需要的最低运营次数是多少 修正了k

i、 ek=1到n

对于k=1，必须将两个3转换为2，以确保 如果选择3个整数中的任意一个，则所选整数为良好整数

对于k=2，一种可能的方法是将其中一个3转换为2

对于k=3，不需要任何运算，因为1是一个好的整数

---

为了确保从拾取的k个元素中至少会给出一个有效的方法，您的集合中的无效值不应超过k-1。因此，您需要找到使足够的元素有效的最短方法。我将这样做：在一个过程中，生成一个映射，计算集合中有多少元素需要$n$操作才能生效。然后，您显然希望获取需要最少操作的元素，因此按照所需操作数的升序获取所需元素数，并将操作数相加

在python中：

def min_ops(L,R,A_set):
    n_ops = dict()  # create an empty mapping
    for a in A_set:   # loop over all a in the set A_set
        n = max(0,max(a-R,L-a))  # the number of operations requied to make a valid
        n_ops[n] = n_ops.get(n,0) + 1  # in the mapping, increment the element keyed by *n* by ones. If it does not exist yet, assume it was 0.
    allret = []   # create a new list to hold the result for all k
    for k in range(1,len(A_set)+1):  # iterate over all k in the range [1,N+1) == [1,N]
        n_good_required = len(A_set) - k + 1
        ret = 0
        # iterator over all pairs of keys,values from the mapping, sorted by key.
        # The key is the number of ops required, the value the number of elements available
        for n,nel in sorted(n_ops.items()):   
            if n_good_required:
               return ret
            ret += n * min(nel,n_good_required)
            n_good_required -= nel
        allret.append(ret)  # append the answer for this k to the result list
    return allret

例如：

A_set = [1,3,3,6,8,5,4,7]
L,R = 4,6

对于每个A，我们会找到使其有效所需的操作数：

n = [3,1,1,0,2,0,0,1]            

i、 e.1需要3个步骤，3个需要一个步骤，依此类推 然后我们计算：

n_ops = {
    0: 3,   # we already have three valid elements
    1: 3,   # three elements that require one op
    2: 1,
    3: 1,   # and finally one that requires 3 ops
}

现在，对于每个k，我们找出集合中需要多少有效元素， e、 g.对于k=4，在8的集合中，我们最多需要3个无效的，所以我们需要5个有效的

因此：

---

正如burnpanck在他的回答中所解释的，为了确保在数组中选择任意k个元素时，其中至少有一个元素在[L，R]范围内，我们需要确保数组中[L，R]范围内至少有n-k+1个数字

因此，首先，对于每个元素，我们计算使该元素成为范围为[L，R]的有效元素的成本，并将这些成本存储在数组成本中

我们注意到：

对于k=1，最小成本是数组成本的总和

对于k=2，最小成本是成本之和减去最大要素

对于k=3，最小成本是成本之和减去两个最大元素

因此，我们需要有一个前缀数组，它的第i个位置是从0到第i个排序成本数组的总和

在计算前缀之后，我们可以为O1中的每个k回答结果

这是Java中的algo，注意时间复杂度在logn上：

---

输入数组的大小是多少？提示！使用DP@PhamTrungN≤10^5和A[i]≤10^9..@Theralprashant最初我考虑DP，但无法提出结构。根据你的观点，什么可以作为DP的起点？@Phamtrong我已经将其k=1写给了NCA，你可以给出更多的见解。可能是一个示例演示就可以了。谢谢，我不熟悉python。您能否将注释放在代码旁边，以便不懂python的每个人都能更容易地获得您的观点。如果您能用上面的示例演示您的代码，以及如何获得正确的答案，我们将非常高兴。Thanksn_ops={0:3，我们已经有三个有效元素1:3，三个元素需要一个op2:1，3:1，最后一个元素需要3个ops}需要1个操作的3个元素是什么。我只能看到一个元素，即3I以burnpanck相同的方式理解初始问题：从未指定您选择的K个整数必须在初始数组中彼此相邻。因此，当且仅当数组中最多剩下k-1个坏整数时，确保始终为任意拾取获取至少一个好整数。如果这不是有意的，请编辑问题以澄清这一点：我理解，只是稍微澄清一下为什么-对于k=2，最小成本是成本的总和，减去最大元素。。我是说为什么要减去最大的元素。什么是关系？我想不起来。Thanks@Ashish因为，当k=2时，我们需要使数组中的所有元素都成为有效元素，只有一个元素除外，我们可以选择该元素。因此，为了获得最低成本，我们需要选择成本最大的元素。最后。。。。谢谢你提出这些问题。。。。现在我在想为什么我错过了那一点。。。但再一次，一旦你知道答案，所有的问题看起来都很简单…：@Ashish很高兴能帮上忙：，如果它回答了你的问题，你能让它被接受吗？

n_ops = {
    0: 3,   # we already have three valid elements
    1: 3,   # three elements that require one op
    2: 1,
    3: 1,   # and finally one that requires 3 ops
}

ret = 0
n_good_requied = 5
with n=0, we have 3 so take all of them
ret = 0
n_good_required = 2
with n=1, we have 3, but we need just two, so take those
ret = 2
we're finished

int[]cost = new int[n];
for(int i = 0; i < n; i++)
    cost[i] = //Calculate min cost for element i
Arrays.sort(cost);
int[]prefix = new int[n];
for(int i = 0; i < n; i++)
   prefix[i] = cost[i] + (i > 0 ? prefix[i - 1] : 0);

for(int i = n - 1; i >= 0; i--)
   System.out.println("Result for k = " + (n - i) + " is " + prefix[i]);