差分约束专题

最新推荐文章于 2022-05-24 19:17:12 发布
最新推荐文章于 2022-05-24 19:17:12 发布
阅读量129 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bloom_er/article/details/113251333
版权

关于差分约束的相关定义，这篇博客推荐看一下 何为差分约束
接下来通过些题目来实战一下
layout-POJ 3169
House Man-HDU 3440
Intervals-POJ 1201
Kings-POJ 1364
THE MATRIX PROBLEM-HDU 3666
Is the Information Reliable?-POJ 2983
Cashier Employment-HDU 1529
Spy’s Work-HDU 4274

layout

layout poj-3169
这题有两个不等式要求：
对于ML个关系，有 S B − S A ≤ w S_B-S_A\le w SB​−SA​≤w
对于MD个关系，有 S B − S A ≥ w S_B-S_A\ge w SB​−SA​≥w
其中 S i S_i Si​ 表示 i i i 到原点的距离。由于题目还有另外两种情况，

  • 无解则输出-1，无解便是跑spfa出现负圈的情况
  • 无穷大则输出-2，便是通过以上关系并不能更新到第n个点，则说明第n点不受上述条件的限制。

这题算是差分约束的入门题，只有两种基本的关系，在写代码的时候需要进行下转换,使所有式子的不等于号方向统一：

  • 仅有 S B − S A ≤ w S_B-S_A\le w SB​−SA​≤w 与 S A − S B ≤ − w S_A-S_B\le -w SA​−SB​≤−w ，这个时候相当于求最短路
  • 仅有 S A − S B ≥ − w S_A-S_B\ge -w SA​−SB​≥−w 与 S B − S A ≥ w S_B-S_A\ge w SB​−SA​≥w ，这个时候相当于求最长路

代码如下，选取了求最短路的情况：

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N], neg[N];
int spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	queue<int>que;
	que.push(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					que.push(v);
					inq[v] = true;
					++neg[v];
					if (neg[v] >= n) {
						return -1;
					}
				}
			}
		}
	}
	if (dis[n] == inf) return -2;
	return dis[n];
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0;
	while (~scanf("%d", &n)) {
		memset(head, -1, sizeof(int) * (n + 10)); cntE = 0;
		rd(m); int m1; rd(m1);
		while (m--) {
			int x, y, w;
			rd(x), rd(y), rd(w);
			add(x, y, w);
		}
		while (m1--) {
			int x, y, w;
			rd(x), rd(y), rd(w);
			add(y, x, -w);
		}
		printf("%d\n", spfa(1));
	}
}

附带一题 HDU-3592
思路跟本题一模一样，可以更深入去理解。

House Man

HDU-3440
这道题的不等式有两种：

  • S i + 1 − S i ≥ 1 S_{i+1}-S_i\ge1 Si+1​−Si​≥1
  • S s o r t ( i + 1 ) − S s o r t ( i ) ≤ D S_{sort(i+1)}-S_{sort(i)}\le D Ssort(i+1)​−Ssort(i)​≤D

其中第二项是根据高度排完序之后的顺序，满足每次跳跃的距离 ≤ D \le D ≤D
将不等式符号化成同一方向后直接建图即可。
代码如下：

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N], neg[N];
int h[N], id[N];
int spfa(int st,int ed) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	queue<int>que;
	que.push(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					que.push(v);
					inq[v] = true;
					++neg[v];
					if (neg[v] >= n) {
						return -1;
					}
				}
			}
		}
	}
	if (dis[ed] == inf) return -2;
	return dis[ed];
}

int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
	rd(T);
	while(T--){
//	while (~scanf("%d", &n)) {
		rd(n); int k; rd(k);
		memset(head, -1, sizeof(int) * (n + 10)); cntE = 0;
		for (int i = 1; i <= n; ++i) rd(h[i]);
		for (int i = 1; i < n; ++i) add(i + 1, i, -1);
		for (int i = 1; i <= n; ++i) id[i] = i;
		sort(id + 1, id + 1 + n, [](const int& a, const int& b) {
			return h[a] < h[b];
			});
 		for (int i = 1; i < n; ++i) {
			add(min(id[i], id[i + 1]), max(id[i], id[i + 1]), k);
		}
		printf("Case %d: %d\n", ++cas, spfa(min(id[1], id[n]), max(id[1], id[n])));
	}
	return 0;
}

Intervals

