须藤安置|安置之旅

给定一个由 N 个正整数组成的数组 A 和一个预算 B。你的任务是决定从数组中选取的元素的最大数量，使得所有选取的元素的累积成本小于或等于预算 B。 选取的成本第 i 个元素由以下公式给出： A[i] + (i * K) 其中，K 是一个常数，其值等于选取的元素数量。索引(i)是基于 1 的。打印最大数量及其各自的累计成本。
例子：

Input : arr[] = { 2, 3, 5 }, B = 11 
Output : 2 11 
Explanation : Cost of picking maximum elements = {2 + (1 * 2) } + {3 + (2 * 2)} = 4 + 7 = 11 (which is equal to budget)
Input : arr[] = { 1, 2, 5, 6, 3 }, B = 90 
Output : 4 54 
 

先决条件：二分搜索

方法：这里的想法是对 K 的所有可能值使用二分搜索，即要选择的元素的最佳数量。从零开始作为下限和结束与元件的总数量，即N作为上界。检查通过将 K 设置为当前Mid ，获得的累积成本是否小于或等于预算。如果满足条件，则尝试通过将Start设置为(Mid + 1)来增加 K，否则尝试通过将End设置为(Mid – 1)来减少 K。
可以通过简单地根据给定的公式修改数组并添加 K(当前要选取的元素数)最小修改值来获得累积成本，从而以蛮力方式检查条件。
下面是上述方法的实现。

C++

// CPP Program to find the optimal number of
// elements such that the cumulative value
// should be less than given number
#include 
 
using namespace std;
 
// This function returns true if the value cumulative
// according to received integer K is less than budget
// B, otherwise returns false
bool canBeOptimalValue(int K, int arr[], int N, int B,
                       int& value)
{
    // Initialize a temporary array which stores
    // the cumulative value of the original array
    int tmp[N];
 
    for (int i = 0; i < N; i++)
        tmp[i] = (arr[i] + K * (i + 1));
 
    // Sort the array to find the smallest K values
    sort(tmp, tmp + N);
 
    value = 0;
    for (int i = 0; i < K; i++)
        value += tmp[i];
 
    // Check if the value is less than budget
    return value <= B;
}
 
// This function prints the optimal number of elements
// and respective cumulative value which is less than
// the given number
void findNoOfElementsandValue(int arr[], int N, int B)
{
    int start = 0; // Min Value or lower bound
 
    int end = N; // Max Value or upper bound
 
    // Initialize answer as zero as optimal value
    // may not exists
    int ans = 0;
 
    int cumulativeValue = 0;
 
    while (start <= end) {
        int mid = (start + end) / 2;
 
        // If the current Mid Value is an optimal
        // value, then try to maximize it
        if (canBeOptimalValue(mid, arr, N, B,
                              cumulativeValue)) {
            ans = mid;
            start = mid + 1;
        }
        else
            end = mid - 1;
    }
    // Call Again to set the corresponding cumulative
    // value for the optimal ans
    canBeOptimalValue(ans, arr, N, B, cumulativeValue);
 
    cout << ans << " " << cumulativeValue << endl;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 5, 6, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Budget
    int B = 90;
    findNoOfElementsandValue(arr, N, B);
    return 0;
}

Java

// Java Program to find the optimal number of
// elements such that the cumulative value
// should be less than given number
import java.util.*;
 
class GFG
{
    static int value;
 
    // This function returns true if
    // the value cumulative according to
    // received integer K is less than
    // budget B, otherwise returns false
    static boolean canBeOptimalValue(int K, int arr[],
                                     int N, int B)
    {
        // Initialize a temporary array
        // which stores the cumulative value
        // of the original array
        int[] tmp = new int[N];
 
        for (int i = 0; i < N; i++)
            tmp[i] = (arr[i] + K * (i + 1));
 
        // Sort the array to find the
        // smallest K values
        Arrays.sort(tmp);
 
        value = 0;
        for (int i = 0; i < K; i++)
            value += tmp[i];
 
        // Check if the value is less than budget
        return value <= B;
    }
 
    // This function prints the optimal number
    // of elements and respective cumulative value
    // which is less than the given number
    static void findNoOfElementsandValue(int arr[],
                                  int N, int B)
    {
        int start = 0; // Min Value or lower bound
 
        int end = N; // Max Value or upper bound
 
        // Initialize answer as zero as
        // optimal value may not exists
        int ans = 0;
 
        value = 0;
 
        while (start <= end)
        {
            int mid = (start + end) / 2;
 
            // If the current Mid Value is an optimal
            // value, then try to maximize it
            if (canBeOptimalValue(mid, arr, N, B))
            {
                ans = mid;
                start = mid + 1;
            }
            else
                end = mid - 1;
        }
         
        // Call Again to set the corresponding
        // cumulative value for the optimal ans
        canBeOptimalValue(ans, arr, N, B);
 
        System.out.print(ans + " " +
                         value + "\n");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 5, 6, 3 };
        int N = arr.length;
 
        // Budget
        int B = 90;
        findNoOfElementsandValue(arr, N, B);
    }
}
 
// This code is contributed by 29AjayKumar

Python3

