#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;


struct Edge {
    int u, v, w;

    inline Edge(int u, int v, int w) : u(u), v(v), w(w) {}
};

inline bool compare(const Edge &left, const Edge &right) {
    return (left.w < right.w);
}

long long edmonds(vector<Edge> &edges, int vertices, int start) {


    vector<Edge> min_edge(vertices, Edge(-1, -1, INT_MAX));

    for (const Edge &e : edges)
        min_edge[e.v] = min(min_edge[e.v], e, compare);

    for (int i = 0; i <
                    vertices; i++) {
        if ((min_edge[i].w == INT_MAX) && (i != start))
            return INT_MAX;
    }

    min_edge[start] = Edge(-1, start, 0);


    vector<int> component(vertices, 0);
    vector<bool> visited(vertices, false);
    vector<bool> cycle_component(vertices, false);
    int cnt = 0;
    for (int i = 0; i < vertices; i++) {
        if (visited[i])
            continue;

        int vertex = i;
        vector<int> path;
        while (vertex != -1 &&
               !visited[vertex]) {
            visited[vertex] = true;
            path.push_back(vertex);
            vertex = min_edge[vertex].u;
        }

        bool is_cycle = false;
        for (const int &v : path) {
            component[v] = cnt;
            if (v == vertex) {
                cycle_component[cnt] = true;
                is_cycle = true;
            }
            if (!is_cycle)
                cnt++;
        }

        if (is_cycle)
            cnt++;
    }


    if (cnt == vertices) {
        long long result = 0;
        for (const Edge &e : min_edge)
            result += e.w;
        return result;
    }

    long long result = 0;
    for (const Edge &e : min_edge) {
        if (cycle_component[component[e.v]])
            result += e.w;
    }


    vector<Edge> new_edges;
    for (const Edge &e : edges) {
        int u = component[e.u];
        int v = component[e.v];
        int w = e.w;
        if (u == v)
            continue;
        else new_edges.emplace_back(u, v, cycle_component[v] ? w - min_edge[e.v].w : w);
    }

    long long temp = edmonds(new_edges, cnt, component[start]);
    return (temp == INT_MAX) ? INT_MAX : result + temp;
}

int main() {
    ifstream fin("chinese.in");
    ofstream fout("chinese.out");
    ios_base::sync_with_stdio(false);
    fin.tie(nullptr);

    int v, e;
    int src, dest, w;
    vector<Edge> edges;

    int start = 1;

    fin >> v >> e;
    while (fin >> src >> dest >> w) {
        if ((dest != start) &&
            (dest != src))
            edges.emplace_back(--src, --dest, w);
    }

    long long mst = edmonds(edges, v, --start);

    if (mst == INT_MAX)
        fout << "NO";
    else
        fout << "YES\n" << mst;

    fin.close();
    fout.close();
    return 0;

}