最大利润使得总被盗价值小于 K 以获得奖金

给定一个整数K和一个数组arr[]表示可以被盗的数量，任务是选择一个项目的子集，使得它们的总价值小于 K 以获得奖励金额。

Bonus Amount: The bonus amount will be the maximum value that can be stolen from the set of items for each item stolen. 
Bonus Amount = (Max of arr[]) * (No of Items stolen) 
 

例子：

Input: arr[] = {1, 2, 3, 4, 5}, K = 7 
Output: 22 
Explanation: 
Maximum value that can stolen is – 5. 
If the items were stolen are 1, 2, and 4. Then the total sum of stolen value will be less than K. 
Therefore, Total Profit 
=> Each Item value + Maximum value that can be stolen 
=> 1 + 5 + 2 + 5 + 4 + 5 = 22 

Input: arr[] = {5, 2, 7, 3}, K = 6 
Output: 19 
Explanation: 
Maximum value that can stolen is – 7 
If the items stolen are 2 and 3. Then the total sum of stolen value will be less than K. 
Therefore, Total Profit 
=> Each Item value + Maximum value that can be stolen 
=> 2 + 7 + 3 + 7 = 19 

方法：这个想法是使用排列组合来选择元素，使得它们的总和小于 K。因此，考虑每一种可能会导致可能的最大利润。

下面是上述方法的实现：

C++

// C++ implementation to find the
// maximum stolen value such that
// total stolen value is less than K
 
#include 
 
using namespace std;
 
// Function to find the maximum
// profit from the given values
int maxProfit(vector value,
                         int N, int K)
{
    sort(value.begin(), value.end());
    int maxval = value[N - 1];
    int maxProfit = 0;
    int curr_val;
     
    // Iterating over every
    // possible permutation
    do {
        curr_val = 0;
        for (int i = 0; i < N; i++) {
            curr_val += value[i];
            if (curr_val <= K) {
                maxProfit = max(curr_val +
                  maxval * (i + 1), maxProfit);
            }
        }
    } while (next_permutation(
        value.begin(), value.end()));
    return maxProfit;
}
 
// Driver Code
int main()
{
    int N = 4, K = 6;
    vector values{5, 2, 7, 3};
     
    // Function Call
    cout << maxProfit(values, N, K);
}

Java

// Java implementation to find the
// maximum stolen value such that
// total stolen value is less than K
import java.util.*;
class GFG{
  
// Function to find the maximum
// profit from the given values
static int maxProfit(int []value,
                     int N, int K)
{
    Arrays.sort(value);
    int maxval = value[N - 1];
    int maxProfit = 0;
    int curr_val;
      
    // Iterating over every
    // possible permutation
    do {
        curr_val = 0;
        for (int i = 0; i < N; i++) {
            curr_val += value[i];
            if (curr_val <= K) {
                maxProfit = Math.max(curr_val +
                                     maxval * (i + 1),
                                     maxProfit);
            }
        }
    } while (next_permutation(value));
    return maxProfit;
}
static boolean next_permutation(int[] p) {
      for (int a = p.length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
          for (int b = p.length - 1;; --b)
            if (p[b] > p[a]) {
              int t = p[a];
              p[a] = p[b];
              p[b] = t;
              for (++a, b = p.length - 1; a < b; ++a, --b) {
                t = p[a];
                p[a] = p[b];
                p[b] = t;
              }
              return true;
            }
      return false;
    }
   
// Driver Code
public static void main(String[] args)
{
    int N = 4, K = 6;
    int []values = {5, 2, 7, 3};
      
    // Function Call
    System.out.print(maxProfit(values, N, K));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 implementation to find the
# maximum stolen value such that
# total stolen value is less than K
 
# Function to find the maximum
# profit from the given values
def maxProfit(value, N, K):
     
    value.sort()
    maxval = value[N - 1]
    maxProfit = 0
     
    # Iterating over every
    # possible permutation
    while True:
        curr_val = 0
        for i in range(N):
            curr_val += value[i]
             
            if (curr_val <= K):
                maxProfit = max(curr_val + maxval *
                                      (i + 1), maxProfit)
                                       
        if not next_permutation(value):
            break
     
    return maxProfit
 
def next_permutation(p):
     
    for a in range(len(p) - 2, -1, -1):
        if p[a] < p[a + 1]:
            b = len(p) - 1
             
            while True:
                if p[b] > p[a]:
                    t = p[a]
                    p[a] = p[b]
                    p[b] = t
                     
                    a += 1
                    b = len(p) - 1
                     
                    while a < b:
                        t = p[a]
                        p[a] = p[b]
                        p[b] = t
                         
                        a += 1
                        b -= 1
                         
                    return True
                     
                b -= 1
     
    return False
     
# Driver Code 
N, K = 4, 6
values = [ 5, 2, 7, 3 ]
 
# Function Call
print(maxProfit(values, N, K))
 
# This code is contributed by divyesh072019

C#

// C# implementation to find the
// maximum stolen value such that
// total stolen value is less than K
using System;
 
class GFG{
     
// Function to find the maximum
// profit from the given values
static int maxProfit(int[] value,
                     int N, int K)
{
    Array.Sort(value);
    int maxval = value[N - 1];
    int maxProfit = 0;
    int curr_val;
       
    // Iterating over every
    // possible permutation
    do
    {
        curr_val = 0;
        for(int i = 0; i < N; i++)
        {
            curr_val += value[i];
            if (curr_val <= K)
            {
                maxProfit = Math.Max(curr_val +
                                     maxval * (i + 1),
                                     maxProfit);
            }
        }
    } while (next_permutation(value));
    return maxProfit;
}
 
static bool next_permutation(int[] p)
{
    for(int a = p.Length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
            for(int b = p.Length - 1;; --b)
                if (p[b] > p[a])
                {
                    int t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                       
                    for(++a, b = p.Length - 1;
                            a < b; ++a, --b)
                    {
                        t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                    }
                    return true;
                }
    return false;
}
 
// Driver code  
static void Main()
{
    int N = 4, K = 6;
    int[] values = { 5, 2, 7, 3 };
   
    // Function call
    Console.WriteLine(maxProfit(values, N, K));
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript

 
    // Javascript implementation to find the
    // maximum stolen value such that
    // total stolen value is less than K
     
    // Function to find the maximum
    // profit from the given values
    function maxProfit(value, N, K)
    {
        value.sort();
        let maxval = value[N - 1];
        let maxProfit = 0;
        let curr_val;
 
        // Iterating over every
        // possible permutation
        do
        {
            curr_val = 0;
            for(let i = 0; i < N; i++)
            {
                curr_val += value[i];
                if (curr_val <= K)
                {
                    maxProfit = Math.max(curr_val +
                                         maxval * (i + 1),
                                         maxProfit);
                }
            }
        } while (next_permutation(value));
        return maxProfit;
    }
 
    function next_permutation(p)
    {
        for(let a = p.length - 2; a >= 0; --a)
            if (p[a] < p[a + 1])
                for(let b = p.length - 1;; --b)
                    if (p[b] > p[a])
                    {
                        let t = p[a];
                        p[a] = p[b];
                        p[b] = t;
 
                        for(++a, b = p.length - 1;
                                a < b; ++a, --b)
                        {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
        return false;
    }
     
    let N = 4, K = 6;
    let values = [ 5, 2, 7, 3 ];
    
    // Function call
    document.write(maxProfit(values, N, K));
 

输出：

19

时间复杂度： O(N ² )
辅助空间： O(N)