Problem p03603 - Generation 1

Orig Description

Score : 700 points
Problem StatementWe have a tree with N vertices. Vertex 1 is the root of the tree, and the parent of Vertex i (2 \leq i \leq N) is Vertex P_i.
To each vertex in the tree, Snuke will allocate a color, either black or white, and a non-negative integer weight.
Snuke has a favorite integer sequence, X_1, X_2, ..., X_N, so he wants to allocate colors and weights so that the following condition is satisfied for all v.
The total weight of the vertices with the same color as v among the vertices contained in the subtree whose root is v, is X_v.
Here, the subtree whose root is v is the tree consisting of Vertex v and all of its descendants.
Determine whether it is possible to allocate colors and weights in this way.
Constraints
1 \leq N \leq 1 000
1 \leq P_i \leq i - 1
0 \leq X_i \leq 5 000
InputsInput is given from Standard Input in the following format:
N
P_2 P_3 ... P_N
X_1 X_2 ... X_N
OutputsIf it is possible to allocate colors and weights to the vertices so that the condition is satisfied, print POSSIBLE; otherwise, print IMPOSSIBLE.
Sample Input 13
1 1
4 3 2
Sample Output 1POSSIBLE
For example, the following allocation satisfies the condition:
Set the color of Vertex 1 to white and its weight to 2.
Set the color of Vertex 2 to black and its weight to 3.
Set the color of Vertex 3 to white and its weight to 2.
There are also other possible allocations.
Sample Input 23
1 2
1 2 3
Sample Output 2IMPOSSIBLE
If the same color is allocated to Vertex 2 and Vertex 3, Vertex 2 cannot be allocated a non-negative weight.
If different colors are allocated to Vertex 2 and 3, no matter which color is allocated to Vertex 1, it cannot be allocated a non-negative weight.
Thus, there exists no allocation of colors and weights that satisfies the condition.
Sample Input 38
1 1 1 3 4 5 5
4 1 6 2 2 1 3 3
Sample Output 3POSSIBLE
Sample Input 41
0
Sample Output 4POSSIBLE

Extracted Specification

An integer N (1 ≤ N ≤ 1000), representing some quantity or size.
A list of integers P of size N-1, where each integer is between 1 and N-1.
A list of integers X of size N, where each integer is between 0 and 5000.

### Example Input:

```
3
1 1
4 3 2
```

### Function Signature:
Write a function f(N, P, X) that takes in the input.
def f(N: int, P: List[int], X: List[int]):
    '''
    N: an integer
    P: a list of integers
    X: a list of integers
    '''

Test Case Generator

Certainly! Here is the test case generator for the given problem statement:

```python
import random

def tcgen():
    # Generate the number of vertices N
    N = random.randint(1, 1000)
    
    # Generate the parent array P for vertices 2 to N
    if N > 1:
        P = [random.randint(1, i - 1) for i in range(2, N + 1)]
    else:
        P = []
    
    # Generate the favorite sequence X
    X = [random.randint(0, 5000) for _ in range(N)]
    
    return N, P, X

def format_test_case(N, P, X):
    output = f"{N}\n"
    if P:
        output += " ".join(map(str, P)) + "\n"
    output += " ".join(map(str, X)) + "\n"
    
    return output

# Example of generating and formatting a test case
N, P, X = tcgen()
formatted_test_case = format_test_case(N, P, X)
print(formatted_test_case)
```

### Explanation:
1. **Number of Vertices (N)**: A random integer between 1 and 1000 is generated for the number of vertices.
2. **Parent Array (P)**: For vertices 2 to N, random parent indices are generated such that each parent index `P_i` satisfies \(1 \leq P_i \leq i - 1\).
3. **Favorite Sequence (X)**: An array of size N is created with random non-negative integers between 0 and 5000.
4. **Formatting**: The generated numbers are formatted into a string as specified in the problem statement.

This generator produces random test cases that adhere to the constraints and input format of the problem.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    P = list(map(int, fh.readline().strip().split()))
    X = list(map(int, fh.readline().strip().split()))
    return N, P, X

# if __name__ == "__main__":
#     import sys
#     input_path = sys.argv[1]
#     with open(input_path, 'r') as fh:
#         N, P, X = extract_arguments(fh)
#         f(N, P, X)