#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

#ifdef _WIN32
using uint = unsigned;
#endif
using db = long double;

constexpr int N = 2e5 + 9;
int n, a[N], p[N], sz[N], son[N];
vi g[N];

int tot, rt[N];

#define ls(p) t[p].ch[0]
#define rs(p) t[p].ch[1]

struct fr {
  int x; LL y;
  bool operator < (const fr &rhs) const {
    return y * rhs.x < rhs.y * x;
  }
  bool operator > (const fr &rhs) const {
    return y * rhs.x > rhs.y * x;
  }
  bool operator <= (const fr &rhs) const {
    return y * rhs.x <= rhs.y * x;
  }
  bool operator >= (const fr &rhs) const {
    return y * rhs.x >= rhs.y * x;
  }
  bool operator == (const fr &rhs) const {
    return y * rhs.x == rhs.y * x;
  }
};

struct {
  fr k;
  int sz, ch[2]; 
  uint p;
} t[N];

int New (fr k) {
  int x = ++tot;
  t[x].k = k;
  t[x].sz = 1;
  t[x].ch[0] = t[x].ch[1] = 0;
  t[x].p = rng();
  return x;
}

void up (int p) {
  t[p].sz = t[ls(p)].sz + t[rs(p)].sz + 1;
}

int merge (int x, int y) {
  if (!x || !y) {
    return x | y;
  }
  if (t[x].p < t[y].p) {
    rs(x) = merge(rs(x), y);
    return up(x), x;
  } else {
    ls(y) = merge(x, ls(y));
    return up(y), y;
  }
}

// x <= k, y > k

void spl_k (int p, fr k, int &x, int &y) {
  if (!p) {
    x = y = 0;
    return;
  }
  if (t[p].k >= k) {
    x = p;
    spl_k(rs(p), k, rs(x), y);
  } else {
    y = p;
    spl_k(ls(p), k, x, ls(y));
  }
  up(p);
}

void spl_sz (int p, int k, int &x, int &y) {
  if (!p) {
    x = y = 0;
    return;
  }
  if (t[ls(p)].sz + 1 <= k) {
    x = p;
    spl_sz(rs(p), k - t[ls(p)].sz - 1, rs(x), y);
  } else {
    y = p;
    spl_sz(ls(p), k, x, ls(y));
  }
  up(p);
}

fr pre (int x) {
  while (ls(x)) {
    x = ls(x);
  }
  return t[x].k;
}

int join (int x, int y) {
  if (!x || !y) {
    return x | y;
  }
  if (t[x].p > t[y].p) {
    swap(x, y);
  }
  int L, R;
  spl_k(y, t[x].k, L, R);
  ls(x) = join(ls(x), L);
  rs(x) = join(rs(x), R);
  return up(x), x;
}

db ans[N];

void dfs (int u) {
  if (son[u]) {
    dfs(son[u]), rt[u] = rt[son[u]];
  }
  for (int v : g[u]) {
    if (v ^ son[u]) {
      dfs(v);
      rt[u] = join(rt[u], rt[v]);
    }
  }
  fr cur = {1, a[u]};
  int thr;
  while (t[rt[u]].sz) {
    fr fst = pre(rt[u]);
    if (cur > fst) {
      break;
    }
    cur.x += fst.x;
    cur.y += fst.y;
    spl_sz(rt[u], 1, thr, rt[u]);
  }
  rt[u] = merge(New(cur), rt[u]);

  ans[u] = cur.y / db(cur.x);
}

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cout << fixed << setprecision(7);
  cin >> n;
  L (i, 2, n) {
    cin >> p[i], g[p[i]].eb(i);
  }
  L (i, 1, n) {
    cin >> a[i];
  }
  R (i, n, 1) {
    sz[i] = 1;
    for (int x : g[i]) {
      sz[i] += sz[x];
      if (sz[x] > sz[son[i]]) {
        son[i] = x;
      }
    }
  }
  dfs(1);
  L (i, 1, n) {
    cout << ans[i] << '\n';
  }
}
// I love WHQ!