通过仅获取角元素|最大化数组中最多K个元素的总和|套装2

给定一个数组arr []和一个整数K ，任务是通过仅获取边角元素来查找并最大化Array中最多K个元素的总和。

A corner element is an element from the start of the array or from the end of the array.

例子：

Input: N = 8, arr[] = {6, -1, 14, -15, 2, 1, 2, -5}, K = 4 
Output: 19 
Explanation: 
Here the optimal choice is to pick three cards from the beginning. After that if we want to pick the next card, our points will decrease. So maximum points is arr[0] + arr[1] + arr[2] = 19.

Input : N = 5, arr[] = {-2, -1, -6, -3, 1}, K = 2 
Output : 1 
Here optimal choice is to pick last card. So maximum possible points is arr[4] = 1. Any further selection will reduce the value. 
 

天真的方法：
为了解决上述问题，我们将使用Recursion 。由于我们只能采用起始或终止索引值，因此需要初始化两个变量并最多采用K步，并在所有可能的组合中返回最大和。仅当最大和大于前一个和时，才更新它，否则跳到下一个可能的组合。递归方法由于具有重叠的子问题和最佳的子结构属性而具有指数复杂性。

下面是上述方法的实现：

C++

// C++ implementation to Maximize sum of atmost
// K elements in Array by taking only corner elements
#include 
using namespace std;
 
// Function to return maximum points
int maxPointCount(int arr[], int K, int start, int end,
                  int points, int max_points)
{
    if (K == 0) {
        return max_points;
    }
    // Pick the start index
    int points_start = points + arr[start];
 
    // Update maximum points if necessary
    max_points = max(max_points, points_start);
 
    // Pick the end index
    int points_end = points + arr[end];
 
    // Update maximum points if necessary
    max_points = max(max_points, points_end);
 
    // Recursive call to get max value
    return max(maxPointCount(arr, K - 1, start + 1, end,
                                points_start, max_points),
               maxPointCount(arr, K - 1, start, end - 1,
                                points_end, max_points));
}
 