# Python Program to find the optimal number of
# elements such that the cumulative value
# should be less than given number
value = 0
 
 
# This function returns true if the value cumulative
# according to received integer K is less than budget
# B, otherwise returns false
def canBeOptimalValue(K: int, arr: list, N: int, B: int) -> bool:
    global value
 
    # Initialize a temporary array which stores
    # the cumulative value of the original array
    tmp = [0] * N
 
    for i in range(N):
        tmp[i] = (arr[i] + K * (i + 1))
 
    # Sort the array to find the smallest K values
    tmp.sort()
 
    value = 0
    for i in range(K):
        value += tmp[i]
 
    # Check if the value is less than budget
    return value <= B
 
# This function prints the optimal number of elements
# and respective cumulative value which is less than
# the given number
def findNoOfElementsandValue(arr: list, N: int, B: int):
    global value
    start = 0 # Min Value or lower bound
 
    end = N # Max Value or upper bound
 
    # Initialize answer as zero as optimal value
    # may not exists
    ans = 0
 
    value = 0
    while start <= end:
        mid = (start + end) // 2
 
        # If the current Mid Value is an optimal
        # value, then try to maximize it
        if canBeOptimalValue(mid, arr, N, B):
            ans = mid
            start = mid + 1
        else:
            end = mid - 1
 
    # Call Again to set the corresponding cumulative
    # value for the optimal ans
    canBeOptimalValue(ans, arr, N, B)
 
    print(ans, value)
 
# Driver Code
if __name__ == "__main__":
 
    arr = [1, 2, 5, 6, 3]
    N = len(arr)
 
    # Budget
    B = 90
    findNoOfElementsandValue(arr, N, B)
 
# This code is contributed by
# sanjeev2552

C#

// C# Program to find the optimal number of
// elements such that the cumulative value
// should be less than given number
using System;
 
class GFG
{
    static int value;
 
    // This function returns true if
    // the value cumulative according to
    // received integer K is less than
    // budget B, otherwise returns false
    static bool canBeOptimalValue(int K, int []arr,
                                  int N, int B)
    {
        // Initialize a temporary array
        // which stores the cumulative value
        // of the original array
        int[] tmp = new int[N];
 
        for (int i = 0; i < N; i++)
            tmp[i] = (arr[i] + K * (i + 1));
 
        // Sort the array to find the
        // smallest K values
        Array.Sort(tmp);
 
        value = 0;
        for (int i = 0; i < K; i++)
            value += tmp[i];
 
        // Check if the value is less than budget
        return value <= B;
    }
 
    // This function prints the optimal number
    // of elements and respective cumulative value
    // which is less than the given number
    static void findNoOfElementsandValue(int []arr,
                                  int N, int B)
    {
        int start = 0; // Min Value or lower bound
 
        int end = N; // Max Value or upper bound
 
        // Initialize answer as zero as
        // optimal value may not exists
        int ans = 0;
 
        value = 0;
 
        while (start <= end)
        {
            int mid = (start + end) / 2;
 
            // If the current Mid Value is an optimal
            // value, then try to maximize it
            if (canBeOptimalValue(mid, arr, N, B))
            {
                ans = mid;
                start = mid + 1;
            }
            else
                end = mid - 1;
        }
         
        // Call Again to set the corresponding
        // cumulative value for the optimal ans
        canBeOptimalValue(ans, arr, N, B);
 
        Console.Write(ans + " " +
                    value + "\n");
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { 1, 2, 5, 6, 3 };
        int N = arr.Length;
 
        // Budget
        int B = 90;
        findNoOfElementsandValue(arr, N, B);
    }
}
 
// This code is contributed by Rajput-Ji

Javascript

 
// JavaScript Program to find the optimal number of
// elements such that the cumulative value
// should be less than given number
 
 
// This function returns true if the value cumulative
// according to received integer K is less than budget
// B, otherwise returns false
 
let cumulativeValue = 0;
 
function canBeOptimalValue(K, arr, N, B) {
    // Initialize a temporary array which stores
    // the cumulative value of the original array
    let tmp = new Array(N);
 
    for (let i = 0; i < N; i++)
        tmp[i] = (arr[i] + K * (i + 1));
 
    // Sort the array to find the smallest K values
    tmp.sort((a, b) => a - b);
 
    cumulativeValue = 0;
    for (let i = 0; i < K; i++)
        cumulativeValue += tmp[i];
 
    // Check if the value is less than budget
    return cumulativeValue <= B;
}
 
// This function prints the optimal number of elements
// and respective cumulative value which is less than
// the given number
function findNoOfElementsandValue(arr, N, B) {
    let start = 0; // Min Value or lower bound
 
    let end = N; // Max Value or upper bound
 
    // Initialize answer as zero as optimal value
    // may not exists
    let ans = 0;
 
 
 
    while (start <= end) {
        let mid = Math.floor((start + end) / 2);
 
        // If the current Mid Value is an optimal
        // value, then try to maximize it
        if (canBeOptimalValue(mid, arr, N, B)) {
            ans = mid;
            start = mid + 1;
        }
        else
            end = mid - 1;
    }
    // Call Again to set the corresponding cumulative
    // value for the optimal ans
    canBeOptimalValue(ans, arr, N, B, cumulativeValue);
 
    document.write(ans + " " + cumulativeValue + "<br>");
}
 
// Driver Code
 
let arr = [1, 2, 5, 6, 3];
let N = arr.length;
 
// Budget
let B = 90;
findNoOfElementsandValue(arr, N, B);
 

输出：

4 54

时间复杂度：O(N * (log N) ² )，其中 N 是给定数组中的元素数。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。