Orig Description
Conveyor Belt
Awesome Conveyor Machine (ACM) is the most important equipment of a factory of Industrial Conveyor Product Corporation (ICPC). ACM has a long conveyor belt to deliver their products from some points to other points. You are a programmer hired to make efficient schedule plan for product delivery.
ACM's conveyor belt goes through $N$ points at equal intervals. The conveyor has plates on each of which at most one product can be put. Initially, there are no plates at any points. The conveyor belt moves by exactly one plate length per unit time; after one second, a plate is at position 1 while there are no plates at the other positions. After further 1 seconds, the plate at position 1 is moved to position 2 and a new plate comes at position 1, and so on. Note that the conveyor has the unlimited number of plates: after $N$ seconds or later, each of the $N$ positions has exactly one plate.
A delivery task is represented by positions $a$ and $b$; delivery is accomplished by putting a product on a plate on the belt at $a$, and retrieving it at $b$ after $b - a$ seconds ($a < b$). (Of course, it is necessary that an empty plate exists at the position at the putting time.) In addition, putting and retrieving products must bedone in the following manner:
When putting and retrieving a product, a plate must be located just at the position. That is, products must be put and retrieved at integer seconds.
Putting and retrieving at the same position cannot be done at the same time. On the other hand, putting and retrieving at the different positions can be done at the same time.
If there are several tasks, the time to finish all the tasks may be reduced by changing schedule when each product is put on the belt. Your job is to write a program minimizing the time to complete all the tasks... wait, wait. When have you started misunderstanding that you can know all the tasks initially? New delivery requests are coming moment by moment, like plates on the conveyor! So you should update your optimal schedule per every new request.
A request consists of a start point $a$, a goal point $b$, and the number $p$ of products to deliver from $a$ to $b$. Delivery requests will be added $Q$ times. Your (true) job is to write a program such that for each $1 \leq i \leq Q$, minimizing the entire time to complete delivery tasks in requests 1 to $i$.
Input
The input consists of a single test case formatted as follows.
$N$ $Q$
$a_1$ $b_1$ $p_1$
:
$a_Q$ $b_Q$ $p_Q$
A first line includes two integers $N$ and $Q$ ($2 \leq N \leq 10^5, 1 \leq Q \leq 10^5$): $N$ is the number of positions the conveyor belt goes through and $Q$ is the number of requests will come. The $i$-th line of the following $Q$ lines consists of three integers $a_i, b_i,$ and $p_i$ ($1 \leq a_i < b_i \leq N, 1 \leq p_i \leq 10^9$), which mean that the $i$-th request requires $p_i$ products to be delivered from position $a_i$ to position $b_i$.
Output
In the $i$-th line, print the minimum time to complete all the tasks required by requests $1$ to $i$.
Sample Input 1
5 2
1 4 1
2 3 1
Output for Sample Input 1
4
4
Sample Input 2
5 2
1 4 1
2 3 5
Output for Sample Input 2
4
8
Sample Input 3
5 2
1 3 3
3 5 1
Output for Sample Input 3
5
6
Sample Input 4
10 4
3 5 2
5 7 5
8 9 2
1 7 5
Output for Sample Input 4
6
11
11
16
Regarding the first example, the minimum time to complete only the first request is 4 seconds. All the two requests can be completed within 4 seconds too. See the below figure.
Extracted Specification
An integer \(N\) (2 ≤ \(N\) ≤ 10^5), representing some quantity or size.
An integer \(Q\) (1 ≤ \(Q\) ≤ 10^5), representing the number of requests.
A list of \(Q\) tuples, each containing three integers \(a\), \(b\), and \(p\):
- \(a\) (1 ≤ \(a\) < \(b\) ≤ \(N\)), representing a starting point.
- \(b\) (1 ≤ \(a\) < \(b\) ≤ \(N\)), representing an ending point.
- \(p\) (1 ≤ \(p\) ≤ 10^9), representing a quantity or count.
### Example Input:
```
5 2
1 4 1
2 3 1
```
### Function Signature:
Write a function f(N, Q, requests) that takes in the input.
def f(N: int, Q: int, requests: List[Tuple[int, int, int]]):
'''
N: an integer
Q: an integer
requests: a list of tuples, each containing three integers
'''
Test Case Generator
Sure, I can write a test case generator for the "Conveyor Belt" problem. The generator will produce random values for \(N\) (the number of positions on the conveyor belt) and \(Q\) (the number of delivery requests). Each delivery request will include start position \(a\), end position \(b\), and the number of products \(p\) to be delivered. Here's the Python code for the test case generator:
```python
import random
def generate_test_case():
# Number of positions on the conveyor belt (2 ≤ N ≤ 10^5)
N = random.randint(2, 10**5)
# Number of delivery requests (1 ≤ Q ≤ 10^5)
Q = random.randint(1, 10**5)
test_case = f"{N} {Q}\n"
for _ in range(Q):
# Start position (1 ≤ a < b ≤ N)
a = random.randint(1, N - 1)
b = random.randint(a + 1, N)
# Number of products to deliver (1 ≤ p ≤ 10^9)
p = random.randint(1, 10**9)
test_case += f"{a} {b} {p}\n"
return test_case
# Example usage
print(generate_test_case())
```
This function will generate a string representing a valid test case for the problem. The output can be copied and pasted into a file or used directly in a testing framework. Each call to `generate_test_case` will produce different random values within the specified constraints.
Feel free to adjust the randomness or constraints if you have specific scenarios in mind for testing.
Extract Arguments
def extract_arguments(fh):
first_line = fh.readline().strip().split()
N = int(first_line[0])
Q = int(first_line[1])
requests = []
for _ in range(Q):
request = tuple(map(int, fh.readline().strip().split()))
requests.append(request)
return N, Q, requests
# if __name__ == "__main__":
# input_path = sys.argv[1]
# with open(input_path, 'r') as fh:
# N, Q, requests = extract_arguments(fh)
# f(N, Q, requests)