POJ-1201
这题需要将区间表示成前缀和的差值
如： [ L , R ] [L,R] [L,R] 中需要至少 x x x 个数，表示成 S R − S L − 1 ≥ x S_R-S_{L-1}\ge x SR​−SL−1​≥x
所以本题的不等式关系有：

  • S R − S L − 1 ≥ x S_R-S_{L-1}\ge x SR​−SL−1​≥x 这个是题目输入的关系。
  • 另外还有隐藏关系，第 i i i 数可选可不选，因此有 0 ≤ S i + 1 − S i ≤ 1 0\le S_{i+1}-S_{i}\le1 0≤Si+1​−Si​≤1

将不等式符号转换成同一方向建边跑 s p f a spfa spfa 即可

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N], neg[N];
int h[N], id[N];
int spfa(int st,int ed) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, -inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	queue<int>que;
	que.push(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] < dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					que.push(v);
					inq[v] = true;
					++neg[v];
					if (neg[v] >= n) {
						return -1;
					}
				}
			}
		}
	}
	if (dis[ed] == inf) return -2;
	return dis[ed];
}

int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
//	rd(T);
//	while(T--){
	ed = 6e4;
	while (~scanf("%d", &n)) {
		memset(head, -1, sizeof(int) * (200000 + 10)); cntE = 0;
		int maxn = 0;
		for (int i = 1; i <= n; ++i) {
			int l, r, w; rd(l), rd(r), rd(w);
			++r; //避免l-1后变成-1，便选择将r+1
			add(l, r, w);
			maxn = max(maxn, r);
		}
		for (int i = 1; i <= maxn; ++i) {
			add(i - 1, i, 0);
			add(i, i - 1, -1);
		}
		printf("%d\n", spfa(0,maxn));
	}
	return 0;
}

King

POJ-1364
这题题面有点难懂,下标的表示没写好，大致意思是：
有一个 a n a_n an​的序列，其中满足一些前缀和条件： a S i + a S i + 1 + a S i + 2 + . . . + a S i + n i a_{S_i}+a_{S_{i}+1}+a_{S_{i}+2}+...+a_{S_{i}+n_i} aSi​​+aSi​+1​+aSi​+2​+...+aSi​+ni​​ < \lt < 或者 > \gt > k i ki ki
所以这题有两种不等式：

  • 设 F ( i ) F(i) F(i) 为序列 a 1 到 a i a_1到a_i a1​到ai​ 的前缀和。有 F ( s i + n i ) − F ( s i − 1 ) < k i F(s_i+n_i)-F(s_i-1)\lt k_i F(si​+ni​)−F(si​−1)<ki​
    或者 F ( s i + n i ) − F ( s i − 1 ) > k i F(s_i+n_i)-F(s_i-1)\gt k_i F(si​+ni​)−F(si​−1)>ki​
  • 最后由于每一个 a i a_i ai​ 的范围是未知的，所以只能确立一个超级源点来连接所有的数，最终判断结果是否有负圈就行了
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N], neg[N];
int h[N], id[N];
bool spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	queue<int>que;
	que.push(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					que.push(v);
					inq[v] = true;
					++neg[v];
					if (neg[v] > n) {
						return true;
					}
				}
			}
		}
	}
	return false;
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
//	rd(T);
//	while(T--){
	while (scanf("%d", &n),n) {
		scanf("%d", &m);
		memset(head, -1, sizeof(int) * (n + 10)); cntE = 0;
		while (m--) {
			int l, r, w; char op[5];
			scanf("%d %d %s %d", &l, &r, op, &w);
			if (op[0] == 'g') add(r + l, l - 1, -w - 1);
			else add(l - 1, r + l, w - 1);
		}
		for (int i = 0; i <= n; ++i) {
			add(n + 1, i, 0);
		}
		if (!spfa(++n)) puts("lamentable kingdom");
		else puts("successful conspiracy");
	}
	return 0;
}

THE MATRIX PROBLEM

