CodeForces - 770C

传送门

题目大意：给定n个学科，每个学科的学习会有前驱限制，即学会A，才能学B，现在问要学会若干学科，求最少一共要学多少学科，并求学习的顺序

思路：拓扑

（感觉拓扑就体现在思想上。。。算法上几乎没用到

一般想法是按照题意建图，一条一条链地去建图，然后拓扑排序，然后这里并不是求全部的学科，而是部分的学科，去掉那些无关的学科成了个棘手的点（

换个思路，不妨将学科A和它所有的限制学科去连边，建有向图，反向dfs（从目标学科开始跑），如果存在环，则无解

（感觉拓扑误导人）

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <map>
#include <vector>
#include <queue>
using namespace std;
#define _for(i,a,b) for(int i=(a) ;i<=(b) ;i++)
#define _rep(i,a,b) for(int i=(a) ;i>=(b) ;i--)
#define mst(v,s) memset(v,s,sizeof(v))
#define pb push_back
#define IOS ios::sync_with_stdio(false)
#define int long long
#define all(v) v.begin(),v.end()
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define ls p<<1
#define rs p<<1|1
typedef long long ll;
const int N=2e5+10;
int n,k;
int a[N];
int v[N];
vector <int > order;
struct ty
{
    int t,next;
}edge[N];
int tot;
int head[N];
void addedge(int x, int y)
{
    edge[++tot].t = y;
    edge[tot].next = head[x];
    head[x]=tot;
}
bool dfs(int x)
{
    v[x]=-1;//判环，预访问
    for(int i=head[x] ;i!=0 ;i=edge[i].next)
    {
        int y = edge[i].t;
        if( v[y] == -1 ) return false;//判环
        if( !v[y] && !dfs(y) ) return false;
    }
    v[x]=1;
    order.pb(x);
    return true;
}
bool topu()
{
    _for(i,1,k)
    {
        if( !v[a[i]] && !dfs(a[i]) ) //有环就退出
        return false;
    }
    return true;
}
signed main()
{
    ///!!!
//    freopen("data.txt","r",stdin);
    ///!!!
    IOS;
    cin>>n>>k;
    _for(i,1,k) cin>>a[i];
    _for(i,1,n)
    {
        int x;
        int last=-1;
        cin>>x;
        _for(j,1,x)
        {
            int y;
            cin>>y;
            addedge(i,y);
        }
    }
    if( topu() )
    {
        cout<<order.size()<<endl;
        for(int i=0 ;i<order.size() ;i++) cout<<order[i]<<" ";
        cout<<endl;
    }
    else cout<<-1<<endl;
}