// Driver code
int main()
{
    int arr[] = { -2, -1, -6, -3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    int K = 2;
 
    int points = 0;
 
    int max_points = 0;
 
    // beginning index
    int start = 0;
 
    // end index
    int end = N - 1;
 
    cout << maxPointCount(arr, K, start,
                end, points, max_points);
 
    return 0;
}

Java

// Java implementation to Maximize
// sum of atmost K elements in Array
// by taking only corner elements
import java.util.*;
 
class GFG{
 
// Function to return maximum points
static int maxPointCount(int arr[], int K,
                         int start, int end,
                         int points, int max_points)
{
    if (K == 0)
    {
        return max_points;
    }
     
    // Pick the start index
    int points_start = points + arr[start];
 
    // Update maximum points if necessary
    max_points = Math.max(max_points, points_start);
 
    // Pick the end index
    int points_end = points + arr[end];
 
    // Update maximum points if necessary
    max_points = Math.max(max_points, points_end);
 
    // Recursive call to get max value
    return Math.max(maxPointCount(arr, K - 1,
                                  start + 1, end,
                                  points_start, max_points),
                    maxPointCount(arr, K - 1,
                                  start, end - 1,
                                  points_end, max_points));
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { -2, -1, -6, -3, 1 };
    int N = arr.length;
    int K = 2;
    int points = 0;
    int max_points = 0;
 
    // Beginning index
    int start = 0;
 
    // End index
    int end = N - 1;
 
    System.out.print(maxPointCount(arr, K, start,
                                   end, points,
                                   max_points));
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 implementation to maximize sum
# of atmost K elements in array by taking
# only corner elements
 
# Function to return maximum points
def maxPointCount(arr, K, start, end,
                  points, max_points):
 
    if (K == 0):
        return max_points
     
    # Pick the start index
    points_start = points + arr[start]
 
    # Update maximum points if necessary
    max_points = max(max_points, points_start)
 
    # Pick the end index
    points_end = points + arr[end]
 
    # Update maximum points if necessary
    max_points = max(max_points, points_end)
 
    # Recursive call to get max value
    return max(maxPointCount(arr, K - 1, start + 1, end,
                             points_start, max_points),
               maxPointCount(arr, K - 1, start, end - 1,
                             points_end, max_points))
 
# Driver code
if __name__ == "__main__":
     
    arr = [ -2, -1, -6, -3, 1 ]
    N = len(arr)
 
    K = 2
    points = 0
    max_points = 0
 
    # Beginning index
    start = 0
 
    # end index
    end = N - 1
 
    print(maxPointCount(arr, K, start,
                        end, points,
                        max_points))
 
# This code is contributed by chitranayal

C#

// C# implementation to Maximize
// sum of atmost K elements in Array
// by taking only corner elements
using System;
 
class GFG{
 
// Function to return maximum points
static int maxPointCount(int []arr, int K,
                         int start, int end,
                         int points, int max_points)
{
    if (K == 0)
    {
        return max_points;
    }
     
    // Pick the start index
    int points_start = points + arr[start];
 
    // Update maximum points if necessary
    max_points = Math.Max(max_points, points_start);
 
    // Pick the end index
    int points_end = points + arr[end];
 
    // Update maximum points if necessary
    max_points = Math.Max(max_points, points_end);
 
    // Recursive call to get max value
    return Math.Max(maxPointCount(arr, K - 1,
                                  start + 1, end,
                                  points_start, max_points),
                    maxPointCount(arr, K - 1,
                                  start, end - 1,
                                  points_end, max_points));
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { -2, -1, -6, -3, 1 };
    int N = arr.Length;
    int K = 2;
    int points = 0;
    int max_points = 0;
 
    // Beginning index
    int start = 0;
 
    // End index
    int end = N - 1;
 
    Console.Write(maxPointCount(arr, K, start,
                                end, points,
                                max_points));
}
}
 
// This code is contributed by sapnasingh4991

输出：

1

高效方法：
为了优化上述解决方案，我们将实现滑动窗口的概念。

• 最初，窗口大小为0，因为我们没有从数组中选择任何元素。我们采用两个变量的curr_points和max_points来表示当前点和最大点。
• 从一开始就一个个地考虑K个元素。因此，在每个步骤中，我们都会计算当前点并在必要时更新最大点，并且在从数组中包含K个元素之后，我们的滑动窗口大小将变为K，这是可能的最大值。
• 之后，在每个步骤中，我们从末尾选择元素，然后从前一个具有前K个元素的窗口中删除最右边的元素。更新curr_points和max_points。最后，该窗口包含阵列末尾的K张卡片。
• 最后，在每个步骤中，从先前选择的窗口中移除最左边的卡片，并从末尾移除K个元素。更新curr_points和max_points的值。最后，窗口大小将再次为0。

让我们看一下这个示例以更好地理解它，arr [] = {-2，-1，-6，-3，1}，K = 2

下面是上述方法的实现：

C++

// C++ implementation to Maximize sum
// of atmost K elements in Array by taking
// only corner elements
#include 
using namespace std;
 
// Function to return maximum points
int maxPointCount(int arr[], int K, int size)
{
    // Initialization of current points
    // and max points so far
    int curr_points = 0;
    int max_points = 0;
 
    // Add elements from the beginning
    for (int i = 0; i < K; i++) {
        curr_points += arr[i];
        max_points = max(curr_points, max_points);
    }
 
    // Points to the end of array element
    int j = size - 1;
 
    // Add K elements from end of array
    for (int i = K - 1; i >= 0; i--) {
        curr_points = curr_points + arr[j] - arr[i];
        max_points = max(curr_points, max_points);
 
        // Decrement the value for j
        j--;
    }
 
    j = size - K;
 
    for (; j < size; j++) {
        curr_points = curr_points - arr[j];
        max_points = max(curr_points, max_points);
    }
 
    // Return the final result
    return max_points;
}
 
// Driver code
int main()
{
    int arr[] = { -2, -1, -6, -3, 1 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    int K = 2;
 
    cout << maxPointCount(arr, K, N);
 
    return 0;
}

Java

// Java implementation to maximize
// sum of atmost K elements in Array
// by taking only corner elements
import java.util.Scanner;
import java.util.Arrays;
 
class GFG{
 
// Function to return maximum points
public static int maxPointCount(int arr[],
                                int K,
                                int size)
{
     
    // Initialization of current points
    // and max points so far
    int curr_points = 0;
    int max_points = 0;
 
    // Add elements from the beginning
    for(int i = 0; i < K; i++)
    {
        curr_points += arr[i];
        max_points = Math.max(curr_points,
                              max_points);
    }
 
    // Points to the end of array element
    int j = size - 1;
 
    // Add K elements from end of array
    for(int i = K - 1; i >= 0; i--)
    {
        curr_points = curr_points +
                      arr[j] - arr[i];
        max_points = Math.max(curr_points,
                              max_points);
 
        // Decrement the value for j
        j--;
    }
 
    j = size - K;
    for(; j < size; j++)
    {
        curr_points = curr_points - arr[j];
        max_points = Math.max(curr_points,
                              max_points);
    }
 
    // Return the final result
    return max_points;
}
 
// Driver code
public static void main(String args[])
{
    int []arr = { -2, -1, -6, -3, 1 };
    int N = arr.length;
    int K = 2;
 
    System.out.print(maxPointCount(arr, K, N));
}
}
 
// This code is contributed by SoumikMondal

Python3

# Python3 implementation to
# Maximize sum of atmost K
# elements in Array by taking
# only corner elements
  
# Function to return maximum
# points
def maxPointCount(arr, K, size):
 
    # Initialization of current
    # points and max points so far
    curr_points = 0;
    max_points = 0;
  
    # Add elements from
    # the beginning
    for i in range(K):
     
        curr_points += arr[i];
        max_points = max(curr_points,
                         max_points)   
  
    # Points to the end
    # of array element
    j = size - 1;
  
    # Add K elements from
    # end of array
    for i in range(K - 1, -1, -1):
     
        curr_points = (curr_points +
                       arr[j] - arr[i]);
        max_points = max(curr_points,
                         max_points);
  
        # Decrement the
        # value for j
        j -= 1;   
 
    for j in range(size - K, size):   
        curr_points = (curr_points -
                       arr[j]);
        max_points = max(curr_points,
                         max_points);   
  
    # Return the final result
    return max_points;   
 
# Driver code
if __name__ == "__main__":
     
    arr = [-2, -1, -6, -3, 1]
    N = len(arr)
    K = 2;   
    print(maxPointCount(arr,K,N))
     
# This code is contributed by rutvik_56

C＃

// C# implementation to maximize 
// sum of atmost K elements in Array 
// by taking only corner elements
using System;
 
class GFG{
     
// Function to return maximum points
static int maxPointCount(int[] arr, int K,
                         int size)
{
     
    // Initialization of current points 
    // and max points so far
    int curr_points = 0;
    int max_points = 0;
   
    // Add elements from the beginning
    for(int i = 0; i < K; i++) 
    {
        curr_points += arr[i];
        max_points = Math.Max(curr_points,
                               max_points);
    }
   
    // Points to the end of array element
    int j = size - 1;
   
    // Add K elements from end of array
    for(int i = K - 1; i >= 0; i--)
    {
        curr_points = curr_points + arr[j] -
                                    arr[i];
        max_points = Math.Max(curr_points,
                               max_points);
   
        // Decrement the value for j
        j--;
    }
   
    j = size - K;
    for(; j < size; j++)
    {
        curr_points = curr_points - arr[j];
        max_points = Math.Max(curr_points,
                               max_points);
    }
   
    // Return the final result
    return max_points;
}
 
// Driver code
static void Main()
{
    int[] arr = { -2, -1, -6, -3, 1 };
    int N = arr.Length;
    int K = 2;
   
    Console.WriteLine(maxPointCount(arr, K, N));
}
}
 
// This code is contributed by divyeshrabadiya07

输出：

1

时间复杂度： O(n)
辅助空间： O(1)
相似的文章：通过仅获取角元素来最大化数组中K个元素的总和