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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
    private static final long INF = 1145141919;
    long map[][];

    public void main(Scanner sc) {
        int n = sc.nextInt();
        int m = sc.nextInt();
        map = new long[n][n];
        for (int i = 0; i < m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            map[a - 1][b - 1] = c;
            map[b - 1][a - 1] = c;
        }

        Map<Integer, Set<Integer>> usedMap = new HashMap<>();
        for (int i = 0; i < n; i++) {
            dijkstra(i, n, usedMap);
        }

        int cnt = 0;
        for (Set<Integer> set : usedMap.values()) {
            cnt += set.size();
        }
        System.out.println(m - cnt);
    }

    public void dijkstra(int start, int n, Map<Integer, Set<Integer>> usedMap) {
        long mins[] = new long[n];
        Arrays.fill(mins, INF);
        boolean flgs[] = new boolean[n];

        Queue<Node> queue = new PriorityQueue<>((o1, o2) -> Long.compare(o1.cost, o2.cost));
        queue.add(new Node(start, 0));
        while (!queue.isEmpty()) {
            Node src = queue.poll();
            if (flgs[src.id]) {
                continue;
            }

            flgs[src.id] = true;
            mins[src.id] = src.cost;

            Integer route[] = src.route.toArray(new Integer[0]);
            for (int i = 0; i < route.length - 1; i++) {
                int id1 = Math.min(route[i], route[i + 1]);
                int id2 = Math.max(route[i], route[i + 1]);
                usedMap.putIfAbsent(id1, new HashSet<>());
                usedMap.get(id1).add(id2);
            }

            for (int dst = 0; dst < n; dst++) {
                if (!flgs[dst] && map[src.id][dst] != 0) {
                    if (mins[dst] > mins[src.id] + map[src.id][dst]) {
                        Node next = new Node(dst, mins[src.id] + map[src.id][dst]);
                        next.route.addAll(src.route);
                        queue.add(next);
                    }
                }
            }
        }
    }

    private class Node {
        int id;
        long cost;
        List<Integer> route = new ArrayList<>();

        public Node(int id, long cost) {
            this.id = id;
            this.cost = cost;
            route.add(id);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        new Main().main(sc);
        sc.close();
    }
}