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

            // マイロジック→合わない
            // Solve1(n, max, weights);

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

            // 試しに、Warshall-Floyd法どおりにやってみる
            // →これは、通る(あたりまえだけど)
            // Sample(n, max, weights);

            // 試しに、2回計算を通してみる→合わない
            // →つまり、テストデータがa-b-d-cに対応してないわけじゃない(そりゃそうだ)
            // →他ページの解説的に、a-b b-aの2回計算を通しているのは、双方向で重みづけが違った場合のロジックをそのまま使ってるからっぽい
            // →つまり、この問題では、無駄な計算を2回やってるだけ。a-bのみでいいはず。
            // Solve2(n, max, weights);

            // 試しに、pを先にしてみる→これは、合う
            // →つまり、はじめので合わなかったのは、純粋に計算順の問題？
            // →なんでこの計算順はいけるのか？

            // a-b-pのループは「まずa-bに絡む重みをすべて出す」になる
            // a-bの全パターンを出すには、a-c-bを出せないといけないが、この時点ではa-cもc-bも未解決。
            // →つまり、p-1を先に回していないと、pは出せない(中間点3個を出すには、すべての中間点2個が解決されている必要がある)
            // (a-p + p-b → a-k + k-p + p-k + k-b → a-1-2 + 1-2-3 + ... + (p-2)-(p-1)-p + (p-1)-p-b)
            // →逆に、p-1を先に回していれば、pのループまでに、必要なp-1(要素数が一つ以上少ない)はすべて計算されている

            // p=0→a-bで、0を経由しているか、何も経由していない場合の重み算出(中継点の数0-1)
            // p=1→a-bで、0,1を経由しているか、何も経由していない場合の重み算出(中継点の数0-2)
            // p=2→a-bで、0,1,2を経由しているか、何も経由していない場合の重み算出(中継点の数0-3)
            // p=3→a-bで、0,1,2,3を経由しているか、何も経由していない場合の重み算出(中継点の数0-4)
            // p→a-bで、0,...,pを経由しているか、何も経由していない場合の重み算出(中継点の数0-p+1)
            Solve3(n, max, weights);

            // Warshall-Floyd法は、dpらしい。→観点の違うdpでも書いてみる。(中間点1個、中間点2個、中間点3個、...、中間点n個)
            // Solve4(n, max, weights);

            // pのループを先にすればi=1で終わっていい理由

            // グラフの連結は、3通り。
            // 直線の場合→a-b-c-dは、どの場合でも通り方は1通り→どの辺も最小に含まれる。
            //   →必ず1回目で計算される(p=a,b,c,dのどれが最後でも、必要な要素――p=dが最後の場合は、中継点の少ないp=a,b,c――が計算済み)
            // Y字の場合→a-b-cは、直線と同じ
            //              \d
            // 円形の場合→a-b-cは、どの点も、通り方は2通り→a-bは計算済み、a-b-c、a-d-cは1回で計算される、a-b-c-dは直線と同じ
            //            \d/

            // なので、1回目ですべての最小が出る

            // 算出した重みより重い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 Solve1(int n, int max, int[,] weights)
        {
            // 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);
                                // 最小値を記録
                                SetWeight(weights, a, b, Math.Min(ab, ap + pb));
                            }
                        }
                    }
                }
            }
        }
        static void Sample(int n, int max, int[,] weights)
        {
            // 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);
                                }
                            }
                        }
                    }
                }
            }
        }
        static void Solve2(int n, int max, int[,] weights)
        {
            Solve1(n, max, weights);
            Solve1(n, max, weights);
        }
        static void Solve3(int n, int max, int[,] weights)
        {
            // aとbの中間点
            for (int p = 0; p < n; p++)
            {
                // aから
                for (int a = 0; a < n; a++)
                {
                    if (a != p)
                    {
                        // bまで
                        for (int b = a + 1; b < n; b++)
                        {
                            if (b != p)
                            {
                                // 2辺以上の最短距離は、1+1以下にはなりえない
                                var ab = GetWeight(weights, a, b, max);
                                if (ab > 2)
                                {
                                    var ap = GetWeight(weights, a, p, max);
                                    var pb = GetWeight(weights, p, b, max);
                                    SetWeight(weights, a, b, Math.Min(ab, ap + pb));
                                }
                            }
                        }
                    }
                }
            }
        }
        static void Solve4(int n, int max, int[,] weights)
        {
            // まず、すべての2辺の重みを出す
            // 次に、すべての3辺の重みを出す
            // 次に、すべての4辺の重みを出す
            //   :
            // 次に、すべてのn-1辺の重みを出す
            // 次に、すべてのn辺の重みを出す

            // 中間点の数ごとにある一点を経由する2点(a-p-b)の重みを求める
            // 使用する中間点の数(a-bまでにいくつの点があるか)
            for (int i = 1; i < n; i++)
            {
                // 始点a
                for (int a = 0; a < n; a++)
                {
                    // 終点b(順番は関係ないので、a<bのみ計算する)
                    for (int b = a + 1; b < n; b++)
                    {
                        // 1-2-4-5
                        //  \3/

                        // 2個 1-2
                        // 2個 1-3
                        // 2個 2-4
                        // 2個 3-4
                        // 2個 4-5
                        // 3個 1-3-2 x 3-1-2の後(4個 1-3-1-2 x)に算出される
                        // 3個 1-4-2 x 1-2or3-4の後(4個 1-2or3-4-2)に算出される
                        // 3個 1-5-2 x 1-2or3-4-5と2-4-5の後(6個 1-2or3-4-5-4-2)に算出される
                        // 3個 1-2-3 x 2-1-3の後(4個 1-2-1-3)に算出される
                        // 3個 1-4-3 x 1-2or3-4の後(4個 1-2or3-4-3)に算出される
                        // 3個 1-5-3 x 1-2or3-4-5と3-4-5の後(6個 1-2or3-4-5-4-2)に算出される
                        // 3個 1-2-4 o
                        // 3個 1-3-4 o
                        // 3個 1-5-4 x 1-2or3-4-5の後(5個 1-2or3-4-5-4)に算出される
                        //  :
                        // 4個 1-3-2 x 1-3-1がxなので
                        // 4個 1-4-2 o
                        // 4個 1-5-2 x 1-2or3-4-5と2-4-5の後(6個 1-2or3-4-5-4-2)に算出される
                        // 3個 1-2-3 x 1-2-1がxなので
                        // 3個 1-4-3 o
                        // 3個 1-5-3 x 1-2or3-4-5と3-4-5の後(6個 1-2or3-4-5-4-2)に算出される

                        // 中間点
                        for (int p = 0; p < n; p++)
                        {
                            var ab = GetWeight(weights, a, b, max);
                            var ap = GetWeight(weights, a, p, max);
                            var pb = GetWeight(weights, p, b, max);
                            SetWeight(weights, a, b, Math.Min(ab, ap + pb));
                        }
                    }
                }
            }
        }
        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: 13236