通过执行给定的操作来最大化删除的数组元素的总和

给定两个数组arr[]和min[] ，由N 个整数和一个整数K 组成。对于每个索引i ， arr[i] 最多可以减少到min[i] 。考虑一个变量，比如说S (最初为0 )。任务是找到通过执行以下操作可以获得的S的最大值：

• 选择一个索引i并将max(arr[i], min[i]) 添加到S 。
• 从arr[]及其对应的最小值中删除所选元素。
• 如果每个剩余值大于min[] 中相应的最小值，则将每个剩余值减少K。

例子：

Input: arr[] = {2, 4, 5, 8}, min[] = {1, 4, 5, 5}, K = 3
Output: 18
Explanation:
Choose the elements in the following order:
Step 1: Choose element 8. Now, S = 8 and arr[] = {-1, 4, 5} and min[] = {1, 4, 5}
Step 2: Choose element 5. Now, S = 8 + 5 = 13 and arr[] = {-1, 4} and min[] = {1, 4}
Step 3: Choose element 5. Now, S = 8 + 5 + 4 = 17 and arr[] = {-1} and min[] = {1}
Step 4: Choose element -1, but -1 < min[0]. Therefore, choose 1.
Hence, S = 8 + 5 + 4 + 1 = 18.

Input: arr[] = {3, 5, 2, 1}, min[] = {3, 2, 1, 3}, K = 2
Output: 12
Explanation:
Choose the elements in the following order:
Step 1: Choose element 5. Now, S = 5 and arr[] = {3, 0, 1} and min[] = {3, 1, 3}
Step 2: Choose element 3. Now, S = 5 + 3 = 8 and arr[] = {0, 1} and min[] = {1, 3} 
Step 3: Choose element 3 from min[]. Now, S = 5 + 3 + 3 = 11 and arr[] = {0} and min[] = {1}
Step 4: Choose element 1 from min[].
Hence, S = 5 + 3 + 3 + 1 = 12.

朴素的方法：最简单的方法是遍历给定的数组并在数组本身中执行给定的操作。请按照以下步骤解决问题：

1. 遍历数组并找到最大的数组元素。
2. 在S 中添加最大值并删除最大值。
3. 如果满足上述条件，则将剩余元素减少K。
4. 重复上述步骤，直到给定的数组变为空。
5. 遍历后，打印S 。

时间复杂度： O(N ² )，其中 N 是给定数组的长度。
辅助空间： O(N)

有效的方法：这个想法是按降序对给定的数组进行排序。然后，通过贪婪地选择元素来打印S的最大值。请按照以下步骤解决问题：

1. 将数组arr[]的元素与其对应的min[]值配对。
2. 根据数组arr[]以降序对数组对进行排序。
3. 最初，选择最大元素并将K增加其初始值。
4. 现在，通过将其值减少当前K 来选择下一个最大元素。
5. 重复上述步骤，直到遍历完所有数组元素并打印S的值。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the maximum sum of
// the array arr[] where each element
// can be reduced to at most min[i]
void findMaxSum(vector arr, int n,
                vector min, int k,
                int& S)
{
    // Stores the pair of arr[i] & min[i]
    vector > A;
 
    for (int i = 0; i < n; i++) {
        A.push_back({ arr[i], min[i] });
    }
 
    // Sorting vector of pairs
    sort(A.begin(), A.end(),
        greater >());
 
    int K = 0;
 
    // Traverse the vector of pairs
    for (int i = 0; i < n; i++) {
 
        // Add to the value of S
        S += max(A[i].first - K,
                A[i].second);
 
        // Update K
        K += k;
    }
}
 
