# Maximum amount of money that can be collected by a player in a game of coins

• Difficulty Level : Hard
• Last Updated : 10 Aug, 2022

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``using` `namespace` `std;` `// Function to calculate the``// maximum amount collected by A``void` `find(``int` `N,  vector>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 collected 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<>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 mid_odd``            ``= ``new` `ArrayList();``    ``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 collected 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 collected 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> 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 collected 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> Arr = ``new` `List>();``    ``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.`

## Javascript

 ``

Output:

`8`

Time Complexity: O(N log N), sort function takes N log N time to execute hence the overall time complexity turns out to be N log N
Auxiliary Space: O(x) where x is the number of mid elements of odd-sized rows pushed into the vector

My Personal Notes arrow_drop_up