Dilworth定理

Posted 2020-08-15

今天早上准备看一波uestc的dp，看到第一道例题的时候发现我竟然不会QAQ，心想清早看的第一题我都不会，甚是郁闷，然后又去百度百度……发现了一个Dilworth定理，然后一直怼一直怼。

 

结论：对于一个偏序集，最少的chain的个数等于最长antichain的长度，最少的antichain的个数等于最长chain的长度。

 

比如对于一个二元组，定义偏序关系"≤"，当且仅当(a.i < b.i) && (a.j < b.j)时，a 与 b可比，但是会发现有些二元组是没法比较的，称之为偏序集。

与她相对的东西叫做全序集，就是任意两个元素都可以比较，还有就是良序集，有最小元素，比如正整数就是一个良序集。

 

看了半天QAQ，依然没有看懂证明，证明好久懂了，再回来补吧，接下来我讲一讲这个定理的实际的应用。

 

一、

codevs 1044 导弹拦截：

题意：依次给出每个导弹飞来的高度，有一种反导弹装置可以将导弹击毁，但是中途过程中，反导弹装置的高度不能升高，求某一台装置最多击落多少个导弹？请问至少需要多少台装置可以拦截所有导弹？

 

题解：

chain : xi ≤ xj 当且仅当 (i <= j && h[i] >= h[j]) 

antichain : (h[i] < h[j] && i <= j) || (h[i] >= h[j] && i > j)

如果按照i <= j 排序，那么antichain中所有的元素h[i] < h[j]，现在的问题就是求这个串最长上升子序列的长度。

 

代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 7;
int x[N], n = 1, d[N], ans1, ans2;

int main () {
	while (cin >> x[n]) n++;
	--n;
	memset (d, 127, sizeof d);
	for (int i = n; i >= 1; --i) {
		int p = upper_bound (d + 1, d + 1 + n, x[i]) - d;
		ans1 = max (ans1, p);
		d[p] = x[i];
	} 
	memset (d, 127, sizeof d);
	for (int i = 1; i <= n; ++i) {
		int p = lower_bound (d + 1, d + 1 + n, x[i]) - d;
		ans2 = max (ans2, p);
		d[p] = x[i];
	}
	cout << ans1 << endl << ans2; 
	return 0;
}

　　

 二、

POJ 1065 Wooden Sticks

题意：有n个棍子，每个棍子都有长度和质量，现在有一台机器来处理这些棍子，机器开启需要一个单位的时间，但是比如现在处理到了第 i 根棍子，如果第i + 1 根棍子的长度和质量都大于等于第i根棍子那么将不会消耗时间，求处理完这些棍子的最少时间。

 

题解：

chain : xi ≤ xj 当且仅当 (xi.m <= xj.m && xi.w <= xj.w)

antichain : (xi.m <= xj.m && xi.w > xj.w) || (xi.m > xj.m &&　xi.w <= xj.w)

如果按照x.m从小到大排序，那么就应该求最长下降子序列，但是在m相等的情况下要使x.w 按照从小到大的顺序来排，因为这样才能在求子序列的时候避免错误情况。

 

代码:

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

const int N = 1e5 + 7;
int kase, n, d[N];

struct node {int a, b;} x[N];

bool cmp (node x, node y) {
	if (x.a == y.a) return x.b < y.b;
	return x.a < y.a;
}

int main () {
	scanf ("%d", &kase);
	while (kase--) {
		scanf ("%d", &n);
		for (int i = 1; i <= n; ++i) 
			scanf ("%d%d", &x[i].a, &x[i].b);
		sort (x + 1, x + 1 + n, cmp);
		memset (d, 127, sizeof d);
		int ans = 0;
		for (int i = n; i >= 1; --i) {
			int p = lower_bound (d + 1, d + 1 + n, x[i].b) - d;
			ans = max (ans, p);
			d[p] = x[i].b;
		}
		cout << ans << endl;
	}
	return 0;
}

　　

poj 3636 Nested Dolls

题意：有n个矩形，如果一个矩形的长宽都小于另一个矩形的长宽，那么这两个矩形可以嵌套在一起，问最少需要几个嵌套组合才能匹配完所有的矩形？

 

题解：

chain : xi ≤ xj 当且仅当 (xi.l < xj.l && xi.w < xj.w)

antichain :  (xi.l <= xj.l && xi.w >= xj.w) || (xi.l >= xj.l && xi.w <= xj.w)

如果按照x.l从小到大排序，那么就是求关于x.w的最长不上升子序列，但是注意的是当x.l相等的时候，要按照w从大到小排序。

 

代码：

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

const int N = 1e5 + 7;
int kase, n, d[N];

struct node {int a, b;} x[N];

bool cmp (node x, node y) {
	return (x.a < y.a) || (x.a == y.a && x.b > y.b);
}

int main () {
	scanf ("%d", &kase);
	while (kase--) {
		scanf ("%d", &n);
		for (int i = 1; i <= n; ++i) 
			scanf ("%d%d", &x[i].a, &x[i].b);
		sort (x + 1, x + 1 + n, cmp);
		memset (d, 127, sizeof d);
		int ans = 0;
		for (int i = n; i >= 1; --i) {
			int p = upper_bound (d + 1, d + 1 + n, x[i].b) - d;
			ans = max (ans, p);
			d[p] = x[i].b;
		}
		cout << ans << endl;
	}
	
	return 0;
}

　　

 

poj 1548 Robots

题意：在一个矩形区域内，一个机器人在左上角出发，每次只能向右向下进行移动，在移动中清理垃圾，一直到右下角，给出所有垃圾的位置，求至少要多少个机器人才能清理完所有垃圾？

 

题解：

chain : pi ≤ pj  (pi.x <= pj.x && pi.y <= pj.y)

antichain : (pi.x <= pj.x && pi.y > pj.y) || (pi.x > pj.x && pi.y <= pj.y)

如果按照p.x排序，那么也就是求关于y的最长下降子序列，需要注意的是当x 想等的时候按照要按照y从小到大排序。

 

代码：

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

const int N = 1e5 + 7;
struct node {int x, y;} p[N];
int n, x, y, d[N];

bool cmp (node a, node b) {
	return a.x < b. x || (a.x == b.x && a.y < b.y);
}

int main () {
	while(true) {
		n = 0;
		while (scanf ("%d%d", &x, &y) != EOF) {
			if (x == 0 && y == 0) break;
			if (x == -1 && y == -1) return 0;
			p[++n] = (node) {x, y};
		}
		sort (p + 1, p + 1 + n, cmp);
		memset (d, 127, sizeof d);
		int ans = 0;
		for (int i = n; i >= 1; --i) {
			int pos = lower_bound(d + 1, d + 1 + n, p[i].y) - d;
			ans = max (ans, pos);
			d[pos] = p[i].y;
		}
		cout << ans << endl;;
	}
	return 0;
}

　　

 

总结：

Dilworth，虽然不懂证明但是确实感受到了一波他的正确性，一般将她转化成DAG，在辨别可比性的时候，把它弄在平面上会比较直观，还有在写cmp的时候要想清楚……