Time Needed to Buy Tickets

This approach directly simulates the ticket-buying process as described in the problem. We use a queue to represent the line of people. Each person buys a ticket, and if they need more, they are sent to the back of the queue. We keep track of the elapsed time until the person at index k has bought all their tickets.

• Create a Queue and populate it with the indices of people, from 0 to n-1.
• Initialize a time variable to 0.
• Start a loop that continues as long as the person at index k has tickets to buy.
• Inside the loop, dequeue the person's index p from the front of the queue.
• Increment the time counter.
• Decrement the ticket count for person p.
• If person p is the target person (p == k) and they have just finished buying tickets (tickets[p] == 0), return the total time.
• If person p still needs more tickets (tickets[p] > 0), add their index p back to the end of the queue.

The most intuitive way to solve this problem is to replicate the process exactly. We can use a queue, a data structure that perfectly models a first-in, first-out line.

1. Initialization: We start by creating a queue and adding the initial indices of all people (0, 1, ..., n-1) into it. We also initialize a time counter to zero.
2. Simulation Loop: The simulation runs in a loop. In each iteration, we simulate one second of time:
   • We take the person at the front of the queue (by dequeuing their index).
   • We increment our time counter.
   • This person buys one ticket, so we decrement their required ticket count in the tickets array.
   • We then check if this person was our target person at index k and if they have now bought all their tickets. If so, the simulation is over, and we return the current time.
   • If the person still has tickets to buy, they go to the back of the line, which we simulate by enqueuing their index.
   • If a person finishes buying all their tickets (and they are not the person at index k whose completion would stop the process), they simply leave the line and are not added back to the queue.

This process continues until the person at index k buys their last ticket.

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int timeRequiredToBuy(int[] tickets, int k) {
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < tickets.length; i++) {
            queue.add(i);
        }

        int time = 0;
        // The loop continues as long as the queue is not empty.
        // The condition to stop is checked inside the loop.
        while (!queue.isEmpty()) {
            int personIndex = queue.poll();
            time++;
            tickets[personIndex]--;

            if (personIndex == k && tickets[k] == 0) {
                return time;
            }

            if (tickets[personIndex] > 0) {
                queue.add(personIndex);
            }
        }
        return time; // Should not be reached given problem constraints
    }
}