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 C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;
using static System.Math;
using System.Numerics;

namespace AtCoder
{
    class Program
    {
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }
        static long Mod = (long)1e9 + 7;
        static void Main(string[] args)
        {
            SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
            Solve();
            Out.Flush();
            Read();
        }
        static void Solve()
        {
            var NM = Sarray();
            var N = NM[0];
            var M = NM[1];
            var graph = Enumerable.Range(0, (int)N).Select(_ => new List<Tuple<long, long, long>>()).ToArray();//番号、行き先、重さ
            for (var i = 0L; i < M; ++i)
            {
                var abc = Sarray();
                var a = abc[0] - 1;
                var b = abc[1] - 1;
                var c = abc[2];
                graph[a].Add(Tuple.Create(i, b, c));
                graph[b].Add(Tuple.Create(i, a, c));
            }
            used = new bool[M];
            for (var i = 0; i < N; ++i)
                dijkstra(i, graph);
            WriteLine(used.Count(u => !u));

        }
        static bool[] used;
        static readonly int WHITE = 0;
        static readonly int GRAY = 1;
        static readonly int BLACK = 2;
        static long[] dijkstra(long root, List<Tuple<long, long, long>>[] G)
        {
            var MAX = long.MaxValue / 2;
            var n = G.Length;
            var q = new priority_queue<Tuple<long, long, long, long>>((l, r) =>
            {//idx,node,dst,edgedst
                var df = r.Item3 - l.Item3;
                if (0 == df)
                    df = r.Item4 - l.Item4;
                return (int)df;
            });
            var d = Enumerable.Repeat(MAX, n).ToArray();
            var color = Enumerable.Repeat(WHITE, n).ToArray();
            d[root] = 0;
            color[root] = GRAY;
            q.insert(new Tuple<long, long, long, long>(-1L, root, 0L, 0L));
            while (0 < q.num)
            {
                var v = q.extract();
                var u = v.Item2;
                if (0 <= v.Item1 && color[u] != BLACK) used[v.Item1] = true;
                color[u] = BLACK;
                if (d[u] < v.Item3) continue;
                foreach (var kv in G[u])
                {
                    var id = kv.Item1;
                    var ky = kv.Item2;
                    var vl = kv.Item3;
                    if (color[ky] == BLACK) continue;
                    if (d[u] + vl <= d[ky])
                    {
                        d[ky] = d[u] + vl;
                        q.insert(new Tuple<long, long, long, long>(id, ky, d[ky], vl));
                    }
                }
            }
            return d;
        }
        class priority_queue<T>
        {
            Comparison<T> cmp;
            T[] A = new T[2000000];
            // var pq = new priority_queue<long>((l, r) => (int)(l - r));
            // とすれば値の大きいものから優先
            public priority_queue(Comparison<T> c)
            {
                cmp = c;
            }
            public int num { get; private set; } = 0;
            public void insert(T v)
            {
                A[num] = v;
                ++num;
                increaseKey(num);
            }
            void increaseKey(int i)
            {
                while (1 < i && 0 < cmp(A[i - 1], A[i / 2 - 1]))
                {
                    var t = A[i - 1];
                    A[i - 1] = A[i / 2 - 1];
                    A[i / 2 - 1] = t;
                    i = i / 2;
                }
            }
            public T extract()
            {
                if (num < 1) return default(T);
                var max = A[0];
                A[0] = A[num - 1];
                --num;
                maxHeapify(1);
                return max;
            }
            void maxHeapify(int i)
            {
                var H = num;
                var l = left(i);
                var r = right(i);
                var largest = 0;
                if (l <= H && 0 < cmp(A[l - 1], A[i - 1]))
                { largest = l; }
                else
                { largest = i; }
                if (r <= H && 0 < cmp(A[r - 1], A[largest - 1]))
                { largest = r; }
                if (largest != i)
                {
                    var t = A[i - 1];
                    A[i - 1] = A[largest - 1];
                    A[largest - 1] = t;
                    maxHeapify(largest);
                }
            }
            int left(int l) => l * 2;
            int right(int r) => r * 2 + 1;
        }
    }
}