bzoj4500 矩阵 差分约束系统

Description

---

有一个n*m的矩阵，初始每个格子的权值都为0，可以对矩阵执行两种操作：
1.选择一行，该行每个格子的权值加1或减1。
2.选择一列，该列每个格子的权值加1或减1。
现在有K个限制，每个限制为一个三元组(x,y,c)，代表格子(x,y)权值等于c。
问是否存在一个操作序列，使得操作完后的矩阵满足所有的限制。
如果存在输出”Yes”，否则输出”No”。

先输入一个T(T <= 5)代表输入有T组数据，每组数据格式为：
第一行三个整数n, m, k (1 <= n, m,k <= 1000)。
接下来k行，每行三个整数x, y, c。

Solution

---

我是谁，差分约束是啥，这是哪

考虑记行操作为x[]，列操作为y[]，那么一个限制等价于x[i]+y[j]=c
转换一下就是x[i]-(-y[j])<=c，-y[j]-x[i]<=-c
注意到这个和最短路的松弛条件很像，即最短路上满足dis[y]-dis[x]<=w[x][y]
那么对于这种形式的限制连边y[j]到x[i]跑最短路就行了。不需要输出方案就判环嘛

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#define rep(i,st,ed) for (int i=st;i<=ed;++i) 
#define fill(x,t) memset(x,t,sizeof(x))

const int N=4005;
const int E=10005;

struct edge {int y,w,next;} e[E];

bool vis[N];

int dis[N],cnt[N];
int ls[N],edCnt;

int read() {
	int x=0,v=1; char ch=getchar();
	for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
	for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
	return x*v;
}

void add_edge(int x,int y,int w) {
	e[++edCnt]=(edge) {y,w,ls[x]}; ls[x]=edCnt;
}

bool spfa(int st) {
	std:: queue <int> que;
	vis[st]=true; dis[st]=0;
	bool ret=false;
	for (que.push(st);!que.empty();) {
		int now=que.front(); que.pop();
		if (++cnt[now]==1000) return true;
		for (int i=ls[now];i;i=e[i].next) {
			if (dis[now]+e[i].w<dis[e[i].y]) {
				dis[e[i].y]=dis[now]+e[i].w;
				if (!vis[e[i].y]) {
					que.push(e[i].y); vis[e[i].y]=true;
				}
			}
		} vis[now]=false;
	}
	return false;
}

int main(void) {
	for (int T=read();T--;) {
		edCnt=0; fill(ls,0); fill(vis,0);
		int n=read(),m=read(),k=read();
		rep(i,1,k) {
			int x=read(),y=read(),c=read();
			add_edge(y+n,x,c);
			add_edge(x,y+n,-c);
		}
		fill(dis,63); fill(cnt,0);
		bool flag=false;
		rep(i,1,n+m) if (dis[i]==dis[0]) {
			flag|=spfa(i);
		}
		flag?puts("No"):puts("Yes");
	}
	return 0;
}