#include <bits/stdc++.h>
using namespace std;

#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define x first
#define y second
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)

typedef long long ll;
typedef double db;
typedef long double LD;
typedef pair<int, int> pii;
typedef pair<db, db> pdd;
typedef pair<ll, ll> pll;

const int N = 1e4 + 47;
vector<int> g[N];
bool vis[N];

void dfs(int v, vector<int> &output)
{
	vis[v] = 1;
	for (int u: g[v])
	{
		if (!vis[u])
			dfs(u, output);
	}
	output.pb(v);
}

void dfs(int v, vector<vector<int>> const& adj, vector<int> &output) 
{
    vis[v] = true;
    for (auto u : adj[v])
        if (!vis[u])
            dfs(u, adj, output);
    output.push_back(v);
}


void scc(int n, vector<vector<int>> &components, vector<vector<int>> &adj_cond)
{
	fill(vis, vis + n, false);
	components.clear(), adj_cond.clear();

    vector<int> order; 

    for (int i = 0; i < n; i++)
        if (!vis[i])
            dfs(i, order);

    vector<vector<int>> adj_rev(n);
    FOR (v, 0, n)
    {
		for (int u : g[v])
            adj_rev[u].push_back(v);
	}

	fill(vis, vis + n, false);
    reverse(all(order));

    vector<int> roots(n, 0);

    for (auto v : order)
        if (!vis[v]) {
            vector<int> component;
            dfs(v, adj_rev, component);
            components.push_back(component);
            int root = *min_element(begin(component), end(component));
            for (auto u : component)
                roots[u] = root;
        }

    adj_cond.assign(n, {});
    for (int v = 0; v < n; v++)
        for (auto u : g[v])
            if (roots[v] != roots[u])
                adj_cond[roots[v]].push_back(roots[u]);
}

int solve()
{
	int n, m;
	if (!(cin >> n >> m))
		return 1;
	
	fill(g, g + N, vector<int>());
	FOR (i, 0, m)
	{
		int s, d;
		cin >> s >> d;
		--s;
		--d;
		g[s].pb(d);
	}
	vector<vector<int>> comps, adj, rev;
	scc(n, comps, adj);
	int nn = sz(comps);
	
	if (nn == 1)
	{
		cout << "0\n";
		return 0;
	}
	
	vector<bool> in(n), out(n);
	FOR (i, 0, n)
	{
		//cerr << "i = " << i << '\n';
		for (int to: adj[i])
		{
			//cerr << to << ' ';
			in[i] = 1;
			out[to] = 1;
		}
		//cerr << '\n';
	}
	
	int ins = count(all(in), true);
	int outs = count(all(out), true);
	int ans = nn - min(ins, outs);
	cout << ans << '\n';
		
	return 0;
}

int32_t main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	
	int TET = 1e9;
	//cin >> TET;
	for (int i = 1; i <= TET; i++)
	{
		if (solve())
		{
			break;
		}
		#ifdef ONPC
			cerr << "_____________________________\n";
		#endif
	}
	#ifdef ONPC
		cerr << "\nfinished in " << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
	#endif
	return 0;
}