HDU-3666
这道题通过题目得出的不等式如下：
L ≤ C i j ∗ a i b j ≤ U L\le \frac{C_{ij}*a_i}{b_j}\le U L≤bj​Cij​∗ai​​≤U
这不等式并不符合差分约束的加减法形式，那就将他转换成加减法，对上面的式子取对数，最后转换成
ln ⁡ ( L C i j ) ≤ ln ⁡ ( a i ) − ln ⁡ ( b j ) ≤ ln ⁡ ( U C i j ) \ln(\frac{L}{C_{ij}})\le \ln(a_i)-\ln(b_j)\le \ln(\frac{U}{C_{ij}}) ln(Cij​L​)≤ln(ai​)−ln(bj​)≤ln(Cij​U​)
通过这个不等式建边即可
另外这题使用朴素版的 s p f a spfa spfa 会超时，需要对 s p f a spfa spfa 进行一些优化
优化的方法有两种： S L F SLF SLF 与 L L L LLL LLL 这篇博客讲得不错
这题使用 S L F SLF SLF 就足够了
建边的时候还需要加一个超级源点，连接每个 i i i

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
int gcd(int a, int b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}
const int N = 2e5 + 10;
const int M = 1e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed, k;
int head[N], cntE;
struct edge {
	int to, next;
	double w;
}e[M];
void add(int u, int v,double w = 0) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
double dis[N];
int neg[N];
bool spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + m + 10));
	memset(dis, inf, sizeof(double) * (n + m + 10));
	memset(neg, 0, sizeof(int) * (n + m + 10));
	deque<int>que;
	que.push_back(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop_front();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					inq[v] = true;
					if (!que.empty() && dis[v] < dis[que.front()]) que.push_front(v);
					else que.push_back(v);
					++neg[v];
					if (neg[v] >= n + m) return false;
				}
			}
		}
	}
	return true;
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
//	rd(T);
//	while (T--) {
	while (~scanf("%d %d", &n,&m)) {
		int L, U; rd(L), rd(U);
		memset(head, -1, sizeof(int) * (n + m + 10)); cntE = 0;
		for (int i = 1; i <= n; ++i) {
			for (int j = 1; j <= m; ++j) {
				int x; rd(x);
				add(n + j, i, log(1.0 * U / x));
				add(i, n + j, -log(1.0 * L / x));
			}
			add(0, i, 0);
		}
		if (spfa(0)) puts("YES");
		else puts("NO");
	}
	return 0;
}

Is the Information Reliable?

POJ-2983
这道题有两种关系：

  • P： S A − S B = x S_A-S_B=x SA​−SB​=x 转化为 x ≤ S A − S B ≤ x x\le S_A-S_B\le x x≤SA​−SB​≤x
  • V： S A − S B ≥ 1 S_A-S_B\ge 1 SA​−SB​≥1
  • 建立一个超级源点

直接建图就行了

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
int gcd(int a, int b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}
const int N = 2e5 + 10;
const int M = 1e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed, k;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w = 0) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N];
int neg[N];
bool spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, -inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	deque<int>que;
	que.push_back(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop_front();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] < dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					inq[v] = true;
					if (!que.empty() && dis[v] > dis[que.front()]) que.push_front(v);
					else que.push_back(v);
					++neg[v];
					if (neg[v] >= n) return false;
				}
			}
		}
	}
	return true;
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
	//	rd(T);
	//	while (T--) {
	while (~scanf("%d %d", &n, &m)) {
		memset(head, -1, sizeof(int) * (n + 10)); cntE = 0;
		while (m--) {
			char op; scanf(" %c", &op);
			if (op == 'P') {
				int x, y, w; rd(x), rd(y), rd(w);
				add(y, x, w);
				add(x, y, -w);
			}
			else {
				int x, y; rd(x), rd(y);
				add(y, x, 1);
			}
		}
		for (int i = 1; i <= n; ++i) add(0, i, 0);
		if (spfa(0)) puts("Reliable");
		else puts("Unreliable");
	}
	return 0;

Cashier Employment

