Orig Description
Escape from the Hell
One day, Buddha looked into the hell and found an office worker. He did evil, such as enforcing hard work on his subordinates. However, he made only one good in his life. He refused an unreasonable request from his customer to save the lives of his subordinates. Buddha thought that, as the reward of the good, the office worker should have had a chance to escape from the hell. Buddha took a spider silk and put down to the hell.
The office worker climbed up with the spider silk, however the length of the way $L$ meters was too long to escape one day. He had $N$ energy drinks and drunk one of them each day. The day he drunk the i-th energy drink he could climb $A_i$ meters in the daytime and after that slided down $B_i$ meters in the night. If he could reach at the height greater than or equal to the $L$ meters in the daytime, he could escape without sliding down. After the $N$ days the silk would be cut.
He realized that other sinners climbed the silk in the night. They climbed $C_i$ meters in the $i$-th night without sliding down in the daytime. If they catched up with the office worker, they should have conflicted and the silk would be cut. Therefore he needed to escape before other sinners catched him. Your task is to write a program computing the best order of energy drink and output the earliest day which he could escape. If he could not escape, your program should output -1.
Input
The input consists of a single test case.
$N$ $L$
$A_1$ $B_1$
$A_2$ $B_2$
...
$A_N$ $B_N$
$C_1$
$C_2$
...
$C_N$
The first line contains two integers $N$ ($1 \leq N \leq 10^5$) and $L$ ($1 \leq L \leq 10^9$), which mean the number of energy drinks and the length of the spider silk respectively. The following $N$ lines show the information of the drinks: the $i$-th of them indicates the $i$-th energy drink, he climbed up $A_i$ ($1 \leq A_i \leq 10^9$) meters and slided down $B_i$ ($1 \leq B_i \leq 10^9$) meters. Next $N$ lines show how far other sinners climbed: the $i$-th of them contains an integer $C_i$ ($1 \leq C_i \leq 10^9$), which means they climbed up $C_i$ meters in the $i$-th day.
Output
Print the earliest day which he could escape. If he could not escape, print -1 instead.
Sample Input 1
3 9
6 3
5 2
3 1
2
2
2
Output for the Sample Input 1
2
Sample Input 2
5 20
3 2
4 2
6 3
8 4
10 5
4
2
3
4
5
Output for the Sample Input 2
-1
Sample Input 3
5 20
6 5
7 3
10 3
10 14
4 7
2
5
3
9
2
Output for the Sample Input 3
3
Sample Input 4
4 12
8 4
6 4
2 1
2 1
1
1
4
4
Output for the Sample Input 4
-1
Extracted Specification
An integer N (1 ≤ N ≤ 10^5), representing some quantity or size.
An integer L (1 ≤ L ≤ 10^9), representing some length or distance.
A list of N tuples, each containing two integers (A_i, B_i), where 1 ≤ A_i ≤ 10^9 and 1 ≤ B_i ≤ 10^9.
A list of N integers, each containing one integer C_i, where 1 ≤ C_i ≤ 10^9.
### Example Input:
```
3 9
6 3
5 2
3 1
2
2
2
```
### Function Signature:
Write a function f(N, L, AB, C) that takes in the input.
def f(N: int, L: int, AB: List[Tuple[int, int]], C: List[int]):
'''
N: an integer
L: an integer
AB: a list of tuples
C: a list of integers
'''
Test Case Generator
Sure, I can help you create a test case generator for the "Escape from the Hell" problem. Below is a Python function that generates random test cases for this problem.
```python
import random
def tcgen():
# Generate random values for N and L
N = random.randint(1, 10**5)
L = random.randint(1, 10**9)
# Generate the list of Ai, Bi, and Ci values
A = [random.randint(1, 10**9) for _ in range(N)]
B = [random.randint(1, 10**9) for _ in range(N)]
C = [random.randint(1, 10**9) for _ in range(N)]
# Prepare the input in the required format
input_data = f"{N} {L}\n"
for i in range(N):
input_data += f"{A[i]} {B[i]}\n"
for i in range(N):
input_data += f"{C[i]}\n"
return input_data
# Example usage
print(tcgen())
```
### Explanation:
1. **N and L Generation**:
- `N` is generated randomly between 1 and 100,000 (inclusive).
- `L` is generated randomly between 1 and 1,000,000,000 (inclusive).
2. **A, B, and C Lists Generation**:
- `A` and `B` are lists of length `N` where each element is a random integer between 1 and 1,000,000,000 (inclusive).
- `C` is a list of length `N` where each element is a random integer between 1 and 1,000,000,000 (inclusive).
3. **Input Formatting**:
- The first line of the input is `N L`.
- The next `N` lines contain pairs of `A[i]` and `B[i]`.
- The following `N` lines contain `C[i]`.
This generator ensures that the generated test cases adhere to the problem constraints and are formatted correctly as required by the problem statement. You can run this function to get a new random test case each time.
Extract Arguments
def extract_arguments(fh):
N, L = map(int, fh.readline().strip().split())
A = []
B = []
for _ in range(N):
a, b = map(int, fh.readline().strip().split())
A.append(a)
B.append(b)
C = [int(fh.readline().strip()) for _ in range(N)]
return N, L, A, B, C