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 (i-1) for 2 ≤ i ≤ N.
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. Here is a Python function that generates random test cases for the problem:
```python
import random
def generate_tree(N):
P = []
for i in range(2, N + 1):
P.append(random.randint(1, i - 1))
return P
def generate_sequence(N):
return [random.randint(0, 5000) for _ in range(N)]
def tcgen():
N = random.randint(1, 1000)
P = generate_tree(N)
X = generate_sequence(N)
return N, P, X
# Example usage
if __name__ == "__main__":
N, P, X = tcgen()
print(N)
if N > 1:
print(" ".join(map(str, P)))
print(" ".join(map(str, X)))
```
### Explanation of the Generator
1. **generate_tree(N)**:
- This function generates the parent array \( P \) with \( N-1 \) values (since \( P \) starts from \( P_2 \) to \( P_N \)).
- For each \( i \) from 2 to \( N \), it appends a random integer between 1 and \( i-1 \) to the \( P \) list, ensuring the tree structure is maintained.
2. **generate_sequence(N)**:
- This function generates the sequence \( X \) with \( N \) integers, each between 0 and 5000.
3. **tcgen()**:
- This function combines the above two helper functions to generate random values for \( N \), \( P \), and \( X \).
- It returns these values to be used as a test case.
4. **Example usage**:
- Demonstrates how to use the `tcgen` function to generate and print a test case.
### Notes:
- The tree is generated such that for each vertex \( i \) (where \( 2 \leq i \leq N \)), its parent \( P_i \) is a vertex from the range [1, \( i-1 \)], ensuring a valid tree structure.
- The weights \( X \) are generated to fall within the specified range [0, 5000].
You can run this script to generate random test cases for the given problem statement.
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