[HNOI2005]狡猾的商人：一题两解

题目链接

题目大意：
一段区间，给定m个信息，每个信息表示一段子区间中的区间和，问你这个区间是否合法（也就是说是否存在这种区间）

第一种解法：差分约束：

由于是一段区间和，那我们不妨把它看成是前缀和形式的两个相减。然后将它用差分约束的方式转换成一张图，那么这个区间是否合法就变成了这张图上是否有最短路，就变成了用SPFA判负环的问题。

1.建图：
对于一条信息：$a_t-a_s==x(t>=s)$那么就可以变为从s-1到t有一条长度为x的边，然后这条边必须在s-1到t的最短路径中。

那么如何判断是否合法呢？这里有一个技巧就是将边反向，边权变为原来的相反数然后判负环。

证明：如果这条边p不在从s-1到t的最短路中，那么一定有一条路径k（注意，这是路径，有可能是由多条边合在一起组成）从s-1到t并且其长度<$le{n}_p$。那么将边权变为负数之后就是$le{n}_k>le{n}_p$,这个时候我们再跑SPFA的时候我们在s-1这个点去t的时候会走p，从t会选择k的反向路径回到s-1，由于$le{n}_p<le{n}_k$所以会有$le{n}_p+(-le{n}_k)<0$，这时候就构成了一个负环。

如何用SPFA判负环？

我们用$cnt[i]$表示在搜最短路的时候i这个点入队列（也就是访问）多少次。
如果$i>=n$那我们就找到了一个负环。具体关于差分约束与SPFA算法请自行学习。

下附AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int read(){
	char s;
	int x=0,f=1;
	s=getchar();
	while(s<'0'||s>'9'){
		if(s=='-')f=-1;
		s=getchar();
	}
	while(s>='0'&&s<='9'){
		x*=10;
		x+=s-'0';
		s=getchar();
	}
	return x*f;
}
int w;
int n,m;
struct edge{
	int to,next,len;
}e[2020];
int eid=0,head[1010];
void insert(int u,int v,int l){
	eid++;
	e[eid].to=v;
	e[eid].len=l;
	e[eid].next=head[u];
	head[u]=eid;
}
bool vis[110];
int cnt[110];
int dist[110];
bool spfa(){
	queue<int>q;
	q.push(0);
	vis[0]=1;
	dist[0]=0;
	while(!q.empty()){
		int k=q.front();
		q.pop();
		vis[k]=0;
		for(int i=head[k];i+1;i=e[i].next){
			int x=e[i].to;
			if(dist[x]>dist[k]+e[i].len){
				dist[x]=dist[k]+e[i].len;
				if(!vis[x]){
					vis[x]=1;
					cnt[x]++;
					q.push(x);
				}
				if(cnt[x]>=n)return false;
			}
			
		}
	}
	return true;
}
int main(){
	w=read();
	while(w--){
		memset(vis,0,sizeof(vis));
		memset(cnt,0,sizeof(cnt));
		memset(e,0,sizeof(e));
		memset(dist,0x3f3f3f3f,sizeof(dist));
		memset(head,-1,sizeof(head));
		eid=0;
		n=read();
		m=read();
		for(int i=1;i<=m;i++){
			int a,b,c;
			a=read();
			b=read();
			c=read();
			if(a>b)swap(a,b);
			insert(a-1,b,c);
			insert(b,a-1,-c);
		}
		if(spfa()){
			printf("true\n");
		}
		else printf("false\n");
	}
} 

第二种解法：带权并查集

好处：上面的差分约束我们每一条信息转化为一条边然后跑最短路，但是带权并查集可以一边读入信息一边处理判断，这样的话省去最短路的时间后，时间会变得更快。
85ms / 784.00KB / 748B C++ 带权并查集
265ms / 820.00KB / 1.37KB C++ 差分约束

下面我们开始介绍这种解法。

1.带权并查集：
与并查集类似，只不过我们在合并过程中带一个权值

sum[x]表示的是中x到其祖先这段区间的和

注意：我们合并的时候是永远用输入信息中的两个点靠后的去合并到靠前的，而不是祖先节点。所以虽然说我们是相对靠后的合并到相对靠前的，但是并不代表一个点的祖先节点一定比这个点靠后。

下附AC代码：

#include<iostream>
#include<cstring>

using namespace std;
int w;
int n,m;
int f[110];
int sum[110];
int flag=1;
int get(int x){
	if(x==f[x])return x;
	int tmp=get(f[x]);
	sum[x]+=sum[f[x]];
	f[x]=tmp;
	return tmp;
}
void merge(int a,int b,int c){
	int fa=get(a);
	int fb=get(b);
	if(fa==fb){
		if(sum[b]-sum[a]!=c)flag=0;
	}
	else{
		f[fb]=fa;
		sum[fb]=sum[a]+c-sum[b];
	}
	return;
}
int main(){
	ios::sync_with_stdio(0);
	cin>>w;
	while(w--){
		cin>>n>>m;
		for(int i=0;i<=n;i++){
			f[i]=i;
		}
		memset(sum,0,sizeof(sum));
		flag=1;
		for(int i=1;i<=m;i++){
			int a,b,c;
			cin>>a>>b>>c;
			if(a>b)swap(a,b);
			merge(a-1,b,c);
		}
		if(flag)cout<<"true"<<endl;
		else cout<<"false"<<endl;
	}
}