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 ≤ 1,000), representing some quantity or size.
A list of integers P of size N-1, where each integer is between 1 and its index (1 ≤ P[i] ≤ i).
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.
```python
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
Sure, I can help you write a test case generator for the problem statement you provided. This generator will create random inputs that respect the constraints of the problem.
Here is the code for the test case generator:
```python
import random
def tcgen():
N = random.randint(1, 1000) # Generate a random integer N (1 ≤ N ≤ 1000)
if N == 1:
P = []
else:
P = [random.randint(1, i - 1) for i in range(2, N + 1)] # Generate P_2, P_3, ..., P_N
X = [random.randint(0, 5000) for _ in range(N)] # Generate X_1, X_2, ..., X_N
return N, P, X
def print_test_case(N, P, X):
print(N)
if P:
print(' '.join(map(str, P)))
print(' '.join(map(str, X)))
# Example usage:
N, P, X = tcgen()
print_test_case(N, P, X)
```
This code will generate random test cases within the constraints specified in the problem statement. Here's a brief explanation of each part:
1. **N**: The number of vertices is chosen randomly between 1 and 1000.
2. **P**: The parent vertices are chosen to ensure that each vertex \(i\) (2 ≤ i ≤ N) has a parent in the range \([1, i-1]\).
3. **X**: The sequence \(X\) is generated with values between 0 and 5000.
The `print_test_case` function is a helper function to format and print the generated test case.
You can call `tcgen()` to generate a new test case and use `print_test_case(N, P, X)` to print it in the required format.
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