#include <stdio.h>
#include <queue>
#include <vector>
using namespace std;

#define inf 1999888777

struct cvor {
    int x,d;
};

bool operator< (const cvor &a, const cvor &b) {
    return (a.d >= b.d);   // Mozda treba i >= za PQ !!!  (a inace treba < )
}

priority_queue<cvor> pq,pq2;

struct grana {
    int x,y,d;
};

grana g[100100];

int poc,kr;
bool markc[10101][3];
int qx[30303],qp[30303];
vector<bool> ww[10101];
vector<int> zz[10101],adjg[10101][3];

void markiraj(int x, int pp) {
    int i,v;
    for(i=0; i<adjg[x][pp].size(); i++) { //if (ww[x][i]) {
      v=adjg[x][pp][i];
      if (!markc[v][pp] && markc[v][3-pp]) {
         //printf(" --> Nije ubacio: %d %d\n", x, v);
         //res++;
         markc[v][pp]=true;
         kr++;
         qx[kr]=v; qp[kr]=pp;

         if (markc[v][3-pp]) markiraj(v,pp);
      }
    }
}


int main() {

    int n,m,a,b,i,xx,yy,dd,res,pp,v,pd;
    cvor pc,xc;
    vector<int> adj[10101],w[10101];
    int d[10101][3];
    bool mark[10101][3];


    FILE *ff=fopen("nishtel.in","r"), *gg=fopen("nishtel.out","w");
//printf("ok\n");
    fscanf(ff,"%d%d%d%d", &n, &m, &a, &b);

    for(i=1; i<=m; i++) {
        fscanf(ff,"%d%d%d", &xx, &yy, &dd);
        g[i].x=xx; g[i].y=yy; g[i].d=dd;
        adj[xx].push_back(yy);
        w[xx].push_back(dd);
    }

    for(i=0; i<=n; i++) {
       d[i][1]=inf;
       d[i][2]=inf;
       mark[i][1]=false;
       mark[i][2]=false;
       //markg[i][1]=false;
       //markg[i][2]=false;
    }
//printf("ok\n");
  // Najmanje udaljenosti do 1. grada
    d[a][1]=0;
    pc.x=a;  pc.d=0;
    pq.push(pc);
    for(int ii=1; ii<=n; ii++) {
        xc=pq.top();
        while(mark[xc.x][1] && !pq.empty()) {
           pq.pop();
           xc=pq.top();
        }
      if (!mark[xc.x][1]) {
        xx=xc.x;

        mark[xx][1]=true;
        for(i=0; i<adj[xx].size(); i++) {
           v=adj[xx][i]; pd=w[xx][i];
           if (d[xx][1] + pd < d[v][1]) {
              d[v][1]=d[xx][1]+pd;
              pc.x=v; pc.d=d[v][1];
              pq.push(pc);
           }
        }
      }
    }
//printf("ok\n");
  // Najmanje udaljenosti do 2. grada
    d[b][2]=0;
    pc.x=b;  pc.d=0;
    pq2.push(pc);
    for(int ii=1; ii<=n; ii++) {
        xc=pq2.top();
        while(mark[xc.x][2] && !pq2.empty()) {
           pq2.pop();
           xc=pq2.top();
        }
      if (!mark[xc.x][2]) {
        xx=xc.x;

        mark[xx][2]=true;
        for(i=0; i<adj[xx].size(); i++) {
           v=adj[xx][i]; pd=w[xx][i];
           if (d[xx][2] + pd < d[v][2]) {
              d[v][2]=d[xx][2]+pd;
              pc.x=v; pc.d=d[v][2];
              pq2.push(pc);
           }
        }
      }
    }

    //printf("---------\n");
    //for(i=1; i<=n; i++) {
    //   printf("d1[%d] = %d        d2[%d] = %d\n", i, d[i][1], i, d[i][2]);
    //}
    //printf("---------\n");

//printf("ok\n");
  // Odredjivanje grafa G1 i G2
    int brg=0;
    for(i=1; i<=m; i++) {
        int ppp=0;
        if (d[g[i].x][1] + g[i].d == d[g[i].y][1]) {
          adjg[ g[i].x ][1].push_back(g[i].y);
          //wg[ g[i].x ][1].push_back(g[i].d);
          ppp++;
          //markg[i][1]=true;
        }
        if (d[g[i].x][2] + g[i].d == d[g[i].y][2]) {
          adjg[ g[i].x ][2].push_back(g[i].y);
         // if (ppp) {
            // ww[ g[i[p
            ppp++;
          //wg[ g[i].x ][2].push_back(g[i].d);
          //markg[i][2]=true;
        }
        if (ppp>0) brg++;
        if (ppp==2) {
           zz[ g[i].x ].push_back(g[i].y);
           //printf("zajednicka: %d %d\n", g[i].x, g[i].y);
        }
    }

  // Spajanje G1 i G2
    res=0;
    for(i=1; i<=n; i++) {
        markc[i][1]=false;
        markc[i][2]=false;
    }
    markc[a][1]=true; markc[b][2]=true;

   /* poc=0; kr=2;
    qx[1]=a; qp[1]=1;
    qx[2]=b; qp[2]=2;

    while( poc < kr ) {
       poc++;
       xx = qx[poc]; pp=qp[poc];

       for(i=0; i<adjg[xx][pp].size(); i++) {
          v=adjg[xx][pp][i];
          printf("provera: %d %d\n", xx, v);
          if (!markc[v][pp]) {
             res++;
             printf(" ~~~> Ubacena: %d %d\n", xx, v);
             markc[v][pp]=true;
             kr++;
             qx[kr]=v; qp[kr]=pp;

             if (markc[v][3-pp]) markiraj(v,pp);
          }
       }
    } */
    res=0;

    poc=0; kr=1;
    qx[1]=a; qp[1]=1;
    //qx[2]=b; qp[2]=2;

    while( poc < kr ) {
       poc++;
       xx = qx[poc]; pp=qp[poc];

       for(i=0; i<adjg[xx][pp].size(); i++) {
          v=adjg[xx][pp][i];
          //printf("provera: %d %d\n", xx, v);
          if (!markc[v][pp]) {
             //res++;
             //printf(" ~~~> Ubacena: %d %d\n", xx, v);
             markc[v][pp]=true;
             kr++;
             qx[kr]=v; qp[kr]=pp;

             //if (markc[v][3-pp]) markiraj(v,pp);
          } else res++;
       }
    }
  // printf("res: %d\n", res);

    poc=0; kr=1;
    //qx[1]=a; qp[1]=1;
    qx[1]=b; qp[1]=2;

    while( poc < kr ) {
       poc++;
       xx = qx[poc]; pp=qp[poc];

       for(i=0; i<adjg[xx][pp].size(); i++) {
          v=adjg[xx][pp][i];
          //printf("provera: %d %d\n", xx, v);
          if (!markc[v][pp]) {
             //res++;
             //printf(" ~~~> Ubacena: %d %d\n", xx, v);
             markc[v][pp]=true;
             kr++;
             qx[kr]=v; qp[kr]=pp;

             //if (markc[v][3-pp]) markiraj(v,pp);
          } else {
              res++;
              //printf("-> %d\n", v);
          }
       }
    }
  // printf("res: %d\n", res);

    int zzz,pz[10101];
    bool markz[10101];

    zzz=0;
    for(i=1; i<=n; i++) {
       markz[i]=false;
       pz[i]=0;
    }
    for(i=1; i<=n; i++) if (!markz[i]) {
       zzz++;
       poc=0; kr=1; qx[1]=i; markz[i]=true; pz[i]=zzz;
      while( poc < kr ) {
          poc++;
       xx = qx[poc]; //pp=qp[poc];

       for(i=0; i<zz[xx].size(); i++) {
          v=zz[xx][i];
          //printf("provera: %d %d\n", xx, v);
          if (!markz[v]) {
             //res++;
             //printf(" ~~~> Ubacena: %d %d\n", xx, v);
             markz[v]=true;
             kr++;
             qx[kr]=v; //qp[kr]=pp;
             pz[v]=zzz;
             //if (markc[v][3-pp]) markiraj(v,pp);
          } else {
              if (pz[v]==zzz)
                res--;
              //printf("-> %d\n", v);
          }
       }
      }
    }
  //   printf("res: %d\n", res);


    //printf(" %d - %d  ---> %d \n", brg,res, m - brg + res);
    fprintf(gg,"%d\n",m-brg+res);

    fclose(ff); fclose(gg);
    return 0;
}