Cashier Employment HDU - 1529
这道题偏难，建立的不等式关系如下：

  • 设所有的申请人当中，在 x x x 时间点入职的数量为 c n t x cnt_x cntx​, S i S_i Si​ 为 0 ~ i 的总申请人数量，其中 S 0 = 0 S_0=0 S0​=0 , S 1 = S 0 + R [ 0 ] S_1=S_0+R[0] S1​=S0​+R[0] , S i = S i − 1 + R [ i − 1 ] S_i=S_{i-1}+R[i-1] Si​=Si−1​+R[i−1]
  • 有 0 ≤ S i + 1 − S i ≤ c n t i 0\le S_{i+1}-S_{i}\le cnt_i 0≤Si+1​−Si​≤cnti​,表示在第 i i i 个时间点最多有 c n t i cnt_i cnti​ 个人入职
  • 对于 i ≥ 8 i\ge8 i≥8 有： S i − S i − 8 ≥ R [ i − 1 ] S_i-S_{i-8}\ge R[i-1] Si​−Si−8​≥R[i−1]，表示在第 i i i 个时间点至少有 R [ i − 1 ] R[i-1] R[i−1] 个人在岗
  • 对于 i < 8 i\lt8 i<8 有： S i − S 16 + i + S 24 ≥ R [ i − 1 ] S_i-S_{16+i}+S_{24}\ge R[i-1] Si​−S16+i​+S24​≥R[i−1],其中 S 24 S_{24} S24​ 为申请总人数，即为答案。
  • 可以二分答案，确定一个中值 m i d mid mid ,令 S 24 = m i d S_{24}=mid S24​=mid ,另外需要加个限制
    m i d ≤ S 24 ≤ m i d mid\le S_{24}\le mid mid≤S24​≤mid
  • 接下来建边跑 s p f a spfa spfa 即可
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
int gcd(int a, int b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}
const int N = 2e5 + 10;
const int M = 1e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed, k;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w = 0) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N];
int neg[N];
bool spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	deque<int>que;
	que.push_back(st);
	dis[st] = 0;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop_front();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					inq[v] = true;
					if (!que.empty() && dis[v] < dis[que.front()]) que.push_front(v);
					else 
						que.push_back(v);
					++neg[v];
					if (neg[v] >= n) return false;
				}
			}
		}
	}
	return true;
}
int R[N], a[N];
bool check(int x) {
	memset(head, -1, sizeof(int) * (24 + 10)); cntE = 0;
	for (int i = 0; i < 24; ++i) {
		add(i, i + 1, a[i]);
		add(i + 1, i, 0);
	}
	for (int i = 8; i < 24; ++i) {
		add(i, i - 8, -R[i - 1]);
	}
	for (int i = 1; i < 8; ++i) {
		add(i, i + 16, x - R[i - 1]);
	}
	add(0, 24, x);
	add(24, 0, -x);
	if (spfa(0)) return true;
	return false;
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
	rd(T);
	while (T--) {
//	while (~scanf("%d %d", &k, &m)) {
		n = 24;
		memset(a, 0, sizeof(int) * (n + 10));
		for (int i = 0; i < 24; ++i) rd(R[i]);
		rd(m);
		for (int i = 1; i <= m; ++i) {
			int x; rd(x);
			++a[x];
		}
		int l = 0, r = m;
		while (l <= r) {
			int mid = l + r >> 1;
			if (check(mid))
				r = mid - 1;
			else l = mid + 1;
		}
		if (r + 1 > m) puts("No Solution");
		else printf("%d\n", r + 1);
	}
	return 0;
}

Spy’s Work-HDU4274

