Buggy python submission (verdict: Time Limit Exceeded):
# 頂点の数（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 submission:
# 頂点の数（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)

Buggy python submission (verdict: Time Limit Exceeded):
# 頂点の数（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 submission:
# 頂点の数（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)

Buggy python submission (verdict: Time Limit Exceeded):
# 頂点の数（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 submission:
# 頂点の数（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)

Buggy python submission (verdict: Time Limit Exceeded):
# 頂点の数（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

# 各辺の組み合わせについて、、
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

# 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 = [([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]]:
            # その頂点が終点である場合、、
            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を返す
    return 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)))
            # nodeを次の始点とする
            start = node
    # list_edgeを返す
    return list_edge

# 辺を格納するリスト（list_edge）を設定する
list_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）を得る
        list_shortest_path = get_shortest_path(start, end, list_adjlist, dic_distance, sum_distance)
        # startからendまでの最短経路に含まれる辺を、list_edgeに追加する
        list_edge.extend(get_edge(list_shortest_path))

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

Fixed submission:
# 頂点の数（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)