Skip to content
Related Articles

Related Articles

Maximum amount of money that can be collected by a player in a game of coins
  • Difficulty Level : Hard
  • Last Updated : 01 Mar, 2021

Given a 2D array Arr[][] consisting of N rows and two persons A and B playing a game of alternate turns based on the following rules:

  • A row is chosen at random, where A can only take the leftmost remaining coin while B can only take the rightmost remaining coin in the chosen row.
  • The game ends when there are no coins left.

The task is to determine the maximum amount of money obtained by A.

 Examples:

Input: N = 2, Arr[][] = {{ 5, 2, 3, 4 }, { 1, 6 }}
Output: 8
Explanation: 
Row 1: 5, 2, 3, 4
Row 2: 1, 6
Operations:

  1. A takes the coin with value 5
  2. B takes the coin with value 4
  3. A takes the coin with value 2
  4. B takes the coin with value 3
  5. A takes the coin with value 1
  6. B takes the coin with value 6

Optimally, money collected by A = 5 + 2 + 1 = 8 
Money collected by B = 3 + 4 + 6 = 13



Input: N = 1, Arr[] = {{ 1, 2, 3 }}
Output : 3

  Approach: Follow the steps below to solve the problem

  1. In a game played with optimal strategy
  2. Initialize a variable, say amount, to store the money obtained by A.
  3. If N is even, A will collect the first half of the coins
  4. Otherwise, first, (N / 2) coins would be collected by A and last (N / 2) would be collected by B
  5. If N is odd, the coin at the middle can be collected by A or B, depending upon the sequence of moves.
  6. Store the coin at the middle of all odd sized rows in a variable, say mid_odd[].
  7. Sort the array mid_odd[] in descending order.
  8. Optimally, A would collect all coins at even indices of min_odd[]
  9. Finally, print the score of A.

Below is the implementation of the above approach:

C++




// CPP Program to implement
// the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to calculate the
// maximum amount collected by A
void find(int N,  vector<vector<int>>Arr)
{
     
    // Stores the money
    // obtained by A
    int amount = 0;
 
    // Stores mid elements
    // of odd sized rows
    vector<int> mid_odd;
    for(int i = 0; i < N; i++)
    {
 
        // Size of current row
        int siz = Arr[i].size();
 
        // Increase money collected by A
        for (int j = 0; j < siz / 2; j++)
            amount = amount + Arr[i][j];
 
        if(siz % 2 == 1)
            mid_odd.push_back(Arr[i][siz/2]);
    }
 
    // Add coins at even indices
    // to the amount colected by A
    sort(mid_odd.begin(),mid_odd.end());
 
    for(int i = 0; i < mid_odd.size(); i++)
        if (i % 2 == 0)
         amount = amount + mid_odd[i];
 
    // Print the amount
    cout<<amount<<endl;
 
}
 
// Driver Code
int main()
{
   int N = 2;
   vector<vector<int>>Arr{{5, 2, 3, 4}, {1, 6}};
 
   // Function call to calculate the
   // amount of coins collected by A
   find(N, Arr);
}
 
// This code is contributed by ipg2016107.

Java




// Java program to implement
// the above approach
import java.util.*;
class GFG
{
  
// Function to calculate the
// maximum amount collected by A
static void find(int N, int[][] Arr)
{
     
    // Stores the money
    // obtained by A
    int amount = 0;
 
    // Stores mid elements
    // of odd sized rows
    ArrayList<Integer> mid_odd
            = new ArrayList<Integer>();
    for(int i = 0; i < N; i++)
    {
 
        // Size of current row
        int siz = Arr[i].length;
 
        // Increase money collected by A
        for (int j = 0; j < siz / 2; j++)
            amount = amount + Arr[i][j];
 
        if(siz % 2 == 1)
            mid_odd.add(Arr[i][siz/2]);
    }
 
    // Add coins at even indices
    // to the amount colected by A
    Collections.sort(mid_odd);
     
    for(int i = 0; i < mid_odd.size(); i++){
        if (i % 2 == 0)
         amount = amount + mid_odd.get(i);
    }
 
    // Print the amount
    System.out.println(amount);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 2;
   int[][] Arr = {{5, 2, 3, 4}, {1, 6}};
 
   // Function call to calculate the
   // amount of coins collected by A
   find(N, Arr);
}
}
  
// This code is contributed by splevel62.

Python3




# Python Program to implement
# the above approach
 
# Function to calculate the
# maximum amount collected by A
 
 
def find(N, Arr):
 
    # Stores the money
    # obtained by A
    amount = 0
 
    # Stores mid elements
    # of odd sized rows
    mid_odd = []
 
    for i in range(N):
 
        # Size of current row
        siz = len(Arr[i])
 
        # Increase money collected by A
        for j in range(0, siz // 2):
            amount = amount + Arr[i][j]
 
        if(siz % 2 == 1):
            mid_odd.append(Arr[i][siz // 2])
 
    # Add coins at even indices
    # to the amount colected by A
    mid_odd.sort(reverse=True)
 
    for i in range(len(mid_odd)):
        if i % 2 == 0:
            amount = amount + mid_odd[i]
 
    # Print the amount
    print(amount)
 
 
# Driver Code
 
N = 2
Arr = [[5, 2, 3, 4], [1, 6]]
 
# Function call to calculate the
# amount of coins collected by A
find(N, Arr)

C#




// C# Program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG {
 
  // Function to calculate the
  // maximum amount collected by A
  static void find(int N, List<List<int>> Arr)
  {
 
    // Stores the money
    // obtained by A
    int amount = 0;
 
    // Stores mid elements
    // of odd sized rows
    List<int> mid_odd = new List<int>();
    for(int i = 0; i < N; i++)
    {
 
      // Size of current row
      int siz = Arr[i].Count;
 
      // Increase money collected by A
      for (int j = 0; j < siz / 2; j++)
        amount = amount + Arr[i][j];
 
      if(siz % 2 == 1)
        mid_odd.Add(Arr[i][siz/2]);
    }
 
    // Add coins at even indices
    // to the amount colected by A
    mid_odd.Sort();
 
    for(int i = 0; i < mid_odd.Count; i++)
      if (i % 2 == 0)
        amount = amount + mid_odd[i];
 
    // Print the amount
    Console.WriteLine(amount);
 
  }
 
  // Driver code
  static void Main()
  {
    int N = 2;
    List<List<int>> Arr = new List<List<int>>();
    Arr.Add(new List<int>());
    Arr[0].Add(5);
    Arr[0].Add(2);
    Arr[0].Add(3);
    Arr[0].Add(4);
    Arr.Add(new List<int>());
    Arr[1].Add(1);
    Arr[1].Add(6);
 
    // Function call to calculate the
    // amount of coins collected by A
    find(N, Arr);
  }
}
 
// This code is contributed by divyesh072019.
Output: 
8

 

Time Complexity : O(N)
Auxiliary Space : O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :