### BUGGY CODE ###

# 頂点の数（N）および辺の数（M）を入力する
N, M = map(int, input().split())

# 頂点の隣接リスト（list_adjlist）を設定する
list_adjlist = [[] for _ in range (N + 1)]
# 辺の長さを格納する辞書（dic_edge_dist）を設定する
dic_edge_dist = {}
# 辺の長さの合計（sum_edge）を設定する
sum_edge= 0

# 各辺について、、
for _ in range(M):
    # 頂点および辺の長さを入力する
    a, b, c = map(int, input().split())
    # list_adjlistに辺を追加する
    list_adjlist[a].append(b)
    list_adjlist[b].append(a)
    # dic_edge_distに辺の長さを格納する
    dic_edge_dist[(min(a, b), max(a, b))] = c
    # sum_edgeに辺の長さを加える
    sum_edge += c

def get_shortest_dist(start, end, list_adjlist, dic_edge_dist, sum_edge):
    # 最短距離（shortest_dist）を設定する
    shortest_dist = sum_edge
    # 経路のリスト（list_path）を設定する
    list_path = [([start], 0)]
    # list_pathが空でない限り、、
    while list_path != []:
        # list_pathの先頭の経路（path）とその距離（dist）を取り出す
        path, dist = list_path.pop(0)
        # pathから到達できる各頂点について、、
        for node in list_adjlist[path[-1]]:
            # その頂点までを含めた経路の距離が、shortest_distより短かった場合、、
            if dist + dic_edge_dist[(min(path[-1], node), max(path[-1], node))] < shortest_dist:
                # その頂点が終点である場合、、
                if node == end:
                    # shortest_distを更新する
                    shortest_dist = dist + dic_edge_dist[(min(path[-1], node), max(path[-1], node))]
                # その頂点が終点以外で未訪問の頂点だった場合、、        
                elif node not in path:
                    # その頂点までを含めた経路およびその距離を、list_pathに追加する
                    list_path.append((path + [node], dist + dic_edge_dist[(min(path[-1], node), max(path[-1], node))]))
    # shortest_distを返す
    return shortest_dist

dic_shortest_dist = {}
for start in range(1, N):
    for end in range(start + 1, N + 1):
        dic_shortest_dist[(start, end)] = get_shortest_dist(start, end, list_adjlist, dic_edge_dist, sum_edge)
        
edge_count = 0
for edge, dist in dic_edge_dist.items():
    for node in range(1, N + 1):
        if node in edge:
            continue
        if dist == dic_shortest_dist[edge]:
            edge_count += 1
            break
        if dic_shortest_dist[(min(node, edge[0]), max(node, edge[0]))] + dist == dic_shortest_dist[(min(node, edge[1]), max(node, edge[1]))]:
            edge_count += 1
            break
        elif dic_shortest_dist[(min(node, edge[0]), max(node, edge[0]))] == dic_shortest_dist[(min(node, edge[1]), max(node, edge[1]))] + dist:
            edge_count += 1
            break
            
print(len(dic_edge_dist) - edge_count)

### FIXED CODE ###

# 頂点の数（N）および辺の数（M）を入力する
N, M = map(int, input().split())

# 辺の長さを格納する辞書（dic_edge_dist）を設定する
dic_edge_dist = {(i, j) : float("inf") for i in range(1, N + 1) for j in range(1, N + 1)}
for i in range(1, N + 1):
    dic_edge_dist[(i, i)] = 0
# 辺を格納するリスト（list_edge）を設定する
list_edge = []

def warshall_floyd(dic_edge_dist):
    dic_shortest_dist = dic_edge_dist.copy()
    for i in range(1, N + 1):
        for j in range(1, N + 1):
            for k in range(1, N + 1):
                dic_shortest_dist[(j, k)] = min(dic_shortest_dist[(j, k)], dic_shortest_dist[(j, i)] + dic_shortest_dist[(i, k)])
    return dic_shortest_dist

# 各辺について、、
for _ in range(M):
    # 頂点および辺の長さを入力する
    a, b, c = map(int, input().split())
    # dic_edge_distに辺の長さを格納する
    dic_edge_dist[(a, b)] = c
    dic_edge_dist[(b, a)] = c
    # list_edgeに辺を格納する
    list_edge.append((min(a, b), max(a, b)))

dic_shortest_dist = warshall_floyd(dic_edge_dist)
    
edge_count = 0
for i, j in list_edge:
    for k in range(1, N + 1):
        if dic_shortest_dist[(k, i)] + dic_edge_dist[(i, j)] == dic_shortest_dist[(k, j)]:
            edge_count += 1
            break
        if dic_shortest_dist[(k, j)] + dic_edge_dist[(j, i)] == dic_shortest_dist[(k, i)]:
            edge_count += 1
            break

print(len(list_edge) - edge_count)