# Find the maximum amount that can be collected by selling movie tickets

Given an integer **N** and an array **seats[]** where **N** is the number of people standing in a line to buy a movie ticket and **seat[i]** is the number of empty seats in the **i ^{th}** row of the movie theater. The task is to find the maximum amount a theater owner can make by selling movie tickets to

**N**people. Price of a ticket is equal to the maximum number of empty seats among all the rows.

**Example:**

Input:seats[] = {1, 2, 4}, N = 3Output:9

Person Empty Seats Ticket Cost 1 1 2 4 4 2 1 2 3 3 3 1 2 2 2 4 + 3 + 2 = 9

Input:seats[] = {2, 3, 5, 3}, N = 4Output:15

**Approach:** This problem can be solved by using a priority queue that will store the count of empty seats for every row and the maximum among them will be available at the top.

- Create an empty priority_queue
**q**and traverse the**seats[]**array and insert all element into the priority_queue. - Initialize two integer variable
**ticketSold = 0**and**ans = 0**that will store the number of tickets sold and the total collection of the amount so far. - Now check while
**ticketSold < N**and**q.top() > 0**then remove the top element from the priority_queue and update ans by adding top element of the priority queue. Also store this top value in a variable**temp**and insert**temp – 1**back to the priority_queue. - Repeat these steps until all the people have been sold the tickets and print the final result.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the maximum amount` `// that can be collected by selling tickets` `int` `maxAmount(` `int` `M, ` `int` `N, ` `int` `seats[])` `{` ` ` `// Priority queue that stores` ` ` `// the count of empty seats` ` ` `priority_queue<` `int` `> q;` ` ` `// Insert each array element` ` ` `// into the priority queue` ` ` `for` `(` `int` `i = 0; i < M; i++) {` ` ` `q.push(seats[i]);` ` ` `}` ` ` `// To store the total` ` ` `// number of tickets sold` ` ` `int` `ticketSold = 0;` ` ` `// To store the total amount` ` ` `// of collection` ` ` `int` `ans = 0;` ` ` `// While tickets sold are less than N` ` ` `// and q.top > 0 then update the collected` ` ` `// amount with the top of the priority` ` ` `// queue` ` ` `while` `(ticketSold < N && q.top() > 0) {` ` ` `ans = ans + q.top();` ` ` `int` `temp = q.top();` ` ` `q.pop();` ` ` `q.push(temp - 1);` ` ` `ticketSold++;` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `seats[] = { 1, 2, 4 };` ` ` `int` `M = ` `sizeof` `(seats) / ` `sizeof` `(` `int` `);` ` ` `int` `N = 3;` ` ` `cout << maxAmount(N, M, seats);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `import` `java.util.*;` `class` `GFG` `{` ` ` `static` `int` `[] seats = ` `new` `int` `[]{ ` `1` `, ` `2` `, ` `4` `};` ` ` `// Function to return the maximum amount` ` ` `// that can be collected by selling tickets` ` ` `public` `static` `int` `maxAmount(` `int` `M, ` `int` `N)` ` ` `{` ` ` `// Priority queue that stores` ` ` `// the count of empty seats` ` ` `PriorityQueue<Integer> q =` ` ` `new` `PriorityQueue<Integer>(Collections.reverseOrder());` ` ` ` ` `// Insert each array element` ` ` `// into the priority queue` ` ` `for` `(` `int` `i = ` `0` `; i < M; i++)` ` ` `{` ` ` `q.add(seats[i]);` ` ` `}` ` ` `// To store the total` ` ` `// number of tickets sold` ` ` `int` `ticketSold = ` `0` `;` ` ` ` ` `// To store the total amount` ` ` `// of collection` ` ` `int` `ans = ` `0` `;` ` ` ` ` `// While tickets sold are less than N` ` ` `// and q.top > 0 then update the collected` ` ` `// amount with the top of the priority` ` ` `// queue` ` ` `while` `(ticketSold < N && q.peek() > ` `0` `)` ` ` `{` ` ` `ans = ans + q.peek();` ` ` `int` `temp = q.peek();` ` ` `q.poll();` ` ` `q.add(temp - ` `1` `);` ` ` `ticketSold++;` ` ` `}` ` ` `return` `ans;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `M = seats.length;` ` ` `int` `N = ` `3` `;` ` ` ` ` `System.out.print(maxAmount(M, N));` ` ` `}` `}` `// This code is contributed by Sanjit_Prasad` |

## Python 3

