POJ1275 Cashier Employment

题意：给定一个公司24小时每个小时需要的员工数量ri，有n（0 <= n <= 1000）个员工可以任用，员工i可以从给定时间开始连续工作8个小时，问至少任用几名员工，若无解，输出No Solution.

分析：

这是一道差分约束的题，我们用f(i)来表示前i个小时任用的总员工数量，不难得出f(i) - f(i-1) >= 0，然后我们用t(i)来表示所有人中从i时刻开始工作的员工的数量，则不难得出第二个不等式f(i) - f(i-1) <= t(i)，变一下形为f(i-1) - f(i) >= -t(i).

考虑每个小时的需求r(i)，当7 <= i <= 23时，当前时刻工作的员工数量为f(i) - f(i-8)，所以不难得出第三个不等式f(i) - f(i-8) >= r(i)，当0 <= i <= 6时，因为可以跨天，举个例来说，3时刻任用的人，等于20时刻，21时刻...23时刻，0时刻，1时刻...3时刻任用的人的和，用f(23) - f(3 +16)可以表示上一天20-23时刻的人，加上f(3)，其值大于r(3)，即f(23) - f(i+16) + f(i) >= r(i)，变形得f(i) - f(i+16) >= r(i) - f(23)，得出第四个不等式。

差分约束要求右边是一个常量，但很明显f(23)是个变量，怎么办呢？显然这满足二分性质，我们可以二分答案，初始左端点可以选成r(i)的最大值，右端点选成n.

说一说差分约束建图的过程：

首先就是可能会涉及到f(-1)，所以我把原题的时间从1开始标号，到24.

上面的4个不等式我都变形成了>=，所以要求最长路，带正权，所以不能用Dijkstra，用SPFA.

建图主要就是对于a-b >= c这个不等式，由b向a连一条权值为c的边。

二分的时候右端点选成n+1，这样如果最后l == n+1，说明无解，也可以选成n，然后最后判断一下左端点的数是否可以。

对于第四个不等式，我把它放到了边集合的末尾，这样每次二分的时候我就可以方便修改。

还有第五个不等式，就是f(23) - f(-1) >= 二分的值，因为这里二分的值是有实际意义的，不添加这个不等式不能保证f(23)的值。

之后是定义虚根，这道题以0为虚根就可以，或者新开一个25的虚根也没问题。

最后是跑SPFA判负环，方法有两种，第一种是记录每个点的进队次数，如果> n就说明有负环，较慢；第二种是记录每个点的更新次数， 如果> n就说明有负环，较快，这里采用第二种。

最后就是多组数据记得清空各种东西。

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;

int T, n, m, x, maxv, r[30], t[30];

struct Edge {
	int to, dist;
};

struct SPFA {
	int d[30], len[30];
	bool inq[30];
	vector<Edge> edge;
	vector<int> G[30];
	
	bool spfa(int s) {
		queue<int> q;
		memset(inq, 0, sizeof inq);
		q.push(s);
		inq[s] = 1;
		for(int i = 1; i <= 24; i++) d[i] = -100000000;
		d[s] = 0;
		memset(len, 0, sizeof len);
		while(!q.empty()) {
			int u = q.front(); q.pop();
			inq[u] = 0;
			for(int i = 0; i < G[u].size(); i++) {
				Edge &e = edge[G[u][i]];
				if(d[e.to] < d[u] + e.dist) {
					d[e.to] = d[u] + e.dist;
					len[e.to]++;
					if(len[e.to] > n) return false;
					if(!inq[e.to]) q.push(e.to), inq[e.to] = 1;
				}
			}
		}
		return true;
	}
}g;

void add(int x, int y, int z) {
	g.edge.push_back((Edge){y, z});
	g.G[x].push_back(m++);
}

bool ok(int x) {
	for(int i = g.edge.size()-7; i < g.edge.size(); i++) g.edge[i].dist = r[i-g.edge.size()+8] - x;
	g.edge[0].dist = x;
	return g.spfa(0);
}

int main() {
	scanf("%d", &T);
	while(T--) {
		m = 0, maxv = 0;
		g.edge.resize(0);
		memset(t, 0, sizeof t);
		for(int i = 1; i <= 24; i++) scanf("%d", &r[i]), maxv = max(maxv, r[i]);
		scanf("%d", &n);
		for(int i = 1; i <= n; i++) scanf("%d", &x), t[x+1]++;
		add(0, 24, 0);
		for(int i = 1; i <= 24; i++) add(i-1, i, 0), add(i, i-1, -t[i]);
		for(int i = 8; i <= 24; i++) add(i-8, i, r[i]);
		for(int i = 1; i < 8; i++) add(i+16, i, r[i]);
		int l = maxv, r = n+1;
		while(l < r) {
			int mid = (l + r) >> 1;
			if(ok(mid)) r = mid;
			else l = mid + 1;
		}
		if(l != n+1) printf("%d\n", l);
		else printf("No Solution\n");
	}
	return 0;
}