#include<stdio.h>

 #include<string.h>

 #include<algorithm>

 #include<stdlib.h>

 #include<bitset>

 #include<queue>

 #include<math.h>

 //#include<time.h>

 //#include<iostream>

 using namespace std;

 int n,m,s,t;

 #define maxn 50011

 #define maxm 100011

 #define LL long long

 struct Edge{int to,next,v;};

 struct qnode

 {

     int id; LL v;

     bool operator < (const qnode &b) const {return v<b.v;}

     bool operator > (const qnode &b) const {return v>b.v;}

 };

 struct Graph

 {

     Edge edge[maxm<<]; int first[maxn],le;

     Graph() {memset(first,,sizeof(first)); le=;}

     void in(int x,int y,int v) {Edge &e=edge[le]; e.to=y; e.v=v; e.next=first[x]; first[x]=le++;}

     void insert(int x,int y,int v) {in(x,y,v); in(y,x,v);}

     priority_queue<qnode,vector<qnode>,greater<qnode> > q;

     void dijkstra(int s,LL *dis,LL *f)

     {

         for (int i=;i<=n;i++) dis[i]=1e18,f[i]=;

         dis[s]=; f[s]=;

         q.push((qnode){s,});

         while (!q.empty())

         {

             const int now=q.top().id; const LL d=q.top().v; q.pop();

             if (d!=dis[now]) continue;

             for (int i=first[now];i;i=edge[i].next)

             {

                 const Edge &e=edge[i];

                 if (dis[e.to]>dis[now]+e.v)

                 {

                     dis[e.to]=dis[now]+e.v;

                     f[e.to]=f[now];

                     q.push((qnode){e.to,dis[e.to]});

                 }

                 else if (dis[e.to]==dis[now]+e.v) f[e.to]+=f[now];

             }

         }

     }

 }g;

 LL dis[][maxn],f[][maxn],val[maxn];

 bitset<maxn> where[maxn],can[][maxn];

 int indo[maxn],head,tail,que[maxn];

 bool check(int x,int y,int v,int ty) {return dis[ty][x]+v+dis[ty^][y]==dis[][t];}

 void toposort(int ty)

 {

     memset(indo,,sizeof(indo));

     for (int i=;i<=n;i++)

         for (int j=g.first[i];j;j=g.edge[j].next)

         {

             const Edge &e=g.edge[j];

             if (check(i,e.to,e.v,ty)) indo[e.to]++;

         }

     head=tail=;

     for (int i=;i<=n;i++) if (indo[i]==) que[tail++]=i;

     while (head!=tail)

     {

         const int now=que[head++];

         for (int i=g.first[now];i;i=g.edge[i].next)

         {

             const Edge &e=g.edge[i];

             if (!check(now,e.to,e.v,ty)) continue;

             indo[e.to]--; if (indo[e.to]==) que[tail++]=e.to;

             can[ty][e.to]&=can[ty][now];

         }

     }

 }

 qnode list[maxn];

 int main()

 {

     scanf("%d%d%d%d",&n,&m,&s,&t);

     for (int i=,x,y,v;i<=m;i++)

     {

         scanf("%d%d%d",&x,&y,&v);

         g.insert(x,y,v);

     }

     g.dijkstra(s,dis[],f[]); g.dijkstra(t,dis[],f[]);

     if (dis[][t]==1e18) {printf("%lld\n",1ll*n*(n-)/); return ;}

     for (int i=;i<=n;i++) can[][i].set(),can[][i].set(),can[][i][i]=can[][i][i]=;

     toposort(); toposort();

     for (int i=;i<=n;i++) if (dis[][i]+dis[][i]!=dis[][t]) val[i]=; else val[i]=f[][i]*f[][i];

     for (int i=;i<=n;i++) list[i]=((qnode){i,val[i]});

     sort(list+,list++n);

     list[n+].v=1e18;

     for (int i=,j=;i<=n+;i++) if (list[i].v!=list[i-].v)

     {

         int now=j;

         for (;j<i;j++) where[now][list[j].id]=;

     }

     LL ans=;

     for (int i=;i<=n;i++)

     {

         int L=,R=n+; LL tmp=f[][t]-val[i];

         while (L<R)

         {

             int mid=(L+R)>>;

             if (list[mid].v>=tmp) R=mid;

             else L=mid+;

         }

         if (L!=n+) ans+=(where[L]&can[][i]&can[][i]).count();

     }

     printf("%lld\n",ans/);

     return ;

 }