uva 515 King（差分约束）

题意：
问是否存在一个序列，是的这个序列从 si ~ si+n 的和满足某个条件。求是否存在这样一个序列满足所有的约束条件。


解析：
差分约束系统：
如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如xj-xi <= bk(i,j∈[1,n],k∈[1,m]),则称其为差分约束系统(system of difference constraints)。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。


差分约束可以转化话单源最短路求解。
然后我们先来设定一个值Xi，Xi=a1+a2+a3……+ai ； 所以输入中是给出一个下标i和长度l，连续的子序列就是 ai+（ai+1）+（ai+2）……（ai+l）
那么显然就是等于  （Xi+l）-（Xi-1）  （长的连续和减去短的连续和，得到中间的部分），这样我们就构建出了差束约分里面的不等式
所以可以知道，虽然a序列标号是从1到n，但是X序列显然是从0到n标号的（想想就知道）
另外一个转化问题就是大于（小于）转化为大于等于（小于等于），因为说了所有数字都是整数所以这个转化很容易的


Xj-Xi>k   等价于  Xj-Xi >= k+1     Xj-Xi<k  等价于 Xj-Xi <= k-1      (因为都是整数所以可以这样做)
然后就是差束约分的有向图建图，这里是用了邻接表建图，可以处理掉平行边


最后一步，设置一个新源点Xn+1  （别忘了是从0到n标号的，所以只能设置n+1），和其余所有出现过的点相连，都是有向边，从Xn+1指向其他点，权值都是0

所以这样建图后，整个图一定是连通的，在没有负环的情况下一定有可行解，然后就是spfa求最短路，顺便判断负环，有负环就没有可行解，否则就有。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 205;
struct Edge {
	int from, to, dist;
	Edge(int u,int v,int d) {
		from = u;
		to = v;
		dist = d;
	}
};
struct Bellman {
	int n, m;
	vector<Edge> edges;
	vector<int> G[maxn];
	int d[maxn];
	int p[maxn];
	int inq[maxn], cnt[maxn];
	void init(int n) {
		this->n = n;
		for(int i = 0; i <= n; i++) {
			G[i].clear();
		}
		edges.clear();
	}
	void addEdge(int from, int to,int dist) {
		edges.push_back(Edge(from, to, dist));
		m = edges.size();
		G[from].push_back(m-1);
	}
	bool bellman_ford(int s) {
		queue<int> Q;
		memset(inq, 0, sizeof(inq));
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0; i <= n; i++) {
			d[i] = INF;
		}
		d[s] = 0;
		inq[s] = true;
		Q.push(s);
		while(!Q.empty()) {
			int u = Q.front();
			Q.pop();
			inq[u] = false;
			for(int i = 0; i < G[u].size(); i++) {
				Edge& e = edges[G[u][i]];
				if(d[u] < INF && d[e.to] > d[u] + e.dist) {
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					if(!inq[e.to]) {
						Q.push(e.to);
						inq[e.to] = true;
						if(++cnt[e.to] > n) {
							return false;
						}
					}
				}
			}
		}
		return true;
	}
};
int main() {
	Bellman bell;
	char op[4];
	int n, m;
	while(scanf("%d", &n) != EOF && n) {
		bell.init(n+2);
		scanf("%d", &m);
		while(m--) {
			int s, len, k;
			scanf("%d %d %s %d", &s, &len, op, &k);
			if(op[0] == 'g') {
				bell.addEdge(s-1, s+len, -k - 1);
			}else {
				bell.addEdge(s+len, s-1, k - 1);
			}
		}
		for(int i = 0; i <= n; i++) {
			bell.addEdge(n+1, i, 0);
		}
		if(bell.bellman_ford(n+1)) {
			puts("lamentable kingdom");
		}else {
			puts("successful conspiracy");
		}
	}
	return 0;
}