#include <stdlib.h>
#include <stdio.h>
#include <vector>

using namespace std;

const int inf = 2000000000;
const int MaxN = 10010;
const int MaxM = 100010;

struct edge {
	int v, w;
	edge(int _v, int _w) {
		v = _v; w = _w;
	}
};

int n, m, A, B, u, v, w, sol;
int dA[MaxN], dB[MaxN], d[MaxN];
int adj[MaxM], weight[MaxM], a[MaxM], b[MaxM], w1[MaxM];
int p[MaxN], deg[MaxN];
bool mark[MaxN];

struct Heap {
	int heap_size;
	int h[MaxN];
	int posInHeap[MaxN];

	void init(int n) { 
		heap_size = n; 
		for (int i = 1; i <= n; i++) {
			h[i] = i;
			posInHeap[i] = i;
		}
	}

	bool empty() { return (heap_size == 0); }

	void update(int u, int newVal) {
		int f, s;
		d[u] = newVal;
		s = posInHeap[u]; 
		f = s / 2;

		while (f != 0 && d[ h[f] ] > d[u]) {
			h[s] = h[f];
			posInHeap[ h[f] ] = s;
			s = f; f = s / 2;
		}
		h[s] = u;
		posInHeap[u] = s;
	}

	int extractMin() {
		int f, s, u, min;
		min = h[1];
		h[1] = u = h[heap_size--];
		f = 1;
		s = 2 * f;
		if (heap_size > s && d[ h[s + 1] ] < d[ h[s] ]) s++;

		while (s <= heap_size && d[u] > d[ h[s] ]) {
			h[f] = h[s];
			posInHeap[ h[s] ] = f;
			f = s; s = 2 * f;
			if (heap_size > s && d[ h[s + 1] ] < d[ h[s] ]) s++;
		}
		h[f] = u;
		posInHeap[u] = f;

		return min;
	}		
};

Heap H;

void Dijkstra(int START) {
	int u, v, w, min;
	for (int i = 1; i <= n; i++) d[i] = inf;
	H.init(n);
	H.update(START, 0);

	while (!H.empty()) {
		u = H.extractMin();
		for (int i = p[u]; i < p[u] + deg[u]; i++) {
			v = adj[i];
			w = weight[i];
			if (d[u] + w < d[v])
				H.update(v, d[u] + w);
		}
	}
}

int main() {

	FILE* inFile = fopen("nishtel.in", "r");
	FILE* outFile = fopen("nishtel.out", "w");

	for (int i = 1; i <= n; i++) deg[i] = 0;
	fscanf(inFile, "%d%d%d%d", &n, &m, &A, &B);
	for (int i = 1; i <= m; i++) {
		fscanf(inFile, "%d%d%d", &a[i], &b[i], &w1[i]);
		deg[a[i]]++;
	}

	p[0] = 0;
	for (int i = 1; i <= n; i++) 
		p[i] = p[i - 1] + deg[i - 1];

	for (int i = 1; i <= m; i++) { 
		adj[p[a[i]]] = b[i];
		weight[p[a[i]]] = w1[i];
        p[a[i]] = p[a[i]] + 1;
	}
    for (int i = 1; i <= n; i++)
		p[i] = p[i - 1] + deg[i - 1];
	
	Dijkstra(A);
	for (int i = 1; i <= n; i++) dA[i] = d[i];
	Dijkstra(B);
	for (int i = 1; i <= n; i++) dB[i] = d[i];

	sol = m - 2 * n + 2;
	for (int i = 1; i <= n; i++) mark[i] = false;

	for (u = 1; u <= n; u++)
		for (int i = p[u]; i < p[u] + deg[u]; i++) {
			v = adj[i];
			w = weight[i];
			if (!mark[v] && dA[v] - dA[u] == w && dB[v] - dB[u] == w) {
				mark[v] = true;
				sol++;
			}
		}
	fprintf(outFile, "%d\n", sol);

	fclose(inFile);
	fclose(outFile);
	return 0;
}