Dijkstra

#include<cstdio>
#include<queue>
#include<string>
#include<sstream>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int INF = 1000000000;
const int maxn = 100010; 

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

vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
int d[maxn];

int n, m;

void init()
{
	freopen("practicein.txt","r",stdin);
	freopen("practiceout.txt","w",stdout);
}

void readdata()
{
	cin >> n >> m;
	int u, v, w;
	for(int i = 0; i < m; i++)
	{
		cin >> u >> v >> w;
		edges.push_back(Edge(u, v, w));
		G[u].push_back(i);
	}
}

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

void dijkstra(int s)
{
	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++)
		{
			Edge& e = edges[G[u][i]];
			if(d[e.to] > d[u] + e.dist)
			{
				d[e.to] = d[u] + e.dist;
				q.push((heapnode){d[e.to],e.to});
			}
		}
	}
}

void work()
{
	int s;
	dijkstra(s);
}

int main()
{
	init();
	readdata();
	work();
	return 0;
}