#include <iostream>

#include <cstdio>

#include <cmath>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <queue>

#define N 100005

#define M 400005

#define INF 0x7FFFFFFF

using namespace std;

inline int read(){

	int ret=0;char ch=getchar();

	while (ch<'0' || ch>'9') ch=getchar();

	while ('0'<=ch && ch<='9'){

		ret=ret*10-48+ch;

		ch=getchar();

	}

	return ret;

}

struct STnode{

	int l,r;

	int tag;

};

int a[N];

struct SegmentTree{

	STnode t[4*N];

	void PushDown(int x){

		if (t[x].l==t[x].r) return;

		if (t[x].tag==INF) return;

		t[x<<1].tag=min(t[x<<1].tag,t[x].tag);

		t[x<<1^1].tag=min(t[x<<1^1].tag,t[x].tag);

		t[x].tag=INF;

	}

	void build(int x,int l,int r){

		t[x].l=l;t[x].r=r;t[x].tag=INF;

		if (l==r) return;

		int mid=(l+r)/2;

		build(x<<1,l,mid);

		build(x<<1^1,mid+1,r);

	}

	void modify(int x,int l,int r,int value){

		PushDown(x);

		if (l<=t[x].l&&t[x].r<=r){

			t[x].tag=min(t[x].tag,value);

			return;

		}

		int mid=(t[x].l+t[x].r)/2;

		if (l<=mid) modify(x<<1,l,r,value);

		if (r>mid) modify(x<<1^1,l,r,value);

	}

	int getans(int x){

		if (t[x].l==t[x].r){a[t[x].l]=t[x].tag;return t[x].tag;}

		PushDown(x);

		return max(getans(x<<1),getans(x<<1^1));

	}

} st;

struct edge{

	int adj,next,len;

	int id;

	edge(){}

	edge(int _adj,int _next,int _len):adj(_adj),next(_next),len(_len){}

} e[M];

int n,g[N],m;

void AddEdge(int u,int v,int w){

	e[++m]=edge(v,g[u],w);g[u]=m;

}

struct HeapNode{

	int pos,value;

	HeapNode(){}

	HeapNode(int _pos,int _value):pos(_pos),value(_value){}

};

bool operator >(const HeapNode &x,const HeapNode &y){

	return x.value>y.value;

}

priority_queue<HeapNode,vector<HeapNode> ,greater<HeapNode> > h;

int fa[N];

int mind[N];

bool flag[N];

int from[N];

void dijkstra(int _s){

	memset(mind,127,sizeof(mind));

	memset(flag,0,sizeof(flag));

	h.push(HeapNode(_s,mind[_s]=0));

	fa[_s]=from[_s]=0;

	while (!h.empty()){

		int u=h.top().pos;

		h.pop();

		flag[u]=1;

		for (int i=g[u];i;i=e[i].next){

			int v=e[i].adj;

			if (mind[v]>mind[u]+e[i].len){

				mind[v]=mind[u]+e[i].len;

				h.push(HeapNode(v,mind[v]));

				fa[v]=u;from[v]=i;

			}

		}

		while (!h.empty()&&flag[h.top().pos]) h.pop();

	}

}

int deep[N];

void dfs(int u){

	for (int i=g[u];i;i=e[i].next){

		int v=e[i].adj;

		if (!deep[v]) deep[v]=deep[u];

		dfs(v);

	}

}

void rebuild(){

	memset(deep,0,sizeof(deep));

	deep[n]=1;

	for (int i=n;fa[i];i=fa[i]) deep[fa[i]]=deep[i]+1;

	memset(g,0,sizeof(g));m=1;

	for (int i=2;i<=n;++i) AddEdge(fa[i],i,0);

	dfs(1);

}

int u[M],v[M],w[M];

int dist[N];

int main(){

	n=read();int m0=read();

	memset(g,0,sizeof(g));m=1;

	for (int i=1;i<=m0;++i){

		u[i]=read();v[i]=read();w[i]=read();

		AddEdge(u[i],v[i],w[i]);e[m].id=i;

		AddEdge(v[i],u[i],w[i]);e[m].id=i;

	}

	dijkstra(n);

	for (int i=1;i<=n;++i) dist[i]=mind[i];

	dijkstra(1);

	for (int i=2;i<=n;++i) w[e[from[i]].id]=0;

	rebuild();

	st.build(1,1,deep[1]-1);

	for (int i=1;i<=m0;++i)if (w[i]){

		if (deep[u[i]]>deep[v[i]]) swap(u[i],v[i]);

		int x=deep[u[i]],y=deep[v[i]];

		if (x==y) continue;

		st.modify(1,x,y-1,dist[u[i]]+w[i]+mind[v[i]]);

	}

	int ans=st.getans(1),cnt=0;

	for (int i=1;i<deep[1];++i) cnt+=(a[i]==ans);

	printf("%d %d\n",ans,ans==mind[n]?m0:cnt);

	return 0;

}