Layout(POJ 3169)

POJ 3169 Layout

题目大意

约翰养了$N$头牛，编号从$1$到$N$，现在，它们要进食，按照编号顺序排成一排。牛之间存在一些关系，所以希望彼此之间至少要满足某个距离，此外，可能存在多头牛挤在同一个位置上。现在有$ML$个关系好的牛的信息$(AL,BL,DL)$以及$MD$个关系不好的牛的信息$(AD,BD,DD)$。这表示的是牛$AL$与$BL$之间的最大距离$DL$和牛$AD$ 与$BD$之间的最小距离$DD$。在满足这些条件的排列方法中，求$1$号牛和$N$号牛之间的最大距离，如果不存在任何一种排列方法满足条件则输出$-1$，无限大的情况输出$-2$

限制条件

• $2\le N\le 1000$
• $1\le ML,MD\le 10000$
• $1\le AL<BL\le N$
• $1\le AD<BD\le N$
• $1\le DL,DD\le 1000000$

输入

第一行$3$个整数，$N，ML，MD$

接下来$ML$行，每行$3$个整数$A、B、D$表示牛$A$和牛$B$的距离最大不能超过$D$

接下来$MD$行，每行$3$个整数$A、B、D$表示牛$A$和牛$B$的距离最小不能低于$D$

输出

输出相应距离

样例输入

4 2 1
1 3 10
2 4 20
2 3 3

样例输出

27

根据差分约束系统可考虑按照如下规律建图

• 关系好的牛，直接正向建立相应的边，例如$1310$直接建立从顶点$1$指向顶点$3$权值为$10$的边(表示好感)
• 关系差的牛，返现建立，同时权值为相反数，例如$233$建立从顶点$3$指向顶点$2$权值为$-3$的边(表示关系差)
• 从大到小，相邻的边，由后指向前，权值为0(牛是按照编号站的)

根据样例建好之后如下
(顶点$3$指向$2$还有一条权值为$0$的边没有画出来)

根据这样的图，找从$1$出发到$n$的最短路径即可，有可能会出现负环(如果存在一个环从自己出发又回到自己，而且这个环上的权值之和为负数)，因此用$Bellman-Ford$算法

#include <iostream>
#include <cstdio>
#include <cstring>
#define M 10005
#define N 1005
#define INF 0x3f3f3f3f

using namespace std;
struct Edge {
	int from, to, cost;
} edge[M * 2];

int n, m;
int dis[N];

void BellmanFord (int s) {
	bool update;
	memset(dis, INF, sizeof(dis));
	dis[s] = 0;
	while (1) {
		update = 0;
		for (int i = 1; i <= m; i++) {
			if(dis[edge[i].to] > dis[edge[i].from] + edge[i].cost) {
				dis[edge[i].to] = dis[edge[i].from] + edge[i].cost;
				update = 1;
			}
		}
		if(!update) break;
	}
}

bool Find_Negative () { //检查负回路
	bool f = 0;
	memset(dis, 0, sizeof(dis)); //将距离全部初始为0，检查负值
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (dis[edge[j].to] > dis[edge[j].from] + edge[j].cost) {
				dis[edge[j].to] = dis[edge[j].from] + edge[j].cost;
				if (i == n) return 1;  //如果更新了n次，那么一定有负环
			}
		}
	}
	return 0;
}

int main () {
	int ml, md, u, v, cost;
	scanf("%d %d %d", &n, &ml, &md);
	for (int i = 1; i <= ml; i++) {
		scanf("%d %d %d", &u, &v, &cost);
		edge[++m].from = u;
		edge[m].to = v;
		edge[m].cost = cost;
	}
	for (int i = 1; i <= md; i++) { 
		scanf("%d %d %d", &u, &v, &cost);
		edge[++m].from = v;
		edge[m].to = u;
		edge[m].cost = -cost;
	}
	for (int i = 2; i <= n; i++) {
		edge[++m].from = i;
		edge[m].to = i - 1;
		edge[m].cost = 0;
	}
	if (Find_Negative()) {
		printf("-1");
		return 0;
	}
	BellmanFord(1);
	if(dis[n] == INF) dis[n] = -2;
	printf("%d", dis[n]);
	return 0;
}