[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並且其長度<$len_p$。那麼將邊權變爲負數之後就是$len_k>len_p$,這個時候我們再跑SPFA的時候我們在s-1這個點去t的時候會走p，從t會選擇k的反向路徑回到s-1，由於$len_p<len_k$所以會有$len_p+(-len_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;
	}
}