dilworth定理

定义：：在数学理论中的序理论与组合数学中，Dilworth定理根据序列划分的最小数量的链描述了任何有限偏序集的宽度。其名称取自数学家Robert P. Dilworth。

定理内容：：

反链是一种偏序集，其任意两个元素不可比；而链则是一种任意两个元素可比的偏序集。Dilworth定理说明，存在一个反链A与一个将序列划分为链族P的划分，使得划分中链的数量等于集合A的基数。当存在这种情况时，对任何至多能包含来自P中每一个成员一个元素的反链，A一定是此序列中的最大反链。同样地，对于任何最少包含A中的每一个元素的一个链的划分，P也一定是序列可以划分出的最小链族。偏序集的宽度被定义为A与P的共同大小。

另一种Dilworth定理的等价表述是：在有穷偏序集中，任何反链最大元素数目等于任何将集合到链的划分中链的最小数目。一个关于无限偏序集的理论指出，在此种情况下，一个偏序集具有有限的宽度w，当且仅当它可以划分为最少w条链。 ^[1] 

偏序集的两个定理：
定理1) 令（X,≤）是一个有限偏序集，并令r是其最大链的大小。则X可以被划分成r个但不能再少的反链。
其对偶定理称为Dilworth定理：
定理2) 令（X,≤）是一个有限偏序集，并令m是反链的最大的大小。则X可以被划分成m个但不能再少的链。

即：链的最少划分数 = 反链的最长长度

例：：

1 7 8  2 3 4

反链：最长不上升子序列（如：（7，2））长度 = 2；

即：按升序划分，最少的链划分数为2，为（1，2，3，4）和（7，8）。

 

Dilworth定理：对于一个偏序集，最少链划分等于最长反链长度。

Dilworth定理的对偶定理：对于一个偏序集，其最少反链划分数等于其最长链的长度。

******也就是说把一个数列划分成最少的最长不升子序列的数目就等于这个数列的最长上升子序列的长度。

例：：  3 2 2 1 4

最少的最长不升子序列的数目：：《3 2 2 1》《4》==最长上升子序列长度（2）；

洛谷  P1020 导弹拦截

题意求最少导弹拦截系统（最少的最长的不生链分数）==最长的升序列长度

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+5;
int dp[maxn];
int a[maxn],ma[maxn];
int main()
{
    int n;
    char c;
    int k=0;
    while(~scanf("%d%c",&n,&c))
    {
        ma[k++]=n;
        if(c=='
'){break;}
    }
    a[1]=ma[k-1];
    int len=1;
    for(int i=k-2;i>=0;i--)
    {
        if(ma[i]>=a[len]){
            a[++len]=ma[i];
        }
        else {
            int pos=upper_bound(a+1,a+len+1,ma[i])-a;
            a[pos]=ma[i];
        }
    }
    dp[1]=ma[1];
    int let=1;
    for(int i=2;i<k;i++)
    {
        if(ma[i]<=dp[let]){
            int pos=lower_bound(dp+1,dp+let+1,ma[i])-dp;
            dp[pos]=ma[i];
        }
        else {
            dp[++let]=ma[i];
        }
    }
    printf("%d
%d
",len,let);
    return 0;
}

洛谷  P1233 木棍加工

题目描述

一堆木头棍子共有n根，每根棍子的长度和宽度都是已知的。棍子可以被一台机器一个接一个地加工。机器处理一根棍子之前需要准备时间。准备时间是这样定义的：

第一根棍子的准备时间为1分钟；

如果刚处理完长度为L，宽度为W的棍子，那么如果下一个棍子长度为Li，宽度为Wi，并且满足L>＝Li，W>＝Wi，这个棍子就不需要准备时间，否则需要1分钟的准备时间；

计算处理完n根棍子所需要的最短准备时间。比如，你有5根棍子，长度和宽度分别为(4, 9)，(5, 2)，(2, 1)，(3, 5)，(1, 4)，最短准备时间为2（按(4, 9)、(3, 5)、(1, 4)、(5, 2)、(2, 1)的次序进行加工）。

输入格式

第一行是一个整数n(n<＝5000)，第2行是2n个整数，分别是L1，W1，L2，w2，…，Ln，Wn。L和W的值均不超过10000，相邻两数之间用空格分开。

输出格式

仅一行，一个整数，所需要的最短准备时间。

输入输出样例

输入 #1复制

5
4 9 5 2 2 1 3 5 1 4

输出 #1复制

2

 分析：：按长度大到小排序，若相同按宽度大到小排序，最少的最长的不升链分数==最长的上升序列长度，就可以做出来了

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=5005;
int a[maxn];
struct node
{
    int x,y;
}ma[maxn];
bool cmp(node A,node B)
{
    if(A.x==B.x){
        return A.y>B.y;
    }
    else{
        return A.x>B.x;
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&ma[i].x,&ma[i].y);
    }
    sort(ma+1,ma+n+1,cmp);
    a[1]=ma[1].y;
    int len=1;
    for(int i=2;i<=n;i++)
    {
        if(ma[i].y>a[len]){
            a[++len]=ma[i].y;
        }
        else{
            int pos=lower_bound(a+1,a+len+1,ma[i].y)-a;//二分较快
            a[pos]=ma[i].y;
        }
    }
    printf("%d
",len);
    return 0;
}