//
// Created by liyuanshuo on 2017/3/14.
//
#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

const int Max = 100010;
const int INF = 0x7fffffff;
int ns, ms;
int first[Max];
int ua[Max], va[Max], wa[Max], next[Max];

void read_graph( )
{
	std::cin>>ns>>ms;
	for (int i = 0; i < ns; ++i)
	{
		first[i] = -1;
	}
	for (int j = 0; j < ms; ++j)
	{
		std::cin>>ua[j]>>va[j]>>wa[j];
		next[j] = first[ua[j]];
		first[ua[j]] = j;
	}
}

struct Edage
{
	int from;
	int to;
	int dist;
	Edage( int u, int v, int d ) : from(u), to(v), dist(d) { }
};

struct HeapNode
{
	int d, u;
	bool operator < ( const HeapNode& rhs ) const
	{
		return d > rhs.d;
	}
};

struct Dijkstra
{
	int n, m;
	std::vector<Edage> edges;
	std::vector<int> G[Max];
	bool done[Max];
	int d[Max];
	int p[Max];
	
	void init( int n )
	{
		this->n = n;
		for (int i = 0; i < n ; ++i)
		{
			G[i].clear ();
		}
		edges.clear ();
	}
	
	void AddEdge( int from, int to, int dist )
	{
		edges.push_back (Edage(from, to, dist));
		m = edges.size ();
		G[from].push_back ( m-1 );
	}
	
	void dijkstra( int s )
	{
		std::priority_queue<HeapNode> Q;
		for (int i = 0; i < n; ++i)
		{
			d[i] = INF;
		}
		d[s] = 0;
		memset (done, 0, sizeof (done));
		Q.push ( (HeapNode){0,s});
		while ( !Q.empty ())
		{
			HeapNode x = Q.top ();
			Q.pop ();
			int u = x.u;
			if( done[u] )
				continue;
			done[u] = true;
			for (int i = 0; i < G[u].size (); ++i)
			{
				Edage& e = edges[G[u][i]];
				if( d[e.to] > d[u] + e.dist )
				{
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					Q.push ( (HeapNode) { d[e.to], e.to });
				}
			}
		}
	}
};