#include<bits/stdc++.h>

using i64 = long long;

template<class T>
struct HLD {
    int n;
    std::vector<int> siz, top, parent, in, out, seq;
    std::vector<std::vector<std::pair<int, T>>> adj;
    std::vector<T> len, mx, dep;
    int cur;

    HLD() {}

    HLD(int n_) {
        init(n_);
    }

    void init(int _n) {//初始化
        this->n = _n;
        siz.resize(n);//子树大小
        top.resize(n);//重链的顶端
        dep.resize(n);//深度
        parent.resize(n);//父节点
        in.resize(n);//dfs序入
        out.resize(n);//dfs序出
        seq.resize(n);//记录dfsx序第几位是哪个节点
        mx.resize(n);//记录这条链的最深的深度
        len.resize(n);//这条链的长度
        cur = 0;
        adj.assign(n, {});
    }

    void addEdge(int u, int v, T w = 1) {
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w);
    }

    void work(int root = 1) {
        top[root] = root;
        dep[root] = 0;
        parent[root] = -1;
        dfs1(root);
        len[root] = mx[root];
        dfs2(root, 0);
    }

    void dfs1(int x) {
        for (auto &v: adj[x]) {
            auto [y, w] = v;
            if (y == parent[x]) continue;
            parent[y] = x;
            mx[y] = dep[y] = dep[x] + w;
            dfs1(y);
            if (adj[x][0].first == parent[x] || mx[y] >= mx[adj[x][0].first]) {
                mx[x] = mx[y];
                std::swap(v, adj[x][0]);
            }
        }
    }

    void dfs2(int u, T tw) {
        in[u] = ++cur;
        seq[cur] = u;
        for (auto [v, w]: adj[u]) {
            if (v == parent[u]) continue;
            top[v] = v == adj[u][0].first ? top[u] : v;
            len[v] = v == adj[u][0].first ? len[u] : mx[v] - dep[v];
            dfs2(v, v == adj[u][0].first ? tw : w);
        }
        out[u] = cur;
    }
};

void DAOQI() {
    int n;
    std::cin >> n;
    HLD<int> h(n + 1);
    for (int i = 2; i <= n; i++) {
        int x;
        std::cin >> x;
        h.addEdge(i, x);
    }
    h.work(1);
    std::map<int, int> mp;
    std::set<int> ans1;
    int ans2 = 0;
    for (int i = 1; i <= n; i++) {
        mp[h.top[i]] = h.len[i] + 1;
    }
    std::vector<int> tmp;
    for (auto [v, c]: mp) {
        tmp.push_back(c);
    }
    std::sort(tmp.begin(), tmp.end(), std::greater<>());
    int ans = tmp[0];
    tmp.push_back(0);
    for (int i = 0; i < tmp.size() - 1; i++) {
        ans = std::min({ans, i + 1 + tmp[i + 1]});
    }
    std::cout << ans << "\n";

}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int T = 1;
    std::cin >> T;
    while (T--) DAOQI();
    return 0;
}