#include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define MP make_pair
#define all(x) x.begin(),x.end()
#define Hagry ios::sync_with_stdio(false);cout.tie(NULL);cin.tie(NULL);

using namespace std;
using ll = long long;
using pi = pair<int, int>;
using vi = vector<int>;
using vpi = vector <pair<int, int>>;
using vvi = vector <vector<int>>;

const int OO = 1e9 + 5;
const int N = 2e5 + 5;
struct DSU {
    int n, comps;
    vector<int> sz, par;

    DSU(int n) {
        this->n = n;
        comps = n;
        sz.resize(n + 1);
        par.resize(n + 1);
        for (int i = 1; i <= n; ++i) {
            sz[i] = 1;
            par[i] = i;
        }
    }

    int find(int x) {
        if (par[x] == x) return x;
        return find(par[x]);
    }

    bool unite(int a, int b) {
        a = find(a), b = find(b);
        if (a == b) return false;
        if (sz[a] < sz[b]) swap(a, b);
        par[b] = a;
        sz[a] += sz[b];
        comps--;
        return true;
    }
};


#define rep(aa, bb, cc) for(int aa = bb; aa < cc;aa++)
struct Dinic {
    struct Edge {
        int to, rev,idx;
        ll c, oc;
        ll flow() { return max(oc - c, 0LL); } // if you need flows
    };
    vi lvl, ptr, q;
    vector<vector<Edge>> adj;
    Dinic(int n) : lvl(n), ptr(n), q(n), adj(n) {}
    void addEdge(int a, int b, ll c, ll rcap = 0) {
        adj[a].push_back({b, (int)adj[b].size(),1, c, c});
        adj[b].push_back({a, (int)adj[a].size() - 1,-1, rcap, rcap});
    }
    ll dfs(int v, int t, ll f) {
        if (v == t || !f) return f;
        for (int& i = ptr[v]; i < (int)adj[v].size(); i++) {
            Edge& e = adj[v][i];
            if (lvl[e.to] == lvl[v] + 1)
                if (ll p = dfs(e.to, t, min(f, e.c))) {
                    e.c -= p, adj[e.to][e.rev].c += p;
                    return p;
                }
        }
        return 0;
    }
    ll calc(int s, int t) {
        ll flow = 0; q[0] = s;
        rep(L,0,31) do { // 'int L=30' maybe faster for random data
                lvl = ptr = vi((int)q.size());
                int qi = 0, qe = lvl[s] = 1;
                while (qi < qe && !lvl[t]) {
                    int v = q[qi++];
                    for (Edge e : adj[v])
                        if (!lvl[e.to] && e.c >> (30 - L))
                            q[qe++] = e.to, lvl[e.to] = lvl[v] + 1;
                }
                while (ll p = dfs(s, t, LLONG_MAX)) flow += p;
            } while (lvl[t]);
        return flow;
    }
    bool leftOfMinCut(int a) { return lvl[a] != 0; }
};


void TC(){
    int n, m;
    cin >> n >> m;

    vector<pi> pos(m+1);
    DSU dsu(m);

    int src = 0, sink = 2*n+1;
    Dinic dinic(sink+1);
    for(int i=1; i<=m; ++i){
        cin >> pos[i].F >> pos[i].S;
        dinic.addEdge(pos[i].F, n + pos[i].S, 1);
    }
    for(int i=1;i<=n; ++i){
        dinic.addEdge(src, i, 1);
        dinic.addEdge(n+i, sink,1);
    }

    for(int i=1; i<=m; ++i){
        for(int j=1; j<i; ++j){
            if(pos[i].F == pos[j].F || pos[i].S == pos[j].S)
                dsu.unite(i, j);
        }
    }


    int ans = m - dinic.calc(src ,sink);
    cout << ans << " ";
    cout << m - dsu.comps;
}

int32_t main() {
#ifndef ONLINE_JUDGE
    freopen("input.in", "r", stdin); freopen("output.out", "w", stdout);
#endif
    Hagry
    int t = 1;
//    cin >> t;
    while (t--) {
        TC();
        cout << '\n';
    }
    return 0;
}