#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
struct Tree {
  vector<vector<int> > anc;
  vector<vector<int> > cost;
  vector<int> T, X;
  vector<int> depth;
  vector<bool> vis;
  int n;
  int root;
  Tree(int N = 1e5, int r = 1) {
    n = N + 5;
    root = r;
    anc = vector<vector<int> >(18, vector<int>(n, 0));
    depth = vector<int>(n, 0);
    vis = vector<bool>(n, false);
    X = T = vector<int>(n, 0);
    init(root, -1);
    for (int d = 1; d < 18; d++) {
      for (int x = 0; x < n; x++) {
        anc[d][x] = anc[d - 1][anc[d - 1][x]];
      }
    }
  }
  void init(int x, int pre) {
    static int t = 0;
    T[x] = t++;
    for (int i = 0; i < adj[x].size(); i++) {
      int y = adj[x][i];
      if (y == pre) continue;
      anc[0][y] = x;
      depth[y] = depth[x] + 1;
      init(y, x);
    }
    X[x] = t++;
  }
  int LCA(int x, int y) {
    if (depth[x] < depth[y]) swap(x, y);
    for (int w = (1 << 17), d = 17; d >= 0; w /= 2, d--) {
      if (depth[x] - depth[y] >= w) {
        x = anc[d][x];
      }
    }
    if (x == y) return x;
    for (int i = 17; i >= 0; i--) {
      if (anc[i][x] != anc[i][y]) {
        x = anc[i][x];
        y = anc[i][y];
      }
    }
    return anc[0][x];
  }
  int up(int x, int k) {
    for (int w = (1 << 17), d = 17; d >= 0; w /= 2, d--) {
      if (k >= w) {
        x = anc[d][x];
        k -= w;
      }
    }
    return x;
  }
  int dist(int x, int y) {
    int l = LCA(x, y);
    return depth[x] + depth[y] - 2 * depth[l];
  }
  bool isparent(int x, int y) { return LCA(x, y) == x; }
} A;
vector<int> aux[100005];
vector<int> event(100005);
vector<int> val(100005), resv;
vector<bool> out(100005, false), tmp(100005, false);
int n, m, sq, s;
int ans = 0, lans = 0;
vector<int> temp;
vector<int> anc(100005, 0);
int root = 1;
vector<pair<int, int> > edge[100005];
vector<int> lazy(100005, 0);
vector<pair<int, int> > ptr(100005, {0, 0});
void compress(int b) {
  for (auto x : temp) {
    aux[x].clear();
    lazy[x] = 0;
    ptr[x] = {0, 0};
    edge[x].clear();
    anc[x] = 0;
    tmp[x] = false;
  }
  temp.clear();
  temp.push_back(1);
  for (int i = b * sq; i < (b + 1) * sq && i < m; i++) {
    temp.push_back(abs(event[i]));
  }
  sort((temp).begin(), (temp).end(),
       [&](int x, int y) { return A.T[x] < A.T[y]; });
  int ss = ((int)(temp).size());
  for (int i = 1; i < ss; i++) {
    temp.push_back(A.LCA(temp[i - 1], temp[i]));
  }
  sort((temp).begin(), (temp).end(),
       [&](int x, int y) { return A.T[x] < A.T[y]; });
  for (auto x : temp) tmp[x] = true;
  stack<int> st;
  root = 1;
  for (auto x : temp) {
    while (!st.empty() && A.X[st.top()] < A.T[x]) st.pop();
    if (!st.empty() && st.top() != x) {
      aux[x].push_back(st.top());
      aux[st.top()].push_back(x);
      anc[x] = st.top();
      int l = A.anc[0][x];
      map<int, int> cnt;
      while (l != st.top()) {
        if (!out[l]) cnt[val[l]]++;
        l = A.anc[0][l];
      }
      for (auto itr : cnt) edge[x].push_back({itr.first, itr.second});
      for (int i = 0; i < ((int)(edge[x]).size()); i++) {
        if (edge[x][i].first < 0)
          ptr[x] = {ptr[x].first + 1, ptr[x].second + edge[x][i].second};
        else
          break;
      }
    }
    st.push(x);
  }
}
int currTree(int x, int pre) {
  int v = 0;
  if (out[x]) v--;
  for (auto y : adj[x]) {
    if (y == pre) continue;
    v += currTree(y, x);
  }
  val[x] += v;
  return v;
}
bool stat(int x, int pre) {
  bool down = false;
  if (tmp[x]) down = true;
  for (auto y : adj[x]) {
    if (y == pre) continue;
    down |= stat(y, x);
  }
  if (!down) {
    if (!out[x] && val[x] < 0) lans++;
  }
  return down;
}
void update(int x, int v) {}
int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cin >> n >> m;
  for (int i = 2; i <= n; i++) {
    int p;
    cin >> p;
    adj[p].push_back(i);
    adj[i].push_back(p);
  }
  A = Tree();
  for (int i = 1; i <= n; i++) cin >> val[i];
  resv = val;
  for (int i = 0; i < m; i++) cin >> event[i];
  sq = 460;
  s = (m - 1) / sq + 1;
  for (int b = 0; b < s; b++) {
    compress(b);
    lans = 0;
    stat(1, 0);
    for (int i = b * sq; i < (b + 1) * sq && i < m; i++) {
      if (event[i] < 0)
        out[-event[i]] = false;
      else
        out[event[i]] = true;
      int p = abs(event[i]);
      int v = abs(event[i]) / event[i];
      while (p != 0) {
        lazy[p] += v;
        val[p] -= v;
        while (ptr[p].first > 0 && edge[p][ptr[p].first - 1].first >= lazy[p])
          ptr[p] = {ptr[p].first - 1,
                    ptr[p].second - edge[p][ptr[p].first - 1].second};
        while (ptr[p].first < ((int)(edge[p]).size()) &&
               edge[p][ptr[p].first].first < lazy[p])
          ptr[p] = {ptr[p].first + 1,
                    ptr[p].second + edge[p][ptr[p].first].second};
        p = anc[p];
      }
      ans = 0;
      int l = -1;
      for (auto x : temp) {
        if (x == l) continue;
        ans += ptr[x].second;
        if (!out[x] && val[x] < 0) ans++;
        l = x;
      }
      cout << lans + ans << ' ';
    }
    val = resv;
    currTree(1, 0);
  }
  cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
}
