N, M = map(int, input().split())
ABC = []
for i in range(M):
    abc = tuple(map(int, input().split()))
    ABC.append(abc)

# print(N, M, ABC)

max_len = 0
for abc in ABC:
    max_len += abc[2]

def sub(a, b, d, d_min, ABC, path):
    # print('sub', a, b, d, d_min, ABC, path)
    for abc in ABC:
        # print('sub', abc)
        if abc[0] == a:
            n_a = abc[1]
            tmp_d = d + abc[2]
            if tmp_d > d_min:
                # print('exceed', d, d_min)
                continue
            if n_a == b:
                path.append(n_a)
                # print('found', tmp_d, path)
                return tmp_d
            tmp = [x for x in path]
            tmp.append(n_a)
            tmp_d = sub(n_a, b, tmp_d, d_min, ABC, tmp)
            if tmp_d > d_min:
                # print('exceed2', tmp_d, d_min)
                continue
        if abc[1] == a:
            n_a = abc[0]
            tmp_d = d + abc[2]
            if tmp_d > d_min:
                # print('exceed', tmp_d, d_min)
                continue
            if n_a == b:
                path.append(n_a)
                # print('found', tmp_d, path)
                return tmp_d
            tmp = [x for x in path]
            tmp.append(n_a)
            tmp_d = sub(n_a, b, tmp_d, d_min, ABC, tmp)
            if tmp_d > d_min:
                # print('exceed2', tmp_d, d_min)
                continue
    # print('not found')
    path = []
    return max_len

def shortest(a, b, ABC):
    d_min = max_len
    ans = []
    for abc in ABC:
        # print('shortest', a, b, abc)
        if abc[0] == a:
            n_a = abc[1]
            d = abc[2]
            path = [a, n_a]
            if n_a == b and d <= d_min:
                d_min = d
                ans = [path]
                continue
            d = sub(n_a, b, d, d_min, ABC, path)
            if d <= d_min:
                # print('shortest, found', d, path)
                d_min = d
                ans = [path]
            if d == d_min:
                ans.append(path)
        if abc[1] == a:
            n_a = abc[0]
            d = abc[2]
            path = [a, n_a]
            if n_a == b and d <= d_min:
                d_min = d
                ans = [path]
                continue
            d = sub(n_a, b, d, d_min, ABC, path)
            if d < d_min:
                # print('shortest, found', d, path)
                d_min = d
                ans = [path]
            if d == d_min:
                ans.append(path)
    return ans

# print(shortest(1, 2, ABC))
# print(shortest(1, 3, ABC))
# print(shortest(2, 3, ABC))

s_paths = set()

for i in range(N):
    for j in range(i + 1, N):
        paths = shortest(i + 1, j + 1, ABC)
        # print(i, j, paths)
        for path in paths:
            # print(path)
            for k in range(len(path) - 1):
                l = min(path[k], path[k + 1])
                r = max(path[k], path[k + 1])
                s_paths.add((l, r))

print(len(ABC) - len(s_paths))
