目录

Description

有 \(n\) 本书，每一本书都有一本先导书，从 \(1\) 到 \(n\) 顺序阅读这些书，想要理解一本书，就必须将先导书看完，求阅读这 \(n\) 本书最少多少遍才可以完全理解这 \(n\) 本书

State

\(1<=T<=2*10^4\)

\(1<=N<=2*10^5\)

\(0<=k<=n-1\)

Input 

5
4
1 2
0
2 1 4
1 2
5
1 5
1 1
1 2
1 3
1 4
5
0
0
2 1 2
1 2
2 2 1
4
2 2 3
0
0
2 3 2
5
1 2
1 3
1 4
1 5
0

Output 

2
-1
1
2
5

Solution

利用拓扑排序可以判断出这 \(n\) 本书是否可以全部理解

那么如何求需要阅读这 \(n\) 本书几遍呢？可以利用 \(dp\) 的知识，\(dp[i]\) 表示，理解第 \(i\) 本书最少需要的阅读次数，那么 \(dp[i]=max(dp[j]+k)\)，其中 \(j\) 为 \(i\) 的前驱节点，而 \(k=(j>i)\) ，这样就可以解决了；（感谢 MOOONI​ ）

但是从上述分析发现，我们只需要最大的那个前驱，所以可以利用小根堆，贪心就可以了

Code 

const int N = 2e5 + 5;

    int n, m, _, k;
    int a[N];
    vector<int> v[N];
    int into[N];

int topsort()
{
    priority_queue<pii, vector<pii>, greater<pii>> q;
    int cnt = 0, ans = 1;
    for(int i = 1; i <= n; i ++){
        if(into[i] == 0) q.push({1, i}), cnt ++;
    }
    while(q.empty() == 0){
        int u = q.top().se;
        ans = q.top().fi;
        q.pop();
        for(auto it : v[u]){
            into[it] --;
            if(into[it] == 0){
                cnt ++;
                if(it < u) q.push({ans + 1, it});
                else q.push({ans, it});
            }
        }
    }
    if(cnt == n) return ans;
    return -1;
}

signed main()
{
    //IOS;
    rush(){
        sd(n);
        rep(i, 1, n){
            sd(k);
            into[i] = k;
            while(k --> 0){
                int x = read();
                v[x].pb(i);
            }
        }
        int ans = topsort();
        pd(ans);
        rep(i, 1, n) v[i].clear();
    }
    //PAUSE;
    return 0;
}