第100次提交竟然不对，后来发现竟然是快排中的比较部分写错了。
我的思路是先排序，然后计算以第i个元素为结尾的序列的最高高度dp[i]。然后再找最大的dp。

#include <stdio.h>
#include <stdlib.h>

struct block
{
    int l,m;
};

void q_sort(struct block*a,int s,int t)    //快速排序
{
    int i,j;
    struct block tmp;
    if(s<t)
    {
        while(1)
        {
            i = s+1;
            j = t;
            while(i<=t && (a[i].l<a[s].l || a[i].l==a[s].l && a[i].m<=a[s].m))    //寻找比分解元素大的元素
                i++;
            while(j>s && (a[j].l>a[s].l || a[j].l==a[s].l && a[j].m>=a[s].m))    //寻找比分解元素小的元素
                j--;
            if(i<j)    //交换
            {
                tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
            }
            else
                break;
        }
        if(j!=s)
        {
            tmp = a[s];
            a[s] = a[j];
            a[j] = tmp;
        }
        q_sort(a,s,j-1);
        q_sort(a,j+1,t);
    }
}

int main()
{
    int n;
    int i,j;
    int max;
    int dp[10000];    //记录最大高度
    struct block a[10000];

    scanf("%d",&n);
    while(n!=0)
    {
        //read
        for(i=0;i<n;i++)
            scanf("%d%d",&a[i].l,&a[i].m);

        //sort
        q_sort(a,0,n-1);

        //dp
        dp[0] = 1;
        for(i=1;i<n;i++)
        {
            dp[i] = 1;
            for(j=i-1;j>=0;j--)
            {
                if(a[i].m>=a[j].m && dp[i]<dp[j]+1)
                {
                    dp[i] = dp[j] + 1;
                }
            }
        }

        //find max
        max = dp[0];
        for(i=1;i<n;i++)
            if(max < dp[i])
                max = dp[i];

        //print
        printf("%d\n",max);

        //next data set
        scanf("%d",&n);
    }

    printf("*\n");

    return 0;
}

我还有一个思路，就是先给每一个block编号，然后分别按照l和m排序，得到两个编号序列。找着两个编号序列的最大公共子序列。时间复杂度还是O（n^2），可以用滚动数组，空间复杂度还是O（n）。