Problem:
 Score : 1200 points    Problem Statement We have N boxes numbered 1 to N , and M balls numbered 1 to M .
Currently, Ball i is in Box A_i .  You can do the following operation:   Choose a box containing two or more balls, pick up one of the balls from that box, and put it into another box.   Since the balls are very easy to break, you cannot move Ball i more than C_i times in total.
Within this limit, you can do the operation any number of times.  Your objective is to have Ball i in Box B_i for every i ( 1 \leq i \leq M ).
Determine whether this objective is achievable.
If it is, also find the minimum number of operations required to achieve it.      Constraints  1 \leq N \leq 10^5  1 \leq M \leq 10^5  1 \leq A_i,B_i \leq N  1 \leq C_i \leq 10^5  In the situation where the objective is achieved, every box contains one or more balls.
That is, for every i ( 1 \leq i \leq N ), there exists j such that B_j=i .         Input Input is given from Standard Input in the following format:  N  M  A_1  B_1  C_1  A_2  B_2  C_2  \vdots  A_M  B_M  C_M       Output If the objective is unachievable, print -1 ; if it is achievable, print the minimum number of operations required to achieve it.        Sample Input 1 3 3
1 2 1
2 1 1
1 3 2      Sample Output 1 3  We can achieve the objective in three operations, as follows:   Pick up Ball 1 from Box 1 and put it into Box 2 .  Pick up Ball 2 from Box 2 and put it into Box 1 .  Pick up Ball 3 from Box 1 and put it into Box 3 .        Sample Input 2 2 2
1 2 1
2 1 1      Sample Output 2 -1       Sample Input 3 5 5
1 2 1
2 1 1
1 3 2
4 5 1
5 4 1      Sample Output 3 6       Sample Input 4 1 1
1 1 1      Sample Output 4 0

Solution (Python):
import sys

from bisect import bisect_left
from collections import defaultdict
from itertools import accumulate


class UnionFind:
    def __init__(self, n):
        self.table = [-1] * n

    def _root(self, x):
        stack = []
        tbl = self.table
        while tbl[x] >= 0:
            stack.append(x)
            x = tbl[x]
        for y in stack:
            tbl[y] = x
        return x

    def find(self, x, y):
        return self._root(x) == self._root(y)

    def unite(self, x, y):
        r1 = self._root(x)
        r2 = self._root(y)
        if r1 == r2:
            return
        d1 = self.table[r1]
        d2 = self.table[r2]
        if d1 <= d2:
            self.table[r2] = r1
            self.table[r1] += d2
        else:
            self.table[r1] = r2
            self.table[r2] += d1

    def get_size(self, x):
        return -self.table[self._root(x)]


def solve():
    n, m = map(int, sys.stdin.buffer.readline().split())

    extra_durabilities = [0] * n
    self_loop_durabilities = [[] for _ in range(n)]
    outdegrees = [0] * n
    base_operation_count = 0
    uft = UnionFind(n)

    mp = map(int, sys.stdin.buffer.read().split())
    for a, b, c in zip(mp, mp, mp):
        a -= 1
        b -= 1
        outdegrees[a] += 1
        if a == b:
            if c >= 2:
                self_loop_durabilities[a].append(c)
            continue
        uft.unite(a, b)
        extra_durabilities[a] += c - 1
        base_operation_count += 1

    
    components = defaultdict(lambda: [0, 0, 0, []])
    for i in range(n):
        r = uft._root(i)
        item = components[r]
        item[0] += 1
        item[1] = max(item[1], outdegrees[i])
        item[2] += extra_durabilities[i]
        item[3].extend(self_loop_durabilities[i])

    exists_initial_catalyst_on_moving_path = False
    exists_initial_catalyst_at_self_loop = False
    supplied_catalyst = 0
    demanded_catalyst = 0
    self_loop_catalysts_cost1 = []
    self_loop_catalysts_cost2 = []

    for i, (cnt, deg, dur, sel) in components.items():
        if cnt == 1:
            if deg == 1:
                self_loop_catalysts_cost2.extend(c - 2 for c in sel)
            else:
                if len(sel) >= 1:
                    self_loop_catalysts_cost1.extend(c - 1 for c in sel)
                    exists_initial_catalyst_at_self_loop = True
            continue
        if deg == 1:
            supplied_catalyst += dur
            demanded_catalyst += 1
        else:
            supplied_catalyst += dur
            if dur >= 1:
                exists_initial_catalyst_on_moving_path = True
            elif len(sel) >= 1:
                exists_initial_catalyst_at_self_loop = True
        self_loop_catalysts_cost1.extend(c - 1 for c in sel)

    
    

    if demanded_catalyst == 0:
        return base_operation_count

    if not exists_initial_catalyst_on_moving_path and not exists_initial_catalyst_at_self_loop:
        return -1

    if supplied_catalyst >= demanded_catalyst:
        if exists_initial_catalyst_on_moving_path:
            return base_operation_count + demanded_catalyst
        else:
            return base_operation_count + demanded_catalyst + 1

    self_loop_catalysts_cost1.sort(reverse=True)
    self_loop_catalysts_cost2.sort(reverse=True)
    
    
    acc1 = [0] + list(accumulate(self_loop_catalysts_cost1))
    acc2 = [0] + list(accumulate(self_loop_catalysts_cost2))
    
    
    shortage = demanded_catalyst - supplied_catalyst
    if acc1[-1] + acc2[-1] < shortage:
        return -1

    cost = 10 ** 18
    for use1 in range(0 if exists_initial_catalyst_on_moving_path else 1, len(acc1)):
        cat = acc1[use1]
        remaining = shortage - cat
        if remaining <= 0:
            cost = min(cost, use1)
            break
        if remaining > acc2[-1]:
            continue
        use2 = bisect_left(acc2, remaining)
        cost = min(cost, use1 + 2 * use2)

    return base_operation_count + demanded_catalyst + cost


print(solve())