工程规划——差分约束

前置芝士

一、差分

我们都说差分相当于前缀和的逆向操作，但是差分真正应该怎么用呢？

假设数组a：a[1], a[2], a[3],,,,,, a[n];

然后我们构造一个数组b ： b[1] ,b[2] , b[3],,,,,, b[i];

使得 a[i] = b[1] + b[2 ]+ b[3] +,,,,,, + b[i]

也就是说，a数组是b数组的前缀和数组，反过来我们把b数组叫做a数组的差分数组。换句话说，每一个a[i]都是b数组中从头开始的一段区间和。

此时问题是：我们要对一维数组进行 m 次区间修改，此时如果正常做复杂度高达 m * (  r  - l ）

但是考虑原数组是差分数组的前缀和，那么我改一个差分数组就可以影响到所有在他之后的原数组。所以跟前缀和差不多，区间修改时把 b [ l ] + c , b [ r +1 ] - c即可。

二、差分约束

差分约束说起来就要放到图论里了，系统本质是n元一次不等式组。【来自OI Wiki】

 那么之所以说这时图论，就是因为这很像单源最短路里的DP属性，并且让电脑像高斯消元一样规规矩矩地解不等式也不太可能

#include<bits/stdc++.h>
using namespace std;
const int N=100010,M=500010;
struct edge{int to,next,w;} e[M];
int head[N],dis[N];
int n,m,k,cnt;
bool vis[M];
void add_edge(int u,int v,int w)
{
	cnt++;
	e[cnt].w=w;
	e[cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
struct node
{
	int dis,pos;
	bool operator <( const node &x ) const
	{ return x.dis<dis; }
};
priority_queue<node> q;
void dijkstra()
{
	dis[k]=0;
	q.push((node){0,k});
	while(!q.empty())
	{
		node tmp=q.top();
		q.pop();
		int x=tmp.pos;
		if(vis[x]) continue;
		vis[x]=1;
		for(int i=head[x];i;i=e[i].next)
		{
			int y=e[i].to;
			if(dis[y]>dis[x]+e[i].w)
			{
				dis[y]=dis[x]+e[i].w;
				if(!vis[y]) q.push((node){dis[y],y});
			}
		}
	}
}

int main()
{
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;++i) dis[i]=0x7fffffff;
	for(int i=1;i<=m;++i)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		add_edge(u,v,w);
	}
	dijkstra();
	for(int i=1;i<=n;i++) printf("%d ",dis[i]);
	return 0;
}

虽然灵感来自Dij，但是真正做的时候还是要用SPFA之类可以判负环的算法，因为负环往往意味着无解dalao的证明

一般题目会有三种情况：①求最短路 ②求最长路 ③判断差分约束系统的解是否存在

前两种情况中，求最短路要化成 ，最长路则不等号相反

值得注意的一点是：建立的图可能不联通，我们只需要加入一个超级源点，比如说求取最长路时图不联通的话，我们只需要加入一个点S，对其他的每个点建立一条权值为0的边图就联通了，然后从S点开始进行spfa判环。最短路类似。摘自差分约束系统

例题：工程规划

从题面上至少可以看出是差分约束或者咕咕上标签写到，整体来说最需要注意的是SPFA里的初始化 “ q . p u s h ( 0 ) ; ” 、f l a g [ 0 ] = 1 、最后minn初始化为0、传参建边的时候"add_edge(v,u,w)"

#include<bits/stdc++.h>
using namespace std;
const int N=1010,M=10010;
int n,m,dis[N],flag[N],sum[N];
int head[N],cnt;
queue<int>q;
struct edge{int to,nxt,w;}e[M];
void add_edge(int u,int v,int w)
{
	e[++cnt].to=v;
	e[cnt].nxt=head[u];
	e[cnt].w=w;
	head[u]=cnt;
}
void SPFA()
{
	memset(dis,0x3f3f3f,sizeof dis);
	dis[0]=0;
	q.push(0);
	flag[0]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		flag[u]=0;
		sum[u]++;
		if(sum[u]>=n)//负环 
		{
			cout<<"NO SOLUTION";
			return;
		}
		for(int i=head[u];i;i=e[i].nxt)
		{
			int v=e[i].to;
			int val=e[i].w;
			if(dis[u]+val<dis[v])
			{
				dis[v]=dis[u]+val;
				if(!flag[v])
				{
					q.push(v);
					flag[v]=1;
				}
			}
		}
	}
	int minn=0;
	for(int i=1;i<=n;i++) minn=min(minn,dis[i]);
	for(int i=1;i<=n;i++) cout<<dis[i]-minn<<endl; 
}

int main()
{
	std::ios::sync_with_stdio(0);
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		int u,v,w;
		cin>>u>>v>>w;
		add_edge(v,u,w);
	}
	for(int i=1;i<=n;i++) add_edge(0,i,0);//超级源点
	SPFA(); 
	return 0;
}