`# Python 3 implementation of the approach` `# Function to return the maximum amount` `# that can be collected by selling tickets` `def` `maxAmount(M, N, seats):` ` ` ` ` `# Priority queue that stores` ` ` `# the count of empty seats` ` ` `q ` `=` `[]` ` ` `# Insert each array element` ` ` `# into the priority queue` ` ` `for` `i ` `in` `range` `(M):` ` ` `q.append(seats[i])` ` ` `# To store the total` ` ` `# number of tickets sold` ` ` `ticketSold ` `=` `0` ` ` `# To store the total amount` ` ` `# of collection` ` ` `ans ` `=` `0` ` ` `# While tickets sold are less than N` ` ` `# and q.top > 0 then update the collected` ` ` `# amount with the top of the priority` ` ` `# queue` ` ` `q.sort(reverse ` `=` `True` `)` ` ` `while` `(ticketSold < N ` `and` `q[` `0` `] > ` `0` `):` ` ` `ans ` `=` `ans ` `+` `q[` `0` `]` ` ` `temp ` `=` `q[` `0` `]` ` ` `q ` `=` `q[` `1` `:]` ` ` `q.append(temp ` `-` `1` `)` ` ` `q.sort(reverse ` `=` `True` `)` ` ` `ticketSold ` `+` `=` `1` ` ` `return` `ans` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `seats ` `=` `[` `1` `, ` `2` `, ` `4` `]` ` ` `M ` `=` `len` `(seats)` ` ` `N ` `=` `3` ` ` `print` `(maxAmount(N, M, seats))` `# This code is contributed by Surendra_Gangwar` |

## C#

`// C# implementation of the approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{` ` ` ` ` `// Function to return the maximum amount` ` ` `// that can be collected by selling tickets` ` ` `static` `int` `maxAmount(` `int` `M, ` `int` `N, ` `int` `[] seats)` ` ` `{` ` ` ` ` `// Priority queue that stores` ` ` `// the count of empty seats` ` ` `List<` `int` `> q = ` `new` `List<` `int` `>();` ` ` ` ` `// Insert each array element` ` ` `// into the priority queue` ` ` `for` `(` `int` `i = 0; i < M; i++) {` ` ` `q.Add(seats[i]);` ` ` `}` ` ` ` ` `q.Sort();` ` ` `q.Reverse();` ` ` ` ` `// To store the total` ` ` `// number of tickets sold` ` ` `int` `ticketSold = 0;` ` ` ` ` `// To store the total amount` ` ` `// of collection` ` ` `int` `ans = 0;` ` ` ` ` `// While tickets sold are less than N` ` ` `// and q.top > 0 then update the collected` ` ` `// amount with the top of the priority` ` ` `// queue` ` ` `while` `(ticketSold < N && q[0] > 0) {` ` ` `ans = ans + q[0];` ` ` `int` `temp = q[0];` ` ` `q.RemoveAt(0);` ` ` `q.Add(temp - 1);` ` ` `q.Sort();` ` ` `q.Reverse();` ` ` `ticketSold++;` ` ` `} ` ` ` `return` `ans;` ` ` `}` ` ` `// Driver code` ` ` `static` `void` `Main()` ` ` `{` ` ` `int` `[] seats = { 1, 2, 4 };` ` ` `int` `M = seats.Length;` ` ` `int` `N = 3;` ` ` `Console.WriteLine(maxAmount(N, M, seats));` ` ` `}` `}` `// This code is contributed by divyesh072019.` |

## Javascript

`<script>` ` ` `// Javascript implementation of the approach` ` ` ` ` `// Function to return the maximum amount` ` ` `// that can be collected by selling tickets` ` ` `function` `maxAmount(M, N, seats)` ` ` `{` ` ` ` ` `// Priority queue that stores` ` ` `// the count of empty seats` ` ` `let q = [];` ` ` ` ` `// Insert each array element` ` ` `// into the priority queue` ` ` `for` `(let i = 0; i < M; i++) {` ` ` `q.push(seats[i]);` ` ` `}` ` ` ` ` `q.sort(` `function` `(a, b){` `return` `a - b});` ` ` `q.reverse();` ` ` ` ` `// To store the total` ` ` `// number of tickets sold` ` ` `let ticketSold = 0;` ` ` ` ` `// To store the total amount` ` ` `// of collection` ` ` `let ans = 0;` ` ` ` ` `// While tickets sold are less than N` ` ` `// and q.top > 0 then update the collected` ` ` `// amount with the top of the priority` ` ` `// queue` ` ` `while` `((ticketSold < N) && (q[0] > 0)) {` ` ` `ans = ans + q[0];` ` ` `let temp = q[0];` ` ` `q.shift();` ` ` `q.push(temp - 1);` ` ` `q.sort(` `function` `(a, b){` `return` `a - b});` ` ` `q.reverse();` ` ` `ticketSold++;` ` ` `} ` ` ` `return` `ans;` ` ` `}` ` ` ` ` `let seats = [ 1, 2, 4 ];` ` ` `let M = seats.length;` ` ` `let N = 3;` ` ` `document.write(maxAmount(N, M, seats));` ` ` `</script>` |

**Output:**

9

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.