### BUGGY CODE ###

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

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

# 各辺の組み合わせについて、、
for _ in range(M):
    # 頂点および辺の長さを入力する
    a, b, c = map(int, input().split())
    # list_all_edgeに辺を追加する
    set_all_edge |= set([(a, b), (b, a)])
    # list_adjlistに追加する
    list_adjlist[a].append(b)
    list_adjlist[b].append(a)
    # dic_distanceに辺の長さを格納する
    dic_distance[(min(a, b), max(a, b))] = c
    # sum_distanceに辺の長さを加える
    sum_distance += c

# 2つの頂点間の最短経路のリストを返す関数を定義する
def get_shortest_path(start, end, list_adjlist, dic_distance, sum_distance):
    # 最短距離（shortest_distance）を設定する
    shortest_distance = sum_distance
    # 最短経路リスト（list_shortest_path）を設定する
    list_shortest_path = []
    # 経路のリスト（list_path）を設定する
    list_path = [([(None, start)], 0)]
    # list_pathが空でない限り、、
    while list_path != []:
        # list_pathの先頭の経路（path）とその距離（disrance）を取り出す
        path, distance = list_path.pop(0)
        # pathから到達できる各頂点について、、
        for node in list_adjlist[path[-1][1]]:
            # その頂点が終点である場合、、
            if node == end:
                # 終点までを含めた経路の距離が、shortest_disranceより短かった場合、、
                if distance + dic_distance[(min(path[-1][1], node), max(path[-1][1], node))] < shortest_distance:
                    # shortest_distanceを更新する
                    shortest_distance = distance + dic_distance[(min(path[-1][1], node), max(path[-1][1], node))]
                    # list_shortest_pathを更新する
                    list_shortest_path = [path + [(path[-1][1], node)]]
                # 終点までを含めた経路の距離が、shortest_distanceと等しかった場合、、
                elif distance + dic_distance[(min(path[-1][1], node), max(path[-1][1], node))] == shortest_distance:
                    # list_shortest_pathに追加する
                    list_shortest_path.append(path + [(path[-1][1], node)])
            # その頂点が終点以外で未訪問の頂点だった場合、、        
            elif node not in path:
                # その頂点までを含めた経路の距離が、shortest_distanceより短かった場合、、
                if distance + dic_distance[(min(path[-1][1], node), max(path[-1][1], node))] < shortest_distance:
                    # その頂点までを含めた経路およびその距離を、list_pathに追加する
                    list_path.append((path + [(path[-1][1], node)], distance + dic_distance[(min(path[-1][1], node), max(path[-1][1], node))]))
    # 
    set_edge = set()
    for shortest_path in list_shortest_path:
        for edge in shortest_path:
            set_edge |= set([edge, edge[::-1]])
    # list_shortest_pathを返す
    return set_edge

# 1〜N-1までの各頂点を始点（start）として、、
for start in range(1, N):
    # start+1〜Nまでの各頂点を終点（end）として、、
    for end in range(start + 1, N + 1):
        # startからendまでの最短経路のリスト（list_shortest_path）を得る
        set_edge = get_shortest_path(start, end, list_adjlist, dic_distance, sum_distance)
        set_all_edge -= set_edge


# どの2頂点間の最短経路にも含まれない辺の数を返す
print(len(set_all_edge) // 2)

### 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)