#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstring>
 
#define fi first
#define se second
#define mp make_pair
#define pe pair<int, int>
 
using namespace std;

const int MAX_N = 100100;
const int INF = (1 << 29);
vector<pe> A[MAX_N];
vector<int> B[MAX_N];
 
vector<int> C[MAX_N];
 
int comp[MAX_N];
vector<int> Comp[MAX_N];
 
vector<pe> edges;
vector<int> sol;
vector<int> vec;
 
bool viz[MAX_N];
int val[MAX_N];
bool marc[MAX_N];
int sz[MAX_N];


void dfs1(int nod) {
    viz[nod] = true;
    for(auto it : A[nod]) {
        if(!viz[it.fi]) {
            dfs1(it.fi);
        }
    }
    vec.push_back(nod);
}
 
int scc_size;
void dfs2(int nod, int c) {
    viz[nod] = true;
    scc_size++;
    comp[nod] = c;
    Comp[c].push_back(nod);
    for(auto it : B[nod]) {
        if(!viz[it]) {
            dfs2(it, c);
        }
    }
}

int dmin[MAX_N];
bool inQ[MAX_N];
int cinQ[MAX_N];

int bellman(int st) {
    queue<int> Q;
    dmin[st]=0;
    Q.push(st);
    inQ[st]=1;
    cinQ[st]=1;
 
    while(!Q.empty()) {
        int nod=Q.front();
        int cst=dmin[nod];
 
        Q.pop();
        inQ[nod]=0;
 
        for(auto it=A[nod].begin();it!=A[nod].end();it++) {
            if(comp[it->fi] == comp[st]) {
                if(dmin[it->fi]>cst+it->se) {
                    dmin[it->fi]=cst+it->se;
                    if(!inQ[it->fi])
                        Q.push(it->fi);
                        inQ[it->fi]=1;
                        cinQ[it->fi]++;
     
                        if(cinQ[it->fi]>scc_size) {
                            return true;
                        }
                }
            }

        }
 
    }
    return false;
}

void dfs3(int nod) {
    viz[nod] = true;
    for(auto it : C[nod]) {
        if(!viz[it]) {
            dfs3(it);
        }
        marc[nod] = (marc[nod] | marc[it]);
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        A[a].push_back(mp(b, c));
        B[b].push_back(a);
        edges.push_back(mp(a, b));
    }
 
    for(int i = 1; i <= n; i++) {
        if(!viz[i]) {
            dfs1(i);
        }
    }

    for(int i = 1; i <= n ; i++) {
        dmin[i] = INF;
    }
 
    memset(viz, 0, sizeof(viz));
    for(auto it = vec.rbegin(); it != vec.rend(); it++) {
        if(!viz[*it]) {
            dfs2(*it, ++comp[0]);
	        if(bellman(*it)) {
                marc[comp[0]] = true;
            }
            sz[comp[0]] = scc_size;
            scc_size = 0;
        }
    }
 
    for(auto it : edges) {
        if(comp[it.fi] != comp[it.se]) {
            C[comp[it.fi]].push_back(comp[it.se]);
        }
    }
 
    memset(viz, 0, sizeof(viz)); 
    for(int i = 1; i <= comp[0]; i++) {
        if(!viz[i]) {
            dfs3(i);
        }
    }

    int ans = 0;
    for(int i = 1; i <= comp[0]; i++) {
        ans += marc[i] * sz[i];
    }
    
    cout << ans;

    return 0;
}