Two chinese algo

import java.io.*;
import java.util.*;

public class Chinese {
    FastScanner in;
    PrintWriter out;

    ArrayList<Integer>[] g;
    ArrayList<Integer>[] gr;
    ArrayList<Integer>[] gCost;
    ArrayList<Integer>[] grCost;

    int n;
    boolean[] was;
    int[] min;
    long ans = 0;

    void dfs(int v) {
        was[v] = true;
        for (int i = 0; i < g[v].size(); i++) {
            int u = g[v].get(i);
            if (!was[u] && min[u] >= gCost[v].get(i))
                dfs(u);
        }
    }

    boolean allVisited() {
        for (int i = 0; i < n; i++)
            if (!was[i])
                return false;
        return true;
    }

    ArrayList<Integer> order = new ArrayList<Integer>();
    ArrayList<Integer> component = new ArrayList<Integer>();

    void dfs1(int v) {
        was[v] = true;
        for (int i = 0; i < g[v].size(); ++i)
            if (!was[g[v].get(i)] && gCost[v].get(i) == min[g[v].get(i)])
                dfs1(g[v].get(i));
        order.add(v);
    }

    void dfs2(int v) {
        was[v] = true;
        component.add(v);
        for (int i = 0; i < gr[v].size(); ++i)
            if (!was[gr[v].get(i)] && grCost[v].get(i) == min[v])
                dfs2(gr[v].get(i));
    }

    void solve() {
        n = in.nextInt();
        int m = in.nextInt();
        was = new boolean[n];
        g = new ArrayList[n];
        gr = new ArrayList[n];
        gCost = new ArrayList[n];
        grCost = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<Integer>();
            gr[i] = new ArrayList<Integer>();
            gCost[i] = new ArrayList<Integer>();
            grCost[i] = new ArrayList<Integer>();
        }
        for (int i = 0; i < m; i++) {
            int fr = in.nextInt() - 1;
            int to = in.nextInt() - 1;
            int cost = in.nextInt();
            g[fr].add(to);
            gr[to].add(fr);
            gCost[fr].add(cost);
            grCost[to].add(cost);
        }
        min = new int[n];
        Arrays.fill(min, Integer.MAX_VALUE);
        dfs(0);
        if (!allVisited()) {
            out.println("NO");
            return;
        }
        int start = 0;
        //int xx = 0;
        while (true) {
            //System.err.println(xx++);
            int[] newMin = new int[n];
            Arrays.fill(newMin, Integer.MAX_VALUE);
            for (int i = 0; i < n; i++)
                for (int j = 0; j < g[i].size(); j++) {
                    int u = g[i].get(j);
                    if (u == start) continue;
                    newMin[u] = Math.min(newMin[u], gCost[i].get(j));
                }
            min = newMin;
            for (int i = 0; i < n; i++)
                if (i != start)
                    ans += min[i];
            Arrays.fill(was, false);
            dfs(start);
            if (allVisited())
                break;
            Arrays.fill(was, false);
            order.clear();
            for (int i = 0; i < n; ++i)
                if (!was[i])
                    dfs1(i);
            Arrays.fill(was, false);
            int[] componentId = new int[n];
            int components = 0;
            for (int i = 0; i < n; ++i) {
                int v = order.get(n - 1 - i);
                if (!was[v]) {
                    dfs2(v);
                    for (int j : component)
                        componentId[j] = components;
                    component.clear();
                    components++;
                }
            }
            //
            int newN = components;
            ArrayList<Integer>[] gNew = new ArrayList[newN];
            ArrayList<Integer>[] grNew = new ArrayList[newN];
            ArrayList<Integer>[] gCostNew = new ArrayList[newN];
            ArrayList<Integer>[] grCostNew = new ArrayList[newN];
            for (int i = 0; i < newN; i++) {
                gNew[i] = new ArrayList<Integer>();
                grNew[i] = new ArrayList<Integer>();
                gCostNew[i] = new ArrayList<Integer>();
                grCostNew[i] = new ArrayList<Integer>();
            }
            for (int i = 0; i < n; i++)
                for (int j = 0; j < g[i].size(); j++) {
                    int u = g[i].get(j);
                    int x = componentId[i];
                    int y = componentId[u];
                    if (x != y) {
                        gNew[x].add(y);
                        gCostNew[x].add(gCost[i].get(j) - min[u]);
                        grNew[y].add(x);
                        grCostNew[y].add(gCost[i].get(j) - min[u]);
                    }
                }
            n = newN;
            g = gNew;
            gr = grNew;
            gCost = gCostNew;
            grCost = grCostNew;
            start = componentId[start];
        }
        out.println("YES");
        out.println(ans);
    }

    void run() {
        try {
            in = new FastScanner(new File("chinese.in"));
            out = new PrintWriter(new File("chinese.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

    public static void main(String[] args) {
        new Chinese().run();
    }
}