using System;

namespace abc151_d
{
    class Program
    {
        static void Main(string[] args)
        {
            var items = Console.ReadLine().Split(' ');
            // 頂点数
            var n = int.Parse(items[0]);
            // 辺数
            var m = int.Parse(items[1]);
            // 最大の重み
            var max = 1000;

            // 辺の一覧(a<bしか使用しない)
            var lines = new int[n, n];
            // 通る点の一覧(最小の重みの格納用)
            var weights = new int[n, n];

            // まずは、1辺ごとの重みを入れて初期化(0は未計算)
            for (int i = 0; i < m; i++)
            {
                items = Console.ReadLine().Split(' ');
                var a = int.Parse(items[0]) - 1;
                var b = int.Parse(items[1]) - 1;
                var c = int.Parse(items[2]);
                SetWeight(lines, a, b, c);
                SetWeight(weights, a, b, c);
            }

            // Warshall-Floyd法というらしい。

            // これ、全頂点同士がつながってないと、ダメなのでは？2辺のものしか計算できないよね？
            // a-b-d-cがa-cより小さい(a-d,b-cはつながっていない)場合、a-b-d(つまりa-d)が計算済みでなければならないはず。
            // でも、このロジックでは、a-b b-d d-c → a-b-d a-c-dとなる。a-b-d-c(a-c-d前にa-c=a-b-dが評価済み)は計算されないはず。
            // 4 4
            // 1 2 1
            // 2 4 1
            // 4 3 1
            // 1 3 5

            // マイロジック→合わない
            {
                //// aから
                //for (int a = 0; a < n; a++)
                //{
                //    // bまで
                //    for (int b = a + 1; b < n; b++)
                //    {
                //        // 2辺以上の最短距離は、1+1以下にはなりえない
                //        var ab = GetWeight(weights, a, b, max);
                //        if (ab > 2)
                //        {
                //            // aとbの中間点
                //            for (int p = 0; p < n; p++)
                //            {
                //                if (a != p && b != p)
                //                {
                //                    var ap = GetWeight(weights, a, p, max);
                //                    var pb = GetWeight(weights, p, b, max);
                //                    // 最小値を記録
                //                    var weight = ap + pb;
                //                    if (weight < ab)
                //                    {
                //                        SetWeight(weights, a, b, weight);
                //                    }
                //                }
                //            }
                //        }
                //    }
                //}
            }

            // Warshall-Floyd法では、a=1-n b=1-nで計算するけど、これ、1辺を2回計算してるよね？
            // 後、pをforの最初にしてるのは、なんでだろう？

            // 試しに、Warshall-Floyd法どおりにやってみる
            // →これは、通る(あたりまえだけど)
            {
                //// aとbの中間点
                //for (int p = 0; p < n; p++)
                //{
                //    // aから
                //    for (int a = 0; a < n; a++)
                //    {
                //        // bまで
                //        for (int b = 0; b < n; b++)
                //        {
                //            // 2辺以上の最短距離は、1+1以下にはなりえない
                //            var ab = GetWeight(weights, a, b, max);
                //            if (ab > 2)
                //            {
                //                if (a != p && b != p)
                //                {
                //                    var ap = GetWeight(weights, a, p, max);
                //                    var pb = GetWeight(weights, p, b, max);
                //                    // 最小値を記録
                //                    var weight = ap + pb;
                //                    if (weight < ab)
                //                    {
                //                        SetWeight(weights, a, b, weight);
                //                    }
                //                }
                //            }
                //        }
                //    }
                //}
            }

            // 試しに、2回計算を通してみる→合わない
            // 試しに、pを先にしてみる

            // aとbの中間点
            for (int p = 0; p < n; p++)
            {
                // aから
                for (int a = 0; a < n; a++)
                {
                    // bまで
                    for (int b = a + 1; b < n; b++)
                    {
                        // 2辺以上の最短距離は、1+1以下にはなりえない
                        var ab = GetWeight(weights, a, b, max);
                        if (ab > 2)
                        {
                            if (a != p && b != p)
                            {
                                var ap = GetWeight(weights, a, p, max);
                                var pb = GetWeight(weights, p, b, max);
                                // 最小値を記録
                                var weight = ap + pb;
                                if (weight < ab)
                                {
                                    SetWeight(weights, a, b, weight);
                                }
                            }
                        }
                    }
                }
            }

            // 算出した重みより重い1辺があったら、それは最短距離でない
            var count = 0;
            for (int a = 0; a < n; a++)
            {
                for (int b = a + 1; b < n; b++)
                {
                    var line = GetWeight(lines, a, b, 0);
                    var weight = GetWeight(weights, a, b, max);
                    if (line > weight)
                    {
                        count++;
                    }
                }
            }

            Console.WriteLine($"{count}");
        }
        static void SetWeight(int[,] weights, int a, int b, int weight)
        {
            var x = a;
            var y = b;
            if (a > b)
            {
                x = b;
                y = a;
            }
            weights[x, y] = weight;
        }
        static int GetWeight(int[,] weights, int a, int b, int def)
        {
            var x = a;
            var y = b;
            if (a > b)
            {
                x = b;
                y = a;
            }
            var weight = weights[x, y];
            // 重みが未計算の時はデフォルト値を返す
            if (weight <= 0)
            {
                weight = def;
            }
            return weight;
        }
    }
}


Measured memory_bytes: 13268