中等题

  • 首先需要满足的条件是 父节点的权值 ≥ \ge ≥ 所有子结点的权值+1
  • 所以为了满足上述条件，需要对所有点建立一个 d f s dfs dfs 序，来构成上述不等式
  • 另外 S i + 1 − S i ≥ 1 S_{i+1}-S_{i}\ge1 Si+1​−Si​≥1
  • 最后建边跑 s p f a spfa spfa 即可
  • 代码 m i n n [ i ] minn[i] minn[i] 表示第 i i i 个点为根的子树中的最小结点 d f s dfs dfs 序号， i d [ i ] id[i] id[i] 表示该点的 d f s dfs dfs 序号
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <set>
#include <cstdlib>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uii;
typedef pair<int, ll> pii;
template<typename T>
inline void rd(T& x)
{
	int tmp = 1; char c = getchar(); x = 0;
	while (c > '9' || c < '0') { if (c == '-')tmp = -1; c = getchar(); }
	while (c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
	x *= tmp;
}
int gcd(int a, int b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}
const int N = 2e5 + 10;
const int M = 1e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
int sgn(double x) {
	if (fabs(x) < eps) return 0;
	if (x > 0) return 1;
	return -1;
}
int n, m, st, ed, k;
int head[N], cntE;
struct edge {
	int to, next;
	int w;
}e[M];
void add(int u, int v, int w = 0) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	e[cntE].w = w;
	head[u] = cntE++;
}
bool inq[N];
int dis[N];
int neg[N];
bool spfa(int st) {
	memset(inq, false, sizeof(bool) * (n + 10));
	memset(dis, -inf, sizeof(int) * (n + 10));
	memset(neg, 0, sizeof(int) * (n + 10));
	deque<int>que;
	que.push_back(st);
	dis[st] = 1;
	inq[st] = true;
	while (!que.empty()) {
		int u = que.front(); que.pop_front();
		inq[u] = false;
		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].to;
			if (dis[v] < dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				if (!inq[v]) {
					inq[v] = true;
					if (!que.empty() && dis[v] > dis[que.front()]) que.push_front(v);
					else 
						que.push_back(v);
					++neg[v];
					if (neg[v] >= n) return false;
				}
			}
		}
	}
	return true;
}
int c[N], id[N], num, minn[N];
bool vis[N];
vector<int>vec[N];
void dfs(int x) {
	vis[x] = true;
	minn[x] = inf;
	for (auto v : vec[x]) {
		dfs(v);
		minn[x] = min(minn[x], minn[v]);
	}
	minn[x] = min(minn[x], id[x] = ++num);
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif // !_DEBUG
	int cas = 0, T;
//	rd(T);
//	while (T--) {
	while (~scanf("%d", &n)) {
		memset(head, -1, sizeof(int) * (n + 10)); cntE = 0;
		for (int i = 1; i <= n; ++i) vec[i].clear();
		for (int i = 2; i <= n; ++i) {
			int x; rd(x);
			vec[x].push_back(i);
		}
		memset(vis, false, sizeof(bool) * (n + 10)); num = 0;
		for (int i = 1, pre = num; i <= n; ++i) {
			if (!vis[i]) {
				dfs(i);
			}
		}
		rd(m);
		while (m--) {
			int x, w; char op;
			scanf("%d %c %d", &x, &op, &w);
			if (op == '<') add(id[x], minn[x] - 1, 1 - w);
			else if (op == '>') add(minn[x] - 1, id[x], w + 1);
			else {
				add(minn[x] - 1, id[x], w);
				add(id[x], minn[x] - 1, -w);
			}
		}
		for (int i = 1; i <= n; ++i) add(i - 1, i, 1);
		if (spfa(0)) puts("True");
		else puts("Lie");
	}
	return 0;
}
_lanChe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++图论专题(form Alex_Wei
08-07
3. **差分约束**：在图论中，差分约束系统是一类特殊的网络流问题，涉及求解一组变量的最小整数解，满足特定的线性不等式关系。 4. **最小生成树** - **Kruskal算法**：按边的权重升序选择边，并避免形成环路，...
差分约束题目
ypeijasd的专栏
04-18 270
P3275 [SCOI2011]糖果 #include <bits/stdc++.h> using namespace std; const int N=100010, M=300010; #define LL long long int n, k, x, a, b, tot, head[N]; LL dis[N], ans, cnt[N]; bool vis[N]; queue<int> q; struct node { int to, dis, nex; }e[M];
差分约束例题
qq_45768588的博客
05-24 137
1、再卖菜 差分约束问题是一个未知量与另外一个未知量的相对大小关系，因此，本题需要先转化成为前缀和的相对关系，并根据这个来建边 经过分析可以知道，要满足上述的条件，需要如下条件成立 当i = 1时，Si+1 - Si-1 >= 2b[i] && Si+1 - Si-1 <= 2b[i]+1; 当i = n时，Si - Si-2 >= 2b[n] && Si - Si-2 <= 2b[i] + 1; 其他情况 Si+1 - Si-1 >= 3b[i
hdu1529 差分约束（好题）
天使也掉毛
06-10 1205
题意：       超市在每个时间都有需要的人数（24小时）比如 1 0 0 0 0 。。。。也就是说在第0个小时的时候要用一个人，其他的时间都不用人，在给你一些人工作的起始时间，如果雇佣了这个人，那么这个人就会从自己的其实时间工作8个小时后离开，给你需求和可雇佣的员工 ，问你满足需求超时最少雇佣多少人。 思路：       经典的差分约束，之前尝试过很多次都没AC，今天终于A
差分约束系统
热门推荐
我的ACM，我的梦！！！
12-22 2万+
差分约束系统 一、何为差分约束系统： 差分约束系统（system of difference constraints），是求解关于一组变数的特殊不等式组之方法。如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如xj-xi 通俗一点地说，差分约束系统就是一些不等式的组，而我们的目标是通过给定的约束不等式组求出最大值或者最小值或者差分约束系统是否有解。 比如：
差分约束题单
weixin_30498807的博客
02-06 87
差分约束题单 Tags：算法 更好阅读体验：https://www.zybuluo.com/xzyxzy/note/1042937 [ ] [POJ]Layout https://vjudge.net/problem/POJ-3169 [ ] [POJ]Intervals https://vjudge.net/problem/POJ-1201 [ ] [POJ]King https://vju...
专题资料（2021-2022年）Layout中的走线策略.doc
10-07
本专题资料主要探讨了2021-2022年期间在Layout中的一些关键走线策略，包括直角走线、差分走线以及蛇形线的应用。 首先，直角走线在传统的观念中被认为是应避免的，因为它可能导致阻抗不连续、信号反射和电磁干扰...
专题资料（2021-2022年）Eviews实验报告5.doc
10-07
1. 数据预处理：检查时间序列的平稳性，可能需要进行差分以使序列平稳。 2. 构建模型：根据自相关和偏自相关图选择合适的AR(p)模型。 3. 参数估计：用OLS或更高级的方法如极大似然估计法估计模型参数。 4. 检验模型...
专题资料（2021-2022年）GPS原理及应用题目及答案.doc
10-07
在相对定位中，常用的技术包括双差分法、三差分法等，以减小接收机钟差的影响。RTK（实时动态定位）的关键在于实时处理载波相位观测值和快速初始化，如浮动相位解、固定相位解等方法。 C/A码是短周期、易于捕获的码...
面板数据分析专题-GMM估计方法.zip
05-11
一阶差分GMM常用于处理静态面板模型，通过对时间序列进行差分消除固定效应。系统GMM则考虑了截面和时间维度的信息，可以处理动态面板模型，通过加入滞后解释变量作为工具变量，提高了估计的精度。 五、GMM的优点与...
POJ 3159 差分约束 裸题
TwistFate24的博客
11-02 302
做这道题的时候同时复习了 堆优化版本的Dijkstra #include&lt;cstdio&gt; #include&lt;queue&gt; #include&lt;cstring&gt; #include&lt;utility&gt; #include&lt;map&gt; #include&lt;queue&gt; #include&lt;vector&gt; using namespa
Burn the Linked Camp ZOJ - 2770 (差分约束，条件限制+好题)
肘子的博客
01-30 174
传送门 题意：刘备有n个连续的军营，现在给出每个军营最多的人数，然后给出从第i个军营到第j个军营的总人数至少有w人，现在问这种情况是否存在。 题解：直接就能看出用差分约束，但是我刚开始太弱了 ，我就建了两个条件，第一个条件是那个最明显的条件，用s[i]表示从第1个军营到第i个军营的总人数，然后s[r]-s[l-1]&gt;=w，然后又建了个所有的s[i]都必须大于等于0，之后再判断s[i]-s...
最短路&差分约束题集
夏天的风
07-24 4250
最短路 【HDU】 1548    A strange lift 基础最短路(或bfs)★ 2544    最短路   基础最短路★ 3790    最短路径问题 基础最短路★ 2066    一个人的旅行 基础最短路(多源多汇,可以建立超级源点和终点)★ 2112    HDU Today 基础最短路★ 1874    畅通工程续 基础最短路★ 1217    Arbitra
AI人工智能机器人PPT模板
08-19
这是一套AI人工智能机器人PPT模板，共23张； PPT模板封面使用了蓝色曲线与机器人PPT背景图片。左侧填写AI人工智能机器人PPT标题。界面背景与PPT主题匹配。 PowerPoint模板内容页，介绍了什么是人工智能、人工智能对生活影响、人工智能的应用等。 本模板适合用于制作AI人工智能PPT、机器人主题PPT、工业2.0PPT等。.PPTX格式；
5G毫米波无线电射频技术.pdf
最新发布
08-19
5G毫米波无线电射频技术.pdf
ACM模板和一些题目的代码实现
08-19
ACM模板和一些题目的代码实现
驾校报名小程序--.zip
08-19
本网站所实现的是一个驾校报名小程序，该系统严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本系统具有以下优点： 该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。 系统将用户权限进行划分，管理员，用户和驾校教练能看到及操作的信息不一样，三者具备不同的操作权限。 该系统操作界面简单明了，大部分人都可以正常使用。
Exotec skypod 资料
08-19
skypod 系统介绍
利用SPFA解决差分约束系统问题
"差分约束系统用于解决特定的线性规划问题，特别是寻找一组变量的解，使得这些变量满足一组不等式约束。在给定的题目POJ1201中，差分约束系统被用来寻找最短的序列长度，这个序列需要满足在每个给定的整数区间内至少...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值