集训第五周 动态规划 B题LIS

 

Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit Status

Description

一组研究人员正在设计一项实验，以测试猴子的智商。他们将挂香蕉在建筑物的屋顶，同时，提供一些砖块给这些猴子。如果猴子足够聪明，它应当能够通过合理的放置一些砖块建立一个塔，并爬上去吃他们最喜欢的香蕉。

 

研究人员有n种类型的砖块，每种类型的砖块都有无限个。第i块砖块的长宽高分别用xi，yi，zi来表示。 同时，由于砖块是可以旋转的，每个砖块的3条边可以组成6种不同的长宽高。

 

在构建塔时，当且仅当A砖块的长和宽都分别小于B砖块的长和宽时，A砖块才能放到B砖块的上面，因为必须留有一些空间让猴子来踩。

 

你的任务是编写一个程序，计算猴子们最高可以堆出的砖块们的高度。

Input

输入文件包含多组测试数据。

每个测试用例的第一行包含一个整数n，代表不同种类的砖块数目。n<=30.

接下来n行，每行3个数，分别表示砖块的长宽高。

当n= 0的时候，无需输出任何答案，测试结束。

Output

对于每组测试数据，输出最大高度。格式：Case 第几组数据: maximum height = 最大高度

Sample Input

1

10 20 30 
2 
6 8 10 
5 5 5 
7 
1 1 1 
2 2 2 
3 3 3 
4 4 4 
5 5 5 
6 6 6 
7 7 7 
5 
31 41 59 
26 53 58 
97 93 23 
84 62 64 
33 83 27 
0 

Sample Output

Case 1: maximum height = 40

Case 2: maximum height = 21 
Case 3: maximum height = 28 
Case 4: maximum height = 342 

 

经典的动态规划题,这个其实可以看作LIS问题来看待，其实这道题虽然说有无限个砖块，可是他每种砖块转换成6种状态之后，每种状态只可能出现一次，因为还有长和宽的限制，因此可以把所有的砖块做成一个排列。还可以由LIS问题得到启发，得到这个问题的最优子结构，用h[i]表示以第i个砖块作为最上面一个砖块可以得到的最大距离，为了保证其最优性，状态转移方程为h[i]=max{h[j]+第i个砖块的高度,j<i},这个方程是因为事先经过排序，使得面积从大到小排，因此序号大于i的砖块不可能放在砖块i的下面，然后枚举n个砖块放在最上面，其中所能得到的最高高度就是答案

 

#include"iostream"
#include"algorithm"
#include"cstring"
#include"cstdio"
#define inf -1e9
using namespace std;
int n,ans,f,ff;

struct node{
int x,y,z;
void getdata(int a,int b,int c)
{
    x=a;y=b;z=c;
}
bool operator < (const node &a1) const
{
    if(x!=a1.x) return x>a1.x;
    return y>a1.y;
}
}a[];

int dp[];

void Init()
{
    f=;int aa,bb,cc;
    a[].x=a[].y=;
    for(int i=;i<n;i++)
    {
      cin>>aa>>bb>>cc;
      a[f++].getdata(aa,bb,cc);
      a[f++].getdata(aa,cc,bb);
      a[f++].getdata(cc,aa,bb);
      a[f++].getdata(cc,bb,aa);
      a[f++].getdata(bb,aa,cc);
      a[f++].getdata(bb,cc,aa);
    }
    sort(a,a+f);
}

bool isok(node a1,node a2)
{
    if(a2.x>a1.x&&a2.y>a1.y) return true;
    return false;
}

void Work()
{
  int MAX=inf;
  memset(dp,,sizeof(int)*f);
  for(int i=;i<f;i++)
  {
   for(int j=;j<=i;j++)
   if(isok(a[i],a[j])&&dp[j]+a[i].z>dp[i])
   dp[i]=dp[j]+a[i].z;
   MAX=max(dp[i],MAX);
  }
  ans=MAX;
}

void Print()
{
 cout<<"Case "<<ff++<<": maximum height = "<<ans<<endl;
}

int main()
{
    ff=;
    while(cin>>n&&n)
    {
     Init();
     Work();
     Print();
    }
    return ;
}

O(O_O)O

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=+;
struct node
{
    int l,w,h;
    void init(int a,int b,int c)
    {
        l=a;
        w=b;
        h=c;
    }
}f[maxn];
int dp[maxn],e,ca=;

bool cmp(node x1,node x2)
{
    return x1.l*x1.w>x2.l*x2.w;
}

void Work()
{
    sort(f,f+e,cmp);
    int maxx=-1e9;
    for(int k=;k<e;k++)
    {
        memset(dp,,sizeof(dp));
        dp[k]=f[k].h;
        for(int i=;i<e;i++)
        {
            if(i==k) continue;
            for(int j=;j<i;j++)
            {
            if(f[j].l>f[i].l&&f[j].w>f[i].w) dp[i]=max(dp[j]+f[i].h,dp[i]);
            }
            maxx=max(dp[i],maxx);
        }
    }
    cout<<"Case "<<ca++<<": maximum height = "<<maxx<<endl;
}

int main()
{
    int n;
    while(cin>>n&&n)
    {
     e=;
     int a,b,c;
     for(int i=;i<=n;i++)
     {
         cin>>a>>b>>c;
         f[e++].init(a,b,c);
         f[e++].init(a,c,b);
         f[e++].init(b,a,c);
         f[e++].init(b,c,a);
         f[e++].init(c,a,b);
         f[e++].init(c,b,a);
     }
     Work();
    }
    return ;
}