Mr. Kitayuta‘s Technology（dfs,连通块）

链接：https://codeforces.com/problemset/problem/505/D
发现一道有趣的题目
大意：就是连城市的每个点要用最少的路来满足m个条件
给出的条件会把n个点分块 所以可以利用并查集来记录连通在一起的点
可是并查集是体现不了单向边的惹 ->利用vector来记录嘛，就像最小生成树的板子一样
连通块最多有两种可能
①一种是无环的最小生成树形式->n-1
②一种有环->n
所以我们可以用dfs搜索看看有没有重复遍历的点就好
这个地方是一个大糊点！！！

可以设想
1 2
1 3
2 4
3 4
第一次dfs 1->2然后2->4
这个时候没有路了返回
然后1->3,3->4看起来4是遍历了两次 其实都是同一个方向地到达4并不是环哦，所以我们应该有一次更改操作
每一次该点可达的路遍历完后 将该点记录为预览过点而不是可能的回路点，这样子就不会出问题啦!!!这个办法超级赞！！！！

void dfs(int u)
{
    vis[u] = -1;
    for (int i = 0; i < a[u].size(); i++) ///a记录单向边
    {
        int v = a[u][i];
        if (vis[v] == -1) ///搜到环啦
        {
            YES_C[findd(v)] = 1;
            return;
        }
        else if (!vis[v])
        {
            dfs(v);
        }
    }
    vis[u] = 1;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define bug(x) cout << #x << " == " << x << endl;
const ll int MAX_N = 1e5 + 10;
vector<int> a[MAX_N];
int f[MAX_N] = {0}; ///利用并查集建连通块，好好用 got it~
int path[MAX_N] = {0};
int sum[MAX_N] = {0};    ///统计连通块里面有几个城市
int vis[MAX_N] = {0};    ///该点有没有游览过
bool YES_C[MAX_N] = {0}; ///连通块是不是环
int findd(int x)
{
    if (f[x] == x)
        return x;
    else
        return findd(f[x]);
}
inline void unite(int x, int y)
{
    int fx = findd(x);
    int fy = findd(y);
    if (fx != fy)
    {
        if (path[fx] < path[fy])
        {
            f[fx] = fy;
        }
        else
        {
            f[fy] = fx;
            if (path[fx] == path[fy])
            {
                path[fx]++;
            }
        }
    }
}
void dfs(int u)
{
    vis[u] = -1;
    for (int i = 0; i < a[u].size(); i++) ///a记录单向边
    {
        int v = a[u][i];
        if (vis[v] == -1) ///搜到环啦
        {
            YES_C[findd(v)] = 1;
            return;
        }
        else if (!vis[v])
        {
            dfs(v);
        }
    }
    vis[u] = 1;
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; i++)
        f[i] = i;
    for (int i = 1; i <= m; i++)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        a[u].push_back(v);
        unite(u, v);
    }
    for (int i = 1; i <= n; i++)
    {
        sum[findd(i)]++;
        if (!vis[i])
        {
            dfs(i); ///搜它！
        }
    }

    ll tot = 0;
    for (int i = 1; i <= n; i++)
    {
        if (findd(i) == i) ///并查集的头
        {
            if (YES_C[f[i]])
            {
                tot += sum[f[i]]; ///是环的话 n条边一定所有点可达
            }
            else
            {
                tot += (sum[f[i]] - 1); ///不是环 就相当于是最小生成树n-1
            }
        }
    }
    printf("%lld\n", tot);
}