Problem:
Score : 400 points

Problem Statement

You are given an undirected connected weighted graph with N vertices and M edges that contains neither self-loops nor double edges.

The i-th (1≤i≤M) edge connects vertex a_i and vertex b_i with a distance of c_i.

Here, a self-loop is an edge where a_i = b_i (1≤i≤M), and double edges are two edges where (a_i,b_i)=(a_j,b_j) or (a_i,b_i)=(b_j,a_j) (1≤i<j≤M).

A connected graph is a graph where there is a path between every pair of different vertices.

Find the number of the edges that are not contained in any shortest path between any pair of different vertices.

Constraints

2≤N≤100

N-1≤M≤min(N(N-1)/2,1000)

1≤a_i,b_i≤N

1≤c_i≤1000

c_i is an integer.

The given graph contains neither self-loops nor double edges.

The given graph is connected.

Input

The input is given from Standard Input in the following format:

N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M

Output

Print the number of the edges in the graph that are not contained in any shortest path between any pair of different vertices.

Sample Input 1

3 3
1 2 1
1 3 1
2 3 3

Sample Output 1

1

In the given graph, the shortest paths between all pairs of different vertices are as follows:

The shortest path from vertex 1 to vertex 2 is: vertex 1 → vertex 2, with the length of 1.

The shortest path from vertex 1 to vertex 3 is: vertex 1 → vertex 3, with the length of 1.

The shortest path from vertex 2 to vertex 1 is: vertex 2 → vertex 1, with the length of 1.

The shortest path from vertex 2 to vertex 3 is: vertex 2 → vertex 1 → vertex 3, with the length of 2.

The shortest path from vertex 3 to vertex 1 is: vertex 3 → vertex 1, with the length of 1.

The shortest path from vertex 3 to vertex 2 is: vertex 3 → vertex 1 → vertex 2, with the length of 2.

Thus, the only edge that is not contained in any shortest path, is the edge of length 3 connecting vertex 2 and vertex 3, hence the output should be 1.

Sample Input 2

3 2
1 2 1
2 3 1

Sample Output 2

0

Every edge is contained in some shortest path between some pair of different vertices.

Solution in Go (1.14.1) (judge verdict: Accepted)

package main

import (
	"container/heap"
	"fmt"
)

func main() {
	var n, m int
	fmt.Scan(&n, &m)

	g := make([][]Edge, n+1)
	em := make(map[[2]int]bool)
	var a, b, c int
	for i := 0; i < m; i++ {
		fmt.Scan(&a, &b, &c)
		if a > b {
			a, b = b, a
		}

		g[a] = append(g[a], Edge{b, c})
		g[b] = append(g[b], Edge{a, c})
		em[[2]int{a, b}] = true
	}

	for i := 1; i <= n; i++ {
		_, prevs := dijkstra(g, i)
		for j := 1; j <= n; j++ {
			if i == j {
				continue
			}
			ps := path(prevs, j)
			for k := 1; k < len(ps); k++ {
				a, b := ps[k-1], ps[k]
				if a > b {
					a, b = b, a
				}
				em[[2]int{a, b}] = false
			}
		}
	}

	ans := 0
	for _, v := range em {
		if v {
			ans++
		}
	}

	fmt.Println(ans)
}

// Edge .
type Edge struct {
	to, cost int
}

const inf int = 1e10

func dijkstra(g [][]Edge, s int) ([]int, []int) {
	dists := make([]int, len(g))
	for i := 1; i < len(dists); i++ {
		dists[i] = inf
	}
	prevs := make([]int, len(g))

	pq := make(PriorityQueue, 0)
	heap.Init(&pq)
	heap.Push(&pq, &Item{s, 0})
	dists[s] = 0

	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		u := item.pos
		if dists[u] < item.cost {
			continue
		}

		for _, e := range g[u] {
			if dists[e.to] > item.cost+e.cost {
				dists[e.to] = item.cost + e.cost
				prevs[e.to] = u
				heap.Push(&pq, &Item{e.to, dists[e.to]})
			}
		}
	}

	return dists, prevs
}

func path(prevs []int, t int) []int {
	path := make([]int, 0)
	for cur := t; cur != 0; cur = prevs[cur] {
		path = append(path, cur)
	}
	return reverse(path)
}

func reverse(a []int) []int {
	for i := len(a)/2 - 1; i >= 0; i-- {
		opp := len(a) - 1 - i
		a[i], a[opp] = a[opp], a[i]
	}
	return a
}

// Item .
type Item struct {
	pos  int
	cost int
}

// PriorityQueue .
type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].cost < pq[j].cost
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

// Push .
func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*Item)
	*pq = append(*pq, item)
}

// Pop .
func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	old[n-1] = nil
	*pq = old[0 : n-1]
	return item
}