POJ3159 最大差距（差分约束系统）

班上有n个同学，现在有一些糖要分给他们，设第i个同学得到的糖为p[i]，分糖必须满足条件：第i个同学要求第j个同学的糖不能超过自己k个，即p[j] - p[i] <= k，k >= 0。要求在满足这些条件的情况下，求出p[n] - p[1]的最大值。

由p[j] - p[i] <= k可得p[j] <= p[i] + k

在单源最短路径的算法中有一步是“若mindis[j] > mindis[i] + dis[i][j]，则mindis[j] = mindis[i] + dis[i][j]，这样就满足mindis[j] <= mindis[i] + dis[i][j]”。因此本题可以使用单源最短路径的算法来解决，对于“第i个同学要求第j个同学的糖不能超过自己k个，即p[j] - p[i] <= k，k >= 0”这个条件，建立一条边(i->j)=k，由于不含负权路径，因此建立完所有边之后以第1个同学为起点，采用Dijkstra+Heap求最短路径即可。除了Dijkstra也可以利用Spfa+Stack算法求解，但由于数据原因必须用Stack，如果用Queue则会超时。

Dijkstra+Heap:

#include <iostream>
#include <cstdio>
#include <climits>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 30005;
const int E = 150005;
const int MAX = 1000000000;

struct Edge
{
	int pnt;
	int dis;
	int next;
}edge[E];
int cur;
int neigh[N];
int n, e;
int mindis[N];
bool vis[N];
struct Qnode
{
	int pnt;
	int dis;
	Qnode(int _pnt, int _dis): pnt(_pnt), dis(_dis){}
	bool operator < (const Qnode& node) const
	{
		return dis > node.dis;
	}
};

void init()
{
	cur = 0;
	for (int i = 0; i < n; ++i) neigh[i] = -1;
}

void addedge(int beg, int end, int dis)
{
	edge[cur].pnt = end;
	edge[cur].dis = dis;
	edge[cur].next = neigh[beg];
	neigh[beg] = cur;
	++cur;
}

void dijkstra(int s)
{
	int pre, te, pnt;
	for (int i = 0; i < n; ++i)
	{
		mindis[i] = MAX;
		vis[i] = false;
	}
	mindis[s] = 0;
	vis[s] = true;
	priority_queue<Qnode> pq;
	pq.push(Qnode(s, 0));
	pre = s;
	for (int i = 1; i < n; ++i)
	{
		te = neigh[pre];
		while (te != -1)
		{
			pnt = edge[te].pnt;
			if (!vis[pnt] && mindis[pre] + edge[te].dis < mindis[pnt])
			{
				mindis[pnt] = mindis[pre] + edge[te].dis;
				pq.push(Qnode(pnt, mindis[pnt]));
			}
			te = edge[te].next;
		}
		while (!pq.empty() && vis[pq.top().pnt]) pq.pop();
		pre = pq.top().pnt;
		vis[pre] = true;
		pq.pop();
	}
}

int main()
{
	int beg, end, dis;
	scanf("%d%d", &n, &e);
	init();
	for (int i = 0; i < e; ++i)
	{
		scanf("%d%d%d", &beg, &end, &dis);
		--beg;
		--end;
		addedge(beg, end, dis);
	}
	dijkstra(0);
	printf("%d\n", mindis[n - 1]);
	return 0;
}

Spfa+Stack:

#include<iostream>
#include<stack>
#include<algorithm>
using namespace std;
const int MAXN = 30005;
const int INF = 9999999;
const int MAXE = 150005;
typedef struct Edge
{
	int v, w;
	int next;
}Edge;

Edge edge[MAXE];
int dist[MAXN], adj[MAXN];
bool in_s[MAXN];
int size, n, m;
void add_edge(int u, int v, int w)
{
	edge[size].v = v;
	edge[size].w = w;
	edge[size].next = adj[u];
	adj[u] = size++;
}
void spfa()
{
	int i, u, v, w;
	int sta[MAXN];
	int top=0;
	memset(in_s, false, sizeof(in_s));
	memset(dist, INF, sizeof(dist));
	sta[++top] = 1;
	dist[1] = 0;
	in_s[1] = true;
	while (top)
	{
		u = sta[top--];
		in_s[u] = false;
		for (i=adj[u]; i!=-1; i=edge[i].next)
		{
			v = edge[i].v;
			w = edge[i].w;
			if (dist[v]>dist[u]+w)
			{
				dist[v] = dist[u] + w;
				if (!in_s[v])
				{
					in_s[v] = true;
					sta[++top] = v;
				}
			}
		}
	}
}
int main()
{
	int i, a, b, c;
	scanf ("%d %d", &n, &m);
	for (i=0; i<=n; i++) adj[i] = -1;
	size = 0;
	for (i=0; i<m; i++)
	{
		scanf("%d %d %d", &a, &b, &c);
		add_edge(a, b, c);
	}
	spfa();
	printf ("%d\n", dist[n]);
	return 0;
}