通过最多执行K次给定操作来最大化第一个数组元素

给定大小为N的整数arr []整数K ，任务是通过最多执行K次以下操作来找到最大化数组的第一个元素：

1. 选择一对索引i和j (0≤i，j≤N-1) ，使得| i − j | = 1且arr _i > 0 。
2. 在这两个索引上分别设置arr _i = arr _i − 1和arr _j = arr _j +1 。

例子：

Input: arr[ ] = {1, 0, 3, 2}, K = 5
Output: 3
Explanation:
One of the possible set of operations can be:
Operation 1: Select i = 3 and j = 2. Therefore, the array modifies to {1, 1, 2, 2}.
Operation 2: Select i = 3 and j = 2. Therefore, the array modifies to {1, 2, 1, 2}.
Operation 3: Select i = 2 and j = 1. Therefore, the array modifies to {2, 1, 1, 2}.
Operation 4: Select i = 2 and j = 1. Therefore, the array modifies to {3, 0, 1, 2}.

Input: arr[] = {5, 1}, K = 2
Output: 6

方法：请按照以下步骤解决问题：

1. 在任何时候，最佳选择索引i和j最接近数组的第一个元素，且i> j 。
2. 因此，对于每个操作，请从左到右遍历数组，并将元素移近第一个元素。
3. 如果所有元素都在某个位置处在第一位置，则停止遍历并打印第一个数组元素。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to maximize
// the first array element
int getMax(int arr[], int N, int K)
{
 
    // Traverse the array
    for (int i = 1; i < N; i++) {
 
        // Initialize cur_val to a[i]
        int cur_val = arr[i];
 
        // If all operations
        // are not over yet
        while (K >= i) {
 
            // If current value is
            // greater than zero
            if (cur_val > 0) {
 
                // Incrementing first
                // element of array by 1
                arr[0] = arr[0] + 1;
 
                // Decrementing current
                // value of array by 1
                cur_val = cur_val - 1;
 
                // Decrementing number
                // of operations by i
                K = K - i;
            }
 
            // If current value is
            // zero, then break
            else
                break;
        }
    }
 
    // Print first array element
    cout << arr[0];
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 1, 0, 3, 2 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Given K
    int K = 5;
 
    // Prints the maximum
    // possible value of the
    // first array element
    getMax(arr, N, K);
 
    return 0;
}

Java

// Java program for the above approach
class GFG{
 
  // Function to maximize
  // the first array element
  static void getMax(int arr[], int N, int K)
  {
 
    // Traverse the array
    for (int i = 1; i < N; i++)
    {
 
      // Initialize cur_val to a[i]
      int cur_val = arr[i];
 
      // If all operations
      // are not over yet
      while (K >= i)
      {
 
        // If current value is
        // greater than zero
        if (cur_val > 0)
        {
 
          // Incrementing first
          // element of array by 1
          arr[0] = arr[0] + 1;
 
          // Decrementing current
          // value of array by 1
          cur_val = cur_val - 1;
 
          // Decrementing number
          // of operations by i
          K = K - i;
        }
 
        // If current value is
        // zero, then break
        else
          break;
      }
    }
 
    // Print first array element
    System.out.print(arr[0]);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
     
    // Given array
    int arr[] = { 1, 0, 3, 2 };
 
    // Size of the array
    int N = arr.length;
 
    // Given K
    int K = 5;
 
    // Prints the maximum
    // possible value of the
    // first array element
    getMax(arr, N, K);
  }
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program for the above approach
 
# Function to maximize
# the first array element
def getMax(arr, N, K):
     
    # Traverse the array
    for i in range(1, N, 1):
         
        # Initialize cur_val to a[i]
        cur_val = arr[i]
 
        # If all operations
        # are not over yet
        while (K >= i):
             
            # If current value is
            # greater than zero
            if (cur_val > 0):
 
                # Incrementing first
                # element of array by 1
                arr[0] = arr[0] + 1
 
                # Decrementing current
                # value of array by 1
                cur_val = cur_val - 1
 
                # Decrementing number
                # of operations by i
                K = K - i
 
            # If current value is
            # zero, then break
            else:
                break
 
    # Print first array element
    print(arr[0])
 
# Driver Code
if __name__ == '__main__':
     
    # Given array
    arr = [ 1, 0, 3, 2 ]
 
    # Size of the array
    N = len(arr)
 
    # Given K
    K = 5
 
    # Prints the maximum
    # possible value of the
    # first array element
    getMax(arr, N, K)
 
# This code is contributed by SURENDRA_GANGWAR

C#

// C# program for the above approach
using System;
 
class GFG{
     
// Function to maximize
// the first array element
static void getMax(int[] arr, int N,
                   int K)
{
     
    // Traverse the array
    for(int i = 1; i < N; i++)
    {
         
        // Initialize cur_val to a[i]
        int cur_val = arr[i];
   
        // If all operations
        // are not over yet
        while (K >= i)
        {
             
            // If current value is
            // greater than zero
            if (cur_val > 0)
            {
                 
                // Incrementing first
                // element of array by 1
                arr[0] = arr[0] + 1;
                 
                // Decrementing current
                // value of array by 1
                cur_val = cur_val - 1;
                 
                // Decrementing number
                // of operations by i
                K = K - i;
            }
   
            // If current value is
            // zero, then break
            else
                break;
        }
    }
     
    // Print first array element
    Console.Write(arr[0]);
} 
 
// Driver code
static void Main()
{
     
    // Given array
    int[] arr = { 1, 0, 3, 2 };
     
    // Size of the array
    int N = arr.Length;
     
    // Given K
    int K = 5;
     
    // Prints the maximum
    // possible value of the
    // first array element
    getMax(arr, N, K);
}
}
 
// This code is contributed by divyesh072019

Javascript

// javascript program for the above approach   
// Function to maximize
    // the first array element
    function getMax(arr , N , K) {
 
        // Traverse the array
        for (i = 1; i < N; i++) {
 
            // Initialize cur_val to a[i]
            var cur_val = arr[i];
 
            // If all operations
            // are not over yet
            while (K >= i) {
 
                // If current value is
                // greater than zero
                if (cur_val > 0) {
 
                    // Incrementing first
                    // element of array by 1
                    arr[0] = arr[0] + 1;
 
                    // Decrementing current
                    // value of array by 1
                    cur_val = cur_val - 1;
 
                    // Decrementing number
                    // of operations by i
                    K = K - i;
                }
 
                // If current value is
                // zero, then break
                else
                    break;
            }
        }
 
        // Prvar first array element
        document.write(arr[0]);
    }
 
    // Driver Code
     
        // Given array
        var arr = [ 1, 0, 3, 2 ];
 
        // Size of the array
        var N = arr.length;
 
        // Given K
        var K = 5;
 
        // Prints the maximum
        // possible value of the
        // first array element
        getMax(arr, N, K);
 
// This code is contributed by aashish1995

输出：

3

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