Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Medium
  • Last Updated : 15 Apr, 2021

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 ith 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 = 3 
Output:
 

PersonEmpty SeatsTicket Cost
11 2 44
21 2 33
31 2 22

4 + 3 + 2 = 9
Input: seats[] = {2, 3, 5, 3}, N = 4 
Output: 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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :