Candies POJ - 3159 （差分约束）

题目链接
题意：
已知n个点和m条关系，每条关系包含a,b,c三个整数，表示：d[b]-d[a]<=c，求d[n]-d[1]的最大值。

如若一个系统由n个变量和m个不等式组成，并且这m个不等式对应的系数矩阵中每一行有且仅有一个1和-1，其它的都为0，这样的系统称为差分约束系统。
说人话：关系式都是 d[i]-d[j]<=a[k]的形式。
令 w(j,i)=a[k]，再移项可以得到 d[j]+w(j,i)>=d[i],是不是感觉似曾相识，迪杰斯特拉算法的松弛操作：

if(d[u]+w(u,v)<d[v]) d[v]=d[u]+w(u,v)

虽然这两个不等式的符号相反，但是迪杰斯特拉的松弛操作是在满足小于的情况下进行松弛，力求达到d[u] + w(u, v) >= d[v]，逻辑是一致的。
所以我们可以将每个不等式转化成图上的有向边：
对于每个不等式 d[i] - d[j] <= a[k]，对建一条j到i的边权为a[k]的有向边，求d[n] - x[1] 的最大值就是求 1 到n的最短路。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N=1500010;
int t,n,m,a[N],b[N],c[N];
int h[N],e[N],ne[N],w[N],idx;
void add(int a,int b,int c)
{
	e[idx]=b;ne[idx]=h[a];w[idx]=c;h[a]=idx++;
}
int dist[N];
bool st[N];
void dij()
{
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	priority_queue<pii,vector<pii>,greater<pii> > q;
	q.push({0,1});
	while(q.size())
	{
		int u=q.top().second;
		q.pop();
		if(st[u]) continue;
		st[u]=1;
		for(int i=h[u];i!=-1;i=ne[i])
		{
			int v=e[i];
			if(dist[v]>w[i]+dist[u])
			{
				dist[v]=w[i]+dist[u];
				q.push({dist[v],v}); 
			}
		}
	}
	return ;
}

int main()
{

	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) h[i]=-1;
	idx=0;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",a+i,b+i,c+i);
		add(a[i],b[i],c[i]);
	}
	dij();
	printf("%d\n",dist[n]);
	return 0;
}

如果关系式中有 d[i]-d[j]=a[k]呢？ 拆分为
d[i]-d[j]<=a[k] 和 d[i]-d[j]>=a[k] ( d[j]-d[i]<=-a[k] ) 分别建边即可。

如果是关系式都是 d[i]-d[j]>=a[k] 呢？
化简后就是 d[j]+w(j,i)<=d[i] 求1到n的最长路即可。
或者转化为 d[j]-d[i]<=-a[k]再建边，和求最长路时全部建负权边一致。

参考博客：https://blog.csdn.net/whereisherofrom/article/details/78922648