Problem p01704 - Generation 1

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.
An integer pw (1 ≤ pw ≤ 100), representing a cost factor.
N lines each containing four integers: vw_i (-100 ≤ vw_i ≤ 100), pf_i (1 ≤ pf_i ≤ 100), vf_i (1 ≤ vf_i ≤ 100), and th_i (-100 ≤ th_i ≤ 100), representing various properties and thresholds.
Each dataset ends with 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
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
```

### Function Signature:
Write a function f(inputs) that takes in the input.
```python
def f(inputs: List[Tuple[int, int, List[Tuple[int, int, int, int]]]]):
    '''
    inputs: a list of tuples where each tuple contains:
            - 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

Certainly! Below is a Python test case generator function for the given problem statement:

```python
import random

def generate_test_case():
    # Generate a random number of flower seeds within the given constraints
    N = random.randint(1, 10**5)
    
    # Generate a random cost of watering one liter
    pw = random.randint(1, 100)
    
    # Generate the details for each flower
    flowers = []
    for _ in range(N):
        vw_i = random.randint(-100, 100)
        pf_i = random.randint(1, 100)
        vf_i = random.randint(1, 100)
        th_i = random.randint(-100, 100)
        flowers.append((vw_i, pf_i, vf_i, th_i))
    
    # Convert the generated data to the required input format
    input_data = f"{N}\n{pw}\n"
    for vw_i, pf_i, vf_i, th_i in flowers:
        input_data += f"{vw_i} {pf_i} {vf_i} {th_i}\n"
    
    return input_data

# Example usage:
test_case = generate_test_case()
print(test_case)
```

This function generates a single test case following the constraints and format described in the problem statement. You can call the `generate_test_case` function multiple times to create as many datasets as needed for testing.

If you want to generate multiple datasets in a single input, you can modify the function as follows:

```python
def generate_multiple_test_cases(num_datasets):
    datasets = []
    for _ in range(num_datasets):
        datasets.append(generate_test_case())
    
    # Add the termination line '0'
    datasets.append("0")
    
    return "\n".join(datasets)

# Example usage:
num_datasets = 5  # Number of datasets to generate
test_cases = generate_multiple_test_cases(num_datasets)
print(test_cases)
```

This modified function generates multiple datasets and concatenates them, ensuring an end-of-input indicator (`0`). Adjust `num_datasets` to the required number of datasets you wish to generate.

Extract Arguments

def extract_arguments(fh):
    datasets = []
    while True:
        N = int(fh.readline().strip())
        if N == 0:
            break
        pw = int(fh.readline().strip())
        flowers = []
        for _ in range(N):
            vw, pf, vf, th = map(int, fh.readline().strip().split())
            flowers.append((vw, pf, vf, th))
        datasets.append((N, pw, flowers))
    return datasets