牛客网Wannafly挑战赛14 C可达性 SCC + 缩点

题目链接：可达性

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述 

给出一个 0 ≤ N ≤ 10 5 点数、0 ≤ M ≤ 10 5 边数的有向图，
输出一个尽可能小的点集，使得从这些点出发能够到达任意一点，如果有多个这样的集合，输出这些集合升序排序后字典序最小的。

输入描述:

第一行为两个整数 1 ≤ n, m ≤ 105，
接下来 M 行，每行两个整数 1 ≤ u, v ≤ 105 表示从点 u 至点 v 有一条有向边。
数据保证没有重边、自环。

输出描述:

第一行输出一个整数 z，表示作为答案的点集的大小；
第二行输出 z 个整数，升序排序，表示作为答案的点集。

示例1

输入

7 10
4 5
5 1
2 5
6 5
7 2
4 2
1 2
5 3
3 5
3 6

输出

2
4 7

题意：题意已经很明确了，看题就可以了，2333。

题解：SCC+缩点，因为题中说的是一个点集里的点能够到达任意一点，所以先进行tarjan求强联通分量，对于处于一个强联通

分量里的点进行缩点操作，然后统计缩点后入度为0的点，并加入到答案的点集里，最后输出即可。

如图所示：

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5 + 7;
const int INF = 0x3f3f3f3f;

int n,m,tot,idx,head[maxn],low[maxn],dfn[maxn];
bool vis[maxn];
int num;
int in[maxn];
int res[maxn];
int blong[maxn];

queue <int> ans;
stack <int> s;

void init(){
    memset(head,-1,sizeof(head));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(res,INF,sizeof(res));
    memset(vis,false,sizeof(vis));
    memset(blong,0,sizeof(blong));
    tot=idx=num=0;
    while(!ans.empty()) ans.pop();
    while(!s.empty()) s.pop();
}

struct node{
    int to,nxt;
    node(){}
    node(int _to,int _nxt):to(_to),nxt(_nxt){}
}e[maxn<<1];

void addedge(int u,int v){
    e[tot]=node(v,head[u]);
    head[u]=tot++;
}

void tarjan(int u){
    low[u]=dfn[u]=++idx;
    vis[u]=true;
    s.push(u);
    for(int i=head[u];~i;i=e[i].nxt){
        int v=e[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(vis[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u]){//对于处于同一强联通分量里的点进行缩点操作
        ++num;
        int cnt=0;
        int now=0;
        while(now!=u){
            now=s.top();
            s.pop();
            cnt++;
            blong[now]=num;//belong[now]代表now点在编号为num的联通块
            vis[now]=false;
        }
    }
}

int main(){
    init();
    cin >> n >> m;
    for(int i=1;i<=m;i++){
        int u,v;
        cin >> u >> v;
        addedge(u,v);
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            tarjan(i);
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=head[i];~j;j=e[j].nxt){
            int v=e[j].to;
            if(blong[v]!=blong[i]){//若不在同一强连通分量里，则统计缩点后的入度
                in[blong[v]]++;
            }
        }
    }
    for(int i=1;i<=n;i++)
        res[blong[i]]=min(res[blong[i]],i);//若缩点后只有一个点单独成一个分量，则res保存了这个点的信息
    for(int i=1;i<=num;i++){
        if(in[i]==0){
            ans.push(res[i]);//统计答案
        }
    }
    cout << ans.size() << endl;
    cout << ans.front();
    ans.pop();
    while(!ans.empty()){
        cout << " " << ans.front();
        ans.pop();
    }
    return 0;
}