#include <bits/stdc++.h>
using namespace std;
#define int long long
#define max_n 5001010
void read(int &p)
{
    p = 0;
    int k = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
        {
            k = -1;
        }
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        p = p * 10 + c - '0';
        c = getchar();
    }
    p *= k;
    return;
}
void write_(int x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x > 9)
    {
        write_(x / 10);
    }
    putchar(x % 10 + '0');
}
void writesp(int x)
{
    write_(x);
    putchar(' ');
}
void writeln(int x)
{
    write_(x);
    putchar('\n');
}
struct node
{
    int to, nxt, flow;
} edge[max_n];
int head[max_n], tot = 1;
void add(int u, int v, int w)
{
    edge[++tot].to = v;
    edge[tot].nxt = head[u];
    edge[tot].flow = w;
    head[u] = tot;

    edge[++tot].to = u;
    edge[tot].nxt = head[v];
    edge[tot].flow = 0;
    head[v] = tot;
}
int n, m;
int S = 1, T;
int dep[max_n], now[max_n];
bool bfs()
{
    for (int i = 1; i <= n; i++)
    {
        dep[i] = 0;
    }
    dep[S] = 1;
    queue<int> que;
    que.push(S);
    now[S] = head[S];
    while (!que.empty())
    {
        int u = que.front();
        // printf("===%lld===\n",u);
        que.pop();
        for (int i = head[u]; i; i = edge[i].nxt)
        {
            int v = edge[i].to;
            // printf("%lld -> %lld\n",u,v);
            if (edge[i].flow && dep[v] == 0)
            {
                now[v] = head[v];
                dep[v] = dep[u] + 1;
                que.push(v);
                if (v == T)
                {
                    return true;
                }
            }
        }
    }
    return false;
}
int dfs(int u, int m_f)
{
    if (u == T || m_f == 0)
    {
        return m_f;
    }
    int fl = 0, as = 0;
    for (int i = now[u]; i; i = edge[i].nxt)
    {
        int v = edge[i].to;
        now[u] = i;
        if ((dep[v] == dep[u] + 1) && edge[i].flow != 0)
        {
            fl = dfs(v, min(m_f, edge[i].flow));
            if (fl)
            {
                edge[i].flow -= fl;
                edge[i ^ 1].flow += fl;
                as += fl;
                m_f -= fl;
            }
        }
    }
    return as;
}
int max_flow = 0;
void dinic()
{
    while (bfs())
    {
        int t = dfs(1, 10000000);
        while (t)
        {
            max_flow += t;
            t = dfs(1, 10000000);
        }
        // writeln(max_flow);
    }
}
signed main()
{
#if _clang_
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
#endif
    read(n), read(m);
    T = n;
    for (int i = 1, u, v, w; i <= m; i++)
    {
        read(u), read(v), read(w);
        add(u, v, w * 1010 + 1);
    }
    dinic();
    writesp(max_flow / 1010), writeln(max_flow % 1010);
    return 0;
}

在线等，挺急的（2关注）