poj1609——Tiling Up Blocks

题目大意：

有若干块砖头，这些砖头的一个表面上有两个区域有突起，分别在左部和中部，左部有l个突起，中部有m个。砖的对侧表面在左部和中部有相同数量的凹陷。（l1，m1）的砖块可以放在（l2，m2）的砖块之上，当且仅当l1>=l2且m1>=m2。题目会给你若干组测试样例，每组测试样例会给出砖的数量和每一块砖的l和m。你要做的就是求出最多可以把多少块砖吗起来，即码放的最大高度。每组测试的结果占一行，最后一行输出‘*’。

测试样例：

Input：

3
3 2
1 1
2 3
5
4 2
2 4
3 3
1 1
5 5

5

1 100

2 1

3 1

5 1

4 1

0

Output：

2

3

4

*

算法一：

将砖块按照 l 的升序排列，如果 l 相同，按 m 的升序排列。令dp[i]表示以第i块砖为最高砖块的最大高度。dp[n-1]即为所求。

dp[i]有递推公式：

dp[i] = 1                            , i = 0

           max{dp[j] + 1}        , i > 0

         0<=j<i

#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];    //记录以a[i]为最高块的最大高度
    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;
}

算法二：

分别以 l 和 m 为主序，对砖块进行排序，然后找着两个序列的最长公共子序列。时间复杂度还是O(n^2)。

#include <stdio.h>
#include <stdlib.h>
#define N 10000    //定义问题的最大规模

struct block
{
    int l,m;
};

int cmp_l(struct block a,struct block b)    //a>b为真
{
    if(a.l > b.l || a.l==b.l && a.m > b.m)
        return 1;
    else if(a.l==b.l && a.m==b.m)
        return 0;
    else
        return -1;
}

int cmp_m(struct block a,struct block b)
{
    if(a.m > b.m || a.m==b.m && a.l>b.l)
        return 1;
    else if(a.m==b.m && a.l==b.l)
        return 0;
    else
        return -1;
}

void q_sort(struct block*a,int s,int t,int (*cmp)(struct block,struct block))    //快速排序
{
    int i,j;
    struct block tmp;
    if(s<t)
    {
        while(1)
        {
            i = s+1;
            j = t;
            while(i<=t && cmp(a[i],a[s])!=1)    //寻找比分解元素大的元素
                i++;
            while(j>s && cmp(a[j],a[s])!=-1)     //寻找比分解元素小的元素
                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,cmp);
        q_sort(a,j+1,t,cmp);
    }
}

int main()
{
    int n;
    int i,j,k;
    struct block a[N],b[N];
    int dp[2][N+1];

    scanf("%d",&n);
    while(n > 0)
    {
        //读入
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].l,&a[i].m);
            b[i] = a[i];
        }

        //分别排序
        q_sort(a,0,n-1,cmp_l);
        q_sort(b,0,n-1,cmp_m);

//        printf("l:\n");
//        for(i=0;i<n;i++)
//            printf("%d %d\n",a[i].l,a[i].m);
//        printf("m:\n");
//        for(i=0;i<n;i++)
//            printf("%d %d\n",b[i].l,b[i].m);

        //求最大公共子列
        for(j=0;j<=n;j++)
            dp[0][j] = 0;
        dp[1][0] = 0;
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(cmp_l(a[i-1],b[j-1])==0)
                    dp[i%2][j] = dp[(i-1)%2][j-1] + 1;
                else if(dp[(i-1)%2][j] > dp[i%2][j-1])
                    dp[i%2][j] = dp[(i-1)%2][j];
                else
                    dp[i%2][j] = dp[i%2][j-1];
            }

//            for(k=1;k<=n;k++)
//                printf("%d ",dp[i%2][k]);
//            printf("\n");
        }

        printf("%d\n",dp[n%2][n]);
        scanf("%d",&n);
    }

    printf("*\n");

    return 0;
}