Orig Description
Problem StatementWe have planted $N$ flower seeds, all of which come into different flowers.
We want to make all the flowers come out together.
Each plant has a value called vitality, which is initially zero.
Watering and spreading fertilizers cause changes on it, and the $i$-th plant will come into flower if its vitality is equal to or greater than $\mathit{th}_i$.
Note that $\mathit{th}_i$ may be negative because some flowers require no additional nutrition.
Watering effects on all the plants.
Watering the plants with $W$ liters of water changes the vitality of the $i$-th plant by $W \times \mathit{vw}_i$ for all $i$ ($1 \le i \le n$), and costs $W \times \mathit{pw}$ yen, where $W$ need not be an integer.
$\mathit{vw}_i$ may be negative because some flowers hate water.
We have $N$ kinds of fertilizers, and the $i$-th fertilizer effects only on the $i$-th plant.
Spreading $F_i$ kilograms of the $i$-th fertilizer changes the vitality of the $i$-th plant by $F_i \times \mathit{vf}_i$, and costs $F_i \times \mathit{pf}_i$ yen, where $F_i$ need not be an integer as well.
Each fertilizer is specially made for the corresponding plant, therefore $\mathit{vf}_i$ is guaranteed to be positive.
Of course, we also want to minimize the cost.
Formally, our purpose is described as "to minimize $W \times \mathit{pw} + \sum_{i=1}^{N}(F_i \times \mathit{pf}_i)$ under $W \times \mathit{vw}_i + F_i \times \mathit{vf}_i \ge \mathit{th}_i$, $W \ge 0$, and $F_i \ge 0$ for all $i$ ($1 \le i \le N$)".
Your task is to calculate the minimum cost.
Input
The input consists of multiple datasets.
The number of datasets does not exceed $100$, and the data size of the input does not exceed $20\mathrm{MB}$.
Each dataset is formatted as follows.
$N$$\mathit{pw}$$\mathit{vw}_1$ $\mathit{pf}_1$ $\mathit{vf}_1$ $\mathit{th}_1$::$\mathit{vw}_N$ $\mathit{pf}_N$ $\mathit{vf}_N$ $\mathit{th}_N$
The first line of a dataset contains a single integer $N$, number of flower seeds.
The second line of a dataset contains a single integer $\mathit{pw}$, cost of watering one liter.
Each of the following $N$ lines describes a flower. The $i$-th line contains four integers, $\mathit{vw}_i$, $\mathit{pf}_i$, $\mathit{vf}_i$, and $\mathit{th}_i$, separated by a space.
You can assume that $1 \le N \le 10^5$, $1 \le \mathit{pw} \le 100$, $-100 \le \mathit{vw}_i \le 100$, $1 \le \mathit{pf}_i \le 100$, $1 \le \mathit{vf}_i \le 100$, and $-100 \le \mathit{th}_i \le 100$.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output a line containing the minimum cost to make all the flowers come out.
The output must have an absolute or relative error at most $10^{-4}$.
Sample Input
3
10
4 3 4 10
5 4 5 20
6 5 6 30
3
7
-4 3 4 -10
5 4 5 20
6 5 6 30
3
1
-4 3 4 -10
-5 4 5 -20
6 5 6 30
3
10
-4 3 4 -10
-5 4 5 -20
-6 5 6 -30
0
Output for the Sample Input
43.5
36
13.5
0
Extracted Specification
An integer N (1 ≤ N ≤ 10^5), representing some quantity or size.
An integer pw (1 ≤ pw ≤ 100), representing some cost per unit.
N lines follow, each containing four integers:
- vw_i (-100 ≤ vw_i ≤ 100)
- pf_i (1 ≤ pf_i ≤ 100)
- vf_i (1 ≤ vf_i ≤ 100)
- th_i (-100 ≤ th_i ≤ 100)
The input consists of multiple datasets. The end of the input is indicated by a line containing a zero.
### Example Input:
```
3
10
4 3 4 10
5 4 5 20
6 5 6 30
3
7
-4 3 4 -10
5 4 5 20
6 5 6 30
0
```
### Function Signature:
Write a function f(inputs) that takes in the input.
def f(inputs: List[Tuple[int, int, List[Tuple[int, int, int, int]]]]):
'''
inputs: a list of tuples, where each tuple consists of:
- an integer N
- an integer pw
- a list of N tuples, each containing four integers (vw_i, pf_i, vf_i, th_i)
'''
Test Case Generator
Sure! A test case generator for the given problem statement could look like the following. This Python function will randomly generate valid input data sets according to the constraints provided in the problem statement.
```python
import random
def tcgen():
# Generate a number of datasets
num_datasets = random.randint(1, 100)
datasets = []
for _ in range(num_datasets):
# Generate N
N = random.randint(1, 10**5)
# Generate pw
pw = random.randint(1, 100)
# Generate flower data
flowers = []
for _ in range(N):
vw = random.randint(-100, 100)
pf = random.randint(1, 100)
vf = random.randint(1, 100)
th = random.randint(-100, 100)
flowers.append((vw, pf, vf, th))
# Append the dataset
datasets.append((N, pw, flowers))
# End of input indicated by a zero
datasets.append(0)
return datasets
def format_datasets(datasets):
lines = []
for dataset in datasets:
if dataset == 0:
lines.append("0")
else:
N, pw, flowers = dataset
lines.append(str(N))
lines.append(str(pw))
for vw, pf, vf, th in flowers:
lines.append(f"{vw} {pf} {vf} {th}")
return "\n".join(lines)
# Generate the test cases
datasets = tcgen()
formatted_datasets = format_datasets(datasets)
print(formatted_datasets)
```
This function `tcgen` generates a random number of datasets, each with parameters \(N\), \(pw\), and a list of tuples representing the values \(\mathit{vw}_i\), \(\mathit{pf}_i\), \(\mathit{vf}_i\), and \(\mathit{th}_i\). The `format_datasets` function is used to format these datasets into the required input format for the problem statement.
You can run `print(formatted_datasets)` to see a sample of generated test cases formatted as specified in the problem statement.
Extract Arguments
def extract_arguments(fh):
datasets = []
while True:
N = int(fh.readline().strip())
if N == 0:
break
pw = int(fh.readline().strip())
plants = []
for _ in range(N):
vw, pf, vf, th = map(int, fh.readline().strip().split())
plants.append((vw, pf, vf, th))
datasets.append((N, pw, plants))
return datasets
# if __name__ == "__main__":
# input_path = sys.argv[1]
# with open(input_path, 'r') as fh:
# datasets = extract_arguments(fh)
# for dataset in datasets:
# f(*dataset)