Problem:
Score : 700 points

Problem Statement

We 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

Inputs

Input is given from Standard Input in the following format:

N
P_2 P_3 ... P_N
X_1 X_2 ... X_N

Outputs

If it is possible to allocate colors and weights to the vertices so that the condition is satisfied, print POSSIBLE; otherwise, print IMPOSSIBLE.

Sample Input 1

3
1 1
4 3 2

Sample Output 1

POSSIBLE

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 2

3
1 2
1 2 3

Sample Output 2

IMPOSSIBLE

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 3

8
1 1 1 3 4 5 5
4 1 6 2 2 1 3 3

Sample Output 3

POSSIBLE

Sample Input 4

1

0

Sample Output 4

POSSIBLE

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()

const int INF = 1e9;

inline void chmin(int &x, int y)
{
	if (x > y) x = y;
}

int N;
int dp[1010];
int p[1010];
vi g[1010];
int x[1010];
int dp2[2][5010];

int main() {
	cin >> N;
	rep(i, N) dp[i] = INF;

	rep(i, N-1) {
		cin >> p[i+1];
		--p[i+1];
		g[p[i+1]].pb(i + 1);
	}

	rep(i, N) cin >> x[i];

	for (int i = N-1; i >= 0; --i) {
		if (g[i].size() == 0) {
			dp[i] = 0;
		} else {
			rep(j, 5010) dp2[0][j] = dp2[1][j] = INF;

			int c = 0, f = 1;

			int to0 = g[i][0];
			dp2[c][x[to0]] = dp[to0];

			if (dp[to0] < 5010) {
				chmin(dp2[c][dp[to0]], x[to0]);
			}

			for (int j = 1; j < g[i].size(); ++j) {
				int to = g[i][j];
				rep(k, 5010) dp2[f][k] = INF;

				//use
				rep(k, 5010) if (dp2[c][k] != INF) {
						//same
					int u = k + x[to], v = dp2[c][k] + dp[to];
					if (u > v) swap(u, v);
					if (u < 5010) {
						chmin(dp2[f][u], v);
					}

					u = k + dp[to], v = dp2[c][k] + x[to];

					if (u > v) swap(u, v);
						//reverse
					if (u < 5010) {
						chmin(dp2[f][u], v);
					}
				}
				
				swap(c, f);
			}

			rep(k, 5010) {
				if (k <= x[i]) {
					chmin(dp[i], dp2[c][k]);
				}

				if (dp2[c][k] <= x[i]) {
					chmin(dp[i], k);
				}
			}
		}
		//cout << i << "= " << dp[i] << endl;
	}

	puts(dp[0] != INF ? "POSSIBLE" : "IMPOSSIBLE");
	
	return 0;
}