uva 动态规划 437 The Tower of Babylon

The Tower of Babylon

Time Limit: 3000MS   Memory Limit: Unknown   64bit IO Format: %lld & %llu

Submit Status

Description

Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So now, in line with the educational nature of this contest, we will tell you the whole story:

The babylonians had n types of blocks, and an unlimited supply of blocks of each type. Each type-i block was a rectangular solid with linear dimensions  .
A block could be reoriented so that any two of its three dimensions determined the dimensions of the base and the other dimension was the height. They wanted to construct the tallest tower possible by stacking blocks. The problem was that, in building a tower,
one block could only be placed on top of another block as long as the two base dimensions of the upper block were both strictly smaller than the corresponding base dimensions of the lower block. This meant, for example, that blocks oriented to have equal-sized
bases couldn‘t be stacked.

Your job is to write a program that determines the height of the tallest tower the babylonians can build with a given set of blocks.

Input and Output

The input file will contain one or more test cases. The first line of each test case contains an integer n, representing the number of different blocks in the following data set. The maximum value for n is
30. Each of the next n lines contains three integers representing the values  ,  and  .

Input is terminated by a value of zero (0) for n.

For each test case, print one line containing the case number (they are numbered sequentially starting from 1) and the height of the tallest possible tower in the format "Casecase: maximum
height =
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

Submit Status

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<cstdio>
#include<cmath>
#include<stdlib.h>
#include<map>
#include<set>
#include<time.h>
#include<vector>
#include<queue>
#include<string>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define eps 1e-8
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
typedef pair<int , int> pii;
#define maxn 35

int n;
LL d[maxn][3];
int vis[maxn][3];
struct block
{
    LL h[3];
} B[maxn];

bool judge(int t1, int x1, int t2, int x2)
{
    LL a[2], b[2];
    int cn1 = 0, cn2 = 0;
    for(int i = 0; i < 3; i++)
    {
        if(i != x1)
        a[cn1++] = B[t1].h[i];
        if(i != x2)
        b[cn2++] = B[t2].h[i];
    }
    for(int i = 0; i < 2; i++)
    {
        if(a[i] >= b[i])
        return false;
    }
    return true;
}

int dfs(int t, int x)
{
    if(vis[t][x]) return d[t][x];
    vis[t][x] = 1;
    LL &res = d[t][x];

    for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                if(judge(t, x, i, j))
                    {
                        res = max(res, dfs(i, j) + B[t].h[x]);
                    }
            }
        }
    return res;
}

int main()
{
    int kase = 0;
    while(~scanf("%d", &n) && n)
    {
        memset(vis, 0, sizeof vis);
        for(int i = 1; i <= n; i++)
        {
            scanf("%I64d%I64d%I64d", &B[i].h[0], &B[i].h[1], &B[i].h[2]);
            sort(B[i].h , B[i].h + 3);
            for(int k = 0; k < 3; k++)
            {
                d[i][k] = B[i].h[k];
            }
        }
        long long ans = 0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                if(!vis[i][j])
                {
                    d[i][j] = dfs(i, j);
                    ans = max(ans, d[i][j]);
                }
            }
        }
        printf("Case %d: maximum height = %lld\n", ++kase, ans);
    }
    return 0;
}

/*

1
10 10 10

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
*/

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-10 10:11:52

uva 动态规划 437 The Tower of Babylon的相关文章

uva 437 The Tower of Babylon(动态规划 嵌套矩形问题最长路)

有思路就去做,要相信自己 多处理更复杂的情况,你就不觉得现在复杂了 #include<cstdio> #include<cstring> #include<algorithm> using namespace std; typedef long long ll; struct soli { ll a,b,c; }s[40]; int n; ll d[40][3]; int vis[40][3]; ll answer[40][3]; ll dp(int s1,int s2

UVa 437 The Tower of Babylon(动态规划)

传送门 Description Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So now, in line with the educational nature of this contest, we will tell you the whole story: The babylonians had n

UVa 437 The Tower of Babylon

Description Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So now, in line with the educational nature of this contest, we will tell you the whole story: The babylonians had n typ

UVA 437 The Tower of Babylon DP

有向图DAG The Tower of Babylon Time Limit: 3000MS   Memory Limit: Unknown   64bit IO Format: %lld & %llu Submit Status Description Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So n

UVa 437 The Tower of Babylon(DP 最长条件子序列)

 题意  给你n种长方体  每种都有无穷个  当一个长方体的长和宽都小于另一个时  这个长方体可以放在另一个上面  要求输出这样累积起来的最大高度 因为每个长方体都有3种放法  比较不好控制   可以把一个长宽高分成三个长方体  高度是固定的  这样就比较好控制了 #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define maxn 105 int x[max

UVA 437 The Tower of Babylon巴比伦塔

题意:有n(n≤30)种立方体,每种有无穷多个.要求选一些立方体摞成一根尽量高的柱子(可以自行选择哪一条边作为高),使得每个立方体的底面长宽分别严格小于它下方立方体的底面长宽. 评测地址:http://acm.hust.edu.cn/vjudge/problem/19214 AC代码: #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 50010 i

UVA - 437 The Tower of Babylon(dp-最长递增子序列)

每一个长方形都有六种放置形态,其实可以是三种,但是判断有点麻烦直接用六种了,然后按照底面积给这些形态排序,排序后就完全变成了LIS的问题.代码如下: #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 1818 struct Node { int x,y,z,area; void init(int a,

DP(DAG) UVA 437 The Tower of Babylon

题目传送门 题意:给出一些砖头的长宽高,砖头能叠在另一块上要求它的长宽都小于下面的转头的长宽,问叠起来最高能有多高 分析:设一个砖头的长宽高为x, y, z,那么想当于多了x, z, y 和y, x, z的砖头,如果i能叠在j上,那么g[i][j] = true,转换成DAG问题,dp[i]表示第i块叠在最上部最高的高度 收获:转换成经典模型 代码: /************************************************ * Author :Running_Time

437 - The Tower of Babylon(记录结果再利用DP)

最近准备进入动态规划的章节,仔细看了看紫书上对01背包的讲解,感觉很好..之前看<挑战程序设计竞赛>那本书,就没有讲的那么深刻 .      更加深刻的理解了什么叫记录结果再利用,手工操作了一遍01背包的过程,也有点明白它的状态是如何转移的了,而且那个状态方程所构成的递推关系真的很巧妙 . 言归正传..这道题就是嵌套矩形问题稍微改了一下,之前的嵌套矩形只需要维护一个状态量就行了,但是这道题是立方体,可以翻转的,所以还要维护一个特征量--高. 由于矩形的嵌套关系,每个状态只会出现一次,所以这么表