Problem Description

You are tasked with simulating a document processing system involving m parallel indexers (workers), numbered from 0 to m-1. Documents arrive sequentially over time and are placed in a processing queue. Each document, when assigned to an indexer, occupies that indexer exclusively for a specified duration.

Document Assignment Rules

Documents are assigned based on the following 0-based indexing rules:

1. Document i arrives at queue_time[i] and requires processing_time[i] units of processing.
2. A base indexer is determined by base = i % m. The system first attempts to assign the document to indexer base.
3. An indexer j is considered available for a document arriving at time t if its current processing (if any) completes no later than time t.
4. If indexer base is available at queue_time[i], document i is assigned to indexer base.
5. Otherwise, the system scans indexers in increasing order, wrapping around modulo m: (base + 1) % m, (base + 2) % m, ..., (base + m - 1) % m. Document i is assigned to the first indexer found that is available at queue_time[i].
6. If no indexer is available at queue_time[i] after checking all m indexers, the document is dropped and never processed.
7. Once document i is assigned to indexer j at queue_time[i], indexer j becomes busy until queue_time[i] + processing_time[i].

Inputs

You will be provided with:

• An integer m: The total number of indexers.
• An integer array queue_time of length n: queue_time[i] represents the arrival time of document i. This array is strictly increasing (queue_time[i] < queue_time[i+1]).
• An integer array processing_time of length n: processing_time[i] is the duration required to process document i.

Assume n = len(queue_time) = len(processing_time).

Outputs

Your algorithm should compute the following:

Step 1

1. The total number of documents that were successfully processed (i.e., not dropped).
2. The indexer ID that processed the most documents. If multiple indexers are tied for the maximum, any one of them is an acceptable return.

Step 2

For a given integer k (where 1 \le k \le m):

1. The set of the top k indexers that processed the largest number of documents. If there are ties, any order or any valid choice among tied indexers is acceptable.
2. The percentage of all documents (including those dropped) that were processed by these top k indexers, expressed as a value between 0% and 100%.

Requirements

• Describe the algorithm to perform the simulation and compute all required outputs.
• Aim for an efficient solution in terms of time and space complexity.

Example

Input:

• m = 3
• queue_time = [1, 2, 3, 7]
• processing_time = [5, 4, 3, 2]
• Suppose k = 2 for Step 2.

Processing simulation:

• Document 0 arrives at time 1, base = 0. All indexers are free. Assign to indexer 0, busy until 1 + 5 = 6.
• Document 1 arrives at time 2, base = 1. Indexer 1 is free. Assign to indexer 1, busy until 2 + 4 = 6.
• Document 2 arrives at time 3, base = 2. Indexer 2 is free. Assign to indexer 2, busy until 3 + 3 = 6.
• Document 3 arrives at time 7, base = 0. Indexer 0 is free (available from time 6). Assign to indexer 0, busy until 7 + 2 = 9.

All documents are successfully processed. Indexer 0 processed 2 documents; indexers 1 and 2 each processed 1 document.

Output:

• Documents processed successfully: 4
• Indexer that processed most documents: 0
• Top 2 indexers (any valid order with ties): e.g., [0, 1] or [0, 2]
• Percentage of documents processed by these 2 indexers: 75% (3 out of 4 documents)