#include <iostream>
#include <vector>
#include <algorithm>
using namespace  std;

const int N = 1005;
vector <pair<long long, long long>> trGraph[N];
vector <pair<long long, long long>> zeroEdges[N];
vector <long long> componen;
vector <long long> isConnectedGraph;
vector <long long> isConnectedZeroGraph;
bool visit[N];

void dfs (vector <vector<pair<long long, long long>>>& graph,long long root) {
    visit[root] = true;
    for (auto i : graph[root]) {
        long long t = i.first;
        if (!visit[t])
            dfs(graph, t);
    }
    isConnectedGraph.push_back(root);
}

void dfsZero (long long root) {
    visit[root] = true;
    for (auto i : zeroEdges[root]) {
        long long t = i.first;
        if (!visit[t])
            dfsZero(t);
    }
    isConnectedZeroGraph.push_back(root);
}

void trDfs(long long root, long long idx) {
    visit[root] = true;
    componen[root] = idx;
    for (auto i : trGraph[root]) {
        long long t = i.first;
        if (!visit[t])
            trDfs(t, idx);
    }
}

long long condens(long long n) {
    for (long long i = 0; i < n; ++i) {
        visit[i] = false;
    }

    isConnectedZeroGraph.clear();

    for (long long i = 0; i < n; ++i) {
        if (!visit[i]) {
            dfsZero(i);
        }
    }

    for (long long i = 0; i < n; ++i) {
        visit[i] = false;
    }

    long long idx = 0;
    for (long long i = 0; i < n; ++i) {
        int t = isConnectedZeroGraph[n - 1 - i];
        if (!visit[t]) {
            ++idx;
            trDfs(t, idx);
        }
    }

    return idx;
}


long long findMST (vector <vector<pair<long long, long long>>>& graph, long long root, long long n) {
    long long ans = 0;
    vector <long long> Min(n, INT32_MAX);

    for (long long i = 0; i < n; ++i) {
        for (auto cur : graph[i]) {
            long long edge = cur.first;
            long long wei = cur.second;
            Min[edge] = min(Min[edge], wei);
        }
    }

    for (long long i = 0; i < n; ++i) {
        if (root != i)
            ans = ans + Min[i];
    }

    for (long long i = 0; i < n; ++i) {
        for (auto cur : graph[i]) {
            if (cur.second == Min[cur.first]) {
                cur.second = 0;
                zeroEdges[i].push_back(cur);
            }
        }
    }

    for (long long i = 0; i < n; ++i) {
        visit[i] = false;
    }

    dfsZero(root);
    if (isConnectedZeroGraph.size() == n) {
        return ans;
    }

    //конденсация графа
    long long components = condens(n);

    vector <vector<pair<long long, long long>>> resGraph(components);
    for (long long i = 0; i < n; ++i) {
        for (auto cur : graph[i]) {
            long long edge = cur.first;
            long long wei = cur.second;
            if (componen[i] != componen[edge])
                resGraph[componen[i]].emplace_back(componen[edge], wei - Min[edge]);
        }
    }

    return ans + findMST(resGraph, componen[root], components);
}


int main() {
    freopen("chinese.in", "r", stdin);
    freopen("chinese.out", "w", stdout);
    long long n, m;
    cin >> n >> m;
    vector <vector<pair<long long, long long>>> graph(n);


    for (long long i = 0; i < n; ++i) {
        visit[i] = false;
    }

    long long fir, sec, wei;
    for (long long i = 0; i < m; ++i) {
        cin >> fir >> sec >> wei;
        --fir;
        --sec;
        graph[fir].emplace_back(sec, wei);
        trGraph[sec].emplace_back(fir, wei);
    }

    dfs(graph, 0);
    if (isConnectedGraph.size() == n) {
        cout << "YES\n";
        cout << findMST(graph, 0, n);
    }
    else cout <<"NO";

    return 0;
}