// Driver Code
int main()
{
    vector arr, min;
 
    // Given array arr[], min[]
    arr = { 3, 5, 2, 1 };
    min = { 3, 2, 1, 3 };
 
    int N = arr.size();
 
    // Given K
    int K = 3;
 
    int S = 0;
 
    // Function Call
    findMaxSum(arr, N, min, K, S);
 
    // Print the value of S
    cout << S;
 
    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;
  
class GFG{
     
static int S;
 
// Function to find the maximum sum of
// the array arr[] where each element
// can be reduced to at most min[i]
static void findMaxSum(int[] arr, int n,
                       int[] min, int k)
{
     
    // Stores the pair of arr[i] & min[i]
    ArrayList A = new ArrayList<>();
  
    for(int i = 0; i < n; i++)
    {
        A.add(new int[]{arr[i], min[i]});
    }
  
    // Sorting vector of pairs
    Collections.sort(A, (a, b) -> b[0] - a[0]);
  
    int K = 0;
  
    // Traverse the vector of pairs
    for(int i = 0; i < n; i++)
    {
         
        // Add to the value of S
        S += Math.max(A.get(i)[0] - K,
                      A.get(i)[1]);
  
        // Update K
        K += k;
    }
}
 
// Driver code
public static void main (String[] args)
{
     
    // Given array arr[], min[]
    int[] arr = { 3, 5, 2, 1 };
    int[] min = { 3, 2, 1, 3 };
     
    int N = arr.length;
     
    // Given K
    int K = 3;
     
     S = 0;
     
    // Function Call
    findMaxSum(arr, N, min, K);
     
    // Print the value of S
    System.out.println(S);
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program for the above approach
 
# Function to find the maximum sum of
# the array arr[] where each element
# can be reduced to at most min[i]
def findMaxSum(arr, n, min, k, S):
     
    # Stores the pair of arr[i] & min[i]
    A = []
 
    for i in range(n):
        A.append((arr[i], min[i]))
 
    # Sorting vector of pairs
    A = sorted(A)
    A = A[::-1]
     
    K = 0
 
    # Traverse the vector of pairs
    for i in range(n):
 
        # Add to the value of S
        S += max(A[i][0] - K, A[i][1])
 
        # Update K
        K += k
 
    return S
     
# Driver Code
if __name__ == '__main__':
     
    arr, min = [], []
 
    # Given array arr[], min[]
    arr = [ 3, 5, 2, 1 ]
    min = [ 3, 2, 1, 3 ]
 
    N = len(arr)
 
    # Given K
    K = 3
     
    S = 0
 
    # Function Call
    S = findMaxSum(arr, N, min, K, S)
 
    # Print the value of S
    print(S)
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Linq;
 
class GFG{
 
static int S;
 
// Function to find the maximum sum of
// the array arr[] where each element
// can be reduced to at most min[i]
static void findMaxSum(int[] arr, int n,
                       int[] min, int k)
{
     
    // Stores the pair of arr[i] & min[i]
    List> A = new List>();
    for(int i = 0; i < n; i++)
    {
        A.Add(new List());
        A[i].Add(arr[i]);
        A[i].Add(min[i]);
    }
     
    // Sorting vector of pairs
    A = A.OrderBy(lst => lst[0]).ToList();
    A.Reverse();
     
    int K = 0;
     
    // Traverse the vector of pairs
    for(int i = 0; i < n; i++)
    {
         
        // Add to the value of S
        S += Math.Max(A[i][0] - K, A[i][1]);
         
        // Update K
        K += k;
    }
}
 
// Driver code
static public void Main()
{
     
    // Given array arr[], min[]
    int[] arr = { 3, 5, 2, 1 };
    int[] min = { 3, 2, 1, 3 };
  
    int N = arr.Length;
  
    // Given K
    int K = 3;
  
    S = 0;
  
    // Function Call
    findMaxSum(arr, N, min, K);
  
    // Print the value of S
    Console.WriteLine(S);
}
}
 
// This code is contributed by avanitrachhadiya2155

Javascript

 
// Javascript program for the above approach
 
var S =0;
 
// Function to find the maximum sum of
// the array arr[] where each element
// can be reduced to at most min[i]
function findMaxSum(arr, n, min, k)
{
    // Stores the pair of arr[i] & min[i]
    var A = [];
 
    for (var i = 0; i < n; i++) {
        A.push([arr[i], min[i] ]);
    }
 
    // Sorting vector of pairs
    A.sort((a,b)=> b[0]-a[0]);
 
    var K = 0;
 
    // Traverse the vector of pairs
    for (var i = 0; i < n; i++) {
 
        // Add to the value of S
        S += Math.max(A[i][0] - K,
                A[i][1]);
 
        // Update K
        K += k;
    }
}
 
// Driver Code
var arr = [], min = [];
// Given array arr[], min[]
arr = [3, 5, 2, 1];
min = [3, 2, 1, 3];
var N = arr.length;
// Given K
var K = 3;
// Function Call
findMaxSum(arr, N, min, K, S);
// Print the value of S
document.write( S);
 

输出：

12

时间复杂度： O(N*log N)，其中 N 是给定数组的长度。
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live