Problem p03183 - Generation 1

Orig Description

Score : 100 points
Problem StatementThere are N blocks, numbered 1, 2, \ldots, N.
For each i (1 \leq i \leq N), Block i has a weight of w_i, a solidness of s_i and a value of v_i.
Taro has decided to build a tower by choosing some of the N blocks and stacking them vertically in some order.
Here, the tower must satisfy the following condition:
For each Block i contained in the tower, the sum of the weights of the blocks stacked above it is not greater than s_i.
Find the maximum possible sum of the values of the blocks contained in the tower.
Constraints
All values in input are integers.
1 \leq N \leq 10^3
1 \leq w_i, s_i \leq 10^4
1 \leq v_i \leq 10^9
InputInput is given from Standard Input in the following format:
N
w_1 s_1 v_1
w_2 s_2 v_2
:
w_N s_N v_N
OutputPrint the maximum possible sum of the values of the blocks contained in the tower.
Sample Input 13
2 2 20
2 1 30
3 1 40
Sample Output 150
If Blocks 2, 1 are stacked in this order from top to bottom, this tower will satisfy the condition, with the total value of 30 + 20 = 50.
Sample Input 24
1 2 10
3 1 10
2 4 10
1 6 10
Sample Output 240
Blocks 1, 2, 3, 4 should be stacked in this order from top to bottom.
Sample Input 35
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
1 10000 1000000000
Sample Output 35000000000
The answer may not fit into a 32-bit integer type.
Sample Input 48
9 5 7
6 2 7
5 7 3
7 8 8
1 9 6
3 3 3
4 1 7
4 5 5
Sample Output 422
We should, for example, stack Blocks 5, 6, 8, 4 in this order from top to bottom.

Extracted Specification

An integer N (1 ≤ N ≤ 10^3), representing some quantity or size.
N tuples, each containing three integers:
The first integer in each tuple is between 1 and 10^4.
The second integer in each tuple is between 1 and 10^4.
The third integer in each tuple is between 1 and 10^9.

### Example Input:

```
3
2 2 20
2 1 30
3 1 40
```

### Function Signature:
Write a function f(inputs) that takes in the input.
```python
from typing import List, Tuple

def f(inputs: List[Tuple[int, int, int]]):
    ''' 
    inputs: a list of tuples, each containing three integers
    '''
```

Test Case Generator

Sure! Here's a test case generator for the given problem statement:

```python
import random

def tcgen():
    # Number of blocks
    N = random.randint(1, 10**3)
    
    # Generate each block's weight, solidness, and value
    blocks = []
    for _ in range(N):
        w = random.randint(1, 10**4)
        s = random.randint(1, 10**4)
        v = random.randint(1, 10**9)
        blocks.append((w, s, v))
    
    return N, blocks

def format_test_case(N, blocks):
    # Format the test case for the output
    output = f"{N}\n"
    for w, s, v in blocks:
        output += f"{w} {s} {v}\n"
    return output

# Example of generating and printing a test case
if __name__ == "__main__":
    N, blocks = tcgen()
    test_case = format_test_case(N, blocks)
    print(test_case)
```

### Explanation:
1. **Number of Blocks (N)**: We randomly generate `N` in the range [1, 1000].
2. **Block Properties**: For each block, generate random values for weight (`w`), solidness (`s`), and value (`v`):
  - `w` is in the range [1, 10000].
  - `s` is in the same range [1, 10000].
  - `v` is in the range [1, 10^9].
3. **Formatting**: The `format_test_case` function converts the generated test case into the required input format.

You can run this script to generate random test cases in the format specified by the problem statement.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    blocks = []
    for _ in range(N):
        w, s, v = map(int, fh.readline().strip().split())
        blocks.append((w, s, v))
    return N, blocks