### BUGGY CODE ###

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

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

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



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


# 最短経路のリスト（list_shortest_path）から、通過する辺を返す関数を定義する
def get_edge(list_shortest_path):
    # 経路上の辺を格納するリスト（list_edge）を設定する
    list_edge = []
    # list_shortest_path内の各最短経路（shortest_path）について、、
    for shortest_path in list_shortest_path:
        # 始点（start）を設定する
        start = shortest_path[0]
        # 最短経路上の始点を除いた各頂点（node）について、、
        for node in shortest_path[1:]:
            # list_edgeに辺を追加する
            list_edge.append((min(start, node), max(start, node)))
            start = node
    # list_edgeを返す
    return list_edge



for start in range(1, N, 1):
    for end in range(N, start, -1):
        if (start, end) not in dic_list_shortest_path:
            dic_list_shortest_path = get_shortest_path(start, end, list_adjlist, dic_distance, sum_distance, dic_list_shortest_path)
            
set_edge = set()            
            
for list_shortest_path in dic_list_shortest_path.values():
    set_edge |= set(get_edge(list_shortest_path))

print(len(set(list_all_edge) - set_edge))        

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