object Main {

  def main(args: Array[String]): Unit = {
    import scala.collection.mutable.ArrayBuffer
    val sc = new java.util.Scanner(System.in)

    // 方向性
    // Bellman-Fordアルゴリズムによって, 全ての頂点vについて, 到達可能な異なる頂点への単一始点最短路を解く.
    // Bellman-FordアルゴリズムはO(VE)なので, 全ての頂点について調べると全点対最短路を解くことになりO(V^2E)である.
    // この時点で全点最短路が求まっているので, 任意のu of Vについて,
    // v of {V - u (d(u,v) != ∞) } からu に到達するために先行点を手繰って通る辺は最短路であるから, この時の最短路を数えていく.
    // 同様の辺を通ることがあるから, ユニークな数を数える.

    val N, M = sc.nextInt()

    val MINF = Int.MinValue / 10
    val INF = Int.MaxValue / 10

    // 全て親が存在しないものとする.
    // parent(u)(v) (u != v) は u について v への推定最短路を達成する v の先行点.
    // u についての v の推定最短路を達成する全ての辺はv の先行点を辿ることで列挙できる.
    val parent = Array.fill(N+1, N+1)(MINF)
    // 全ての距離を∞に初期化する. distance(u)(v) (u != v) はuからvへの推定最短路.
    // アルゴリズムが収束した時, distance(u)(v) = δ(u, v) となり, 最短路の値となる.
    // この時, u についての最短路ではparent(v) を起点としてuまで
    val distance = Array.fill(N+1, N+1)(INF)
    (1 to N) foreach { i => // 全ての自分自身への距離を0とする.
      distance(i)(i) = 0
    }
    // weight(u, v) は u から vへの重さ
    val weight = Array.fill(N+1, N+1)(INF)

    val E = new ArrayBuffer[(Int, Int)]()
    (0 until M) foreach { _ =>
      val a, b, c = sc.nextInt()
      weight(a)(b) = c
      weight(b)(a) = c
      E.append((a, b), (b, a))
    }

    // 全ての頂点について, ベルマンフォードの緩和のステップを行う.
    // ここで, 負閉路がないことが前提なので, 負閉路の判定のステップは必要がない.
    (1 to N) foreach { i =>
      (1 until N) foreach { _ =>
        E foreach { case (u, v) =>
          if (distance(i)(v) >= distance(i)(u) + weight(u)(v)) {
            distance(i)(v) = distance(i)(u) + weight(u)(v)
            parent(i)(v) = u
          }
        }
      }
    }

    // 全ての頂点について, 異なる頂点への最短路を逆方向に辿って最短路をカウントしていく.
    val b = Set.newBuilder[(Int, Int)]
    (1 to N) foreach { u =>
      (1 to N) foreach { v =>
        var _v = v
        while (parent(u)(_v) != MINF) {
          b += (if (parent(u)(_v) < _v) (parent(u)(_v), _v) else (_v, parent(u)(_v)))
          _v = parent(u)(_v)
        }
      }
    }

    // ユニークな最短路に使った辺の数を全体の辺の数から引くと, 使わなかった辺の数になる.
    println(M - b.result().size)
  }
}