GFG App
Open App
Browser
Continue

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

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