zcmu 5142: 巴比伦塔

最新推荐文章于 2021-08-11 21:06:50 发布

做回甲乙丙丁

最新推荐文章于 2021-08-11 21:06:50 发布

阅读量404

点赞数 2

分类专栏：基础算法文章标签：动态规划算法

本文链接：https://blog.csdn.net/qq_43624815/article/details/113370223

版权

基础算法专栏收录该内容

20 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何使用有向无环图（DAG）解决一个数学问题：给定不同尺寸的砖块，求能搭建的最高柱子。通过将每个砖块的三种堆叠方式拆解为独立节点，建立DAG并寻找最长路径，来找到最大高度。文中提供了两种不同的算法实现，分别是直接计算最长路和利用拓扑排序加速。这两种方法都是通过遍历所有可能的堆叠组合，找到最优解。

摘要由CSDN通过智能技术生成

Description

有n(n<=30)种砖块，已知三条边长，每种都有无穷多个。要求选一些立方体摞成一根尽量高的柱子（每个砖块可以自行选择一条边作为高），使得每个砖块的底面长宽分别严格小于它下方砖块的底面长宽，求塔的最大高度。(多组输入,有n == 0的情况,数据都在int范围内)

Input

第一行 T 组 n

n个方砖

a,b,c砖的三维.

(T<=100,n<=30,0<= a,b,c<=1e6)

Output

见样例

Sample Input

4
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

Sample Output

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

做法 : 建立DAG

由于每个砖块的底面长宽分别严格小于它下方砖块的底面长宽，因此不难将这样一种关系作为建图
的依据，而本题也就转化为最长路问题。
也就是说如果砖块j能放在砖块i.上,那么i和j之间存在一边(i,j)，且边权就是砖块j所选取的高。

本题的另一个问题在于每个砖块的高有三种选法，怎样建图更合适呢?
不妨将每个砖块拆解为三种堆叠方式,即将一个砖块分解为三个砖块, 每一个拆解得到的砖块都选取不同的高。
初始的起点是大地，大地的底面是无穷大的，则大地可达任意砖块，当然我们写程序时不必特意写上无穷大。
假设有两个砖块，三条边分别为31, 41, 59和33, 83, 27，那么整张DAG应该如下图所示。
在这里插入图片描述

图中蓝实框所表示的是一个砖块拆解得到的一组砖块,之所以用{}示底面长宽，因为砖块一旦选取了高，底面边长就是无序的。
图中黄虚框表示的是重复计算部分，为下文做铺垫。

转移状态说明

题目要求的是塔的最大高度，已经转化为最长路问题，其起点上文已指出是大地，那么终点呢?
显然终点已经自然确定，那就是某砖块上不能再搭别的砖块的时候。
之前在图上标记的黄虚框表明有重复计算，下面我们开始考虑转移方程。
显然，砖块- -旦选取了高，那么这块砖块上最大能放的高度是确定的。
某个砖块i有三种堆叠方式分别记为0,1,2，那么对于砖块i和其堆叠方式r来说则有如下转移方程
d(i,r)= max{d(j,r’)+h’}
其中j是所有那些在砖块i以r方式堆叠时可放上的砖块，r’ 对应j此时的摆放方式，也就确定了此时唯一的高度h’。
在实际编写时，将所有d(i, r)都初始化为-1,表示未计算过。
在试图计算前，如果发现已经计算过,直接返回保存的值;否则就按步计算,并保存。
最终答案是所有d(i,r)的最大值。

方法一:

//code1
//Andong 2021/1/29
//#include <bits/stdc++.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>

#define INF 0x3f3f3f3f
#define ll long long
#define LL long long
#define MAXN (1000 + 5)
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
using namespace std;
int d[MAXN][3];
int x[MAXN], y[MAXN], z[MAXN];
int babylon_sub(int c, int rot, int n) {
	if (d[c][rot] != -1) {
		return d[c][rot];
	}
	d[c][rot] = 0;
	int base1, base2;
	if (rot == 0) {
		base1 = x[c];
		base2 = y[c];
	}
	if (rot == 1) {
		base1 = y[c];
		base2 = z[c];
	}
	if (rot == 2) {
		base1 = x[c];
		base2 = z[c];
	}
	for (int i = 0; i < n; i++) {
		if ((x[i] < base1 && y[i] < base2) || (y[i] < base1 && x[i] < base2))
			d[c][rot] = MAX(d[c][rot], babylon_sub(i, 0, n) + z[i]);
		if ((y[i] < base1 && z[i] < base2) || (z[i] < base1 && y[i] < base2))
			d[c][rot] = MAX(d[c][rot], babylon_sub(i, 1, n) + x[i]);
		if ((x[i] < base1 && z[i] < base2) || (z[i] < base1 && x[i] < base2))
			d[c][rot] = MAX(d[c][rot], babylon_sub(i, 2, n) + y[i]);
	}
	return d[c][rot];
}
int babylon(int n) {
	for (int i = 0; i < n; i++) {
		d[i][0] = -1;
		d[i][1] = -1;
		d[i][2] = -1;
	}
	int r = 0;
	for (int i = 0; i < n; i++) {
		r = MAX(r, babylon_sub(i, 0, n) + z[i]);
		r = MAX(r, babylon_sub(i, 1, n) + x[i]);
		r = MAX(r, babylon_sub(i, 2, n) + y[i]);
	}
	return r;
}
int main() {
	int t = 0;
	int T;
	cin>>T;
	while(T--){
		int n;
		cin >> n;t++;
		for (int i = 0; i < n; i++) {
			cin >> x[i] >> y[i] >> z[i];
		}
		cout << "Case " << t << ":"<< " maximum height = " << babylon(n);
		cout << endl;
	}
	return 0;
}

方法二:

稍微用了一点拓扑的思路在处理DAG上加速了

//code2
//Andong 2021/1/29
//#include <bits/stdc++.h>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>

#define INF 0x3f3f3f3f
#define ll long long
#define LL long long
using namespace std;
const int maxn = 1e3 + 10;
const ll mod = 1e9 + 7;
int a[maxn],b[maxn],c[maxn];
struct node {
	int c,l,h;
} p[maxn];
vector<int>e[maxn];
int in[maxn],ans[maxn];
int main() {
	int n,cas = 0;
	int T;
	scanf("%d",&T);
	while(T--) {
		scanf("%d",&n);
		memset(in,0,sizeof(in));
		memset(ans,0,sizeof(ans));
		for(int i=0; i<n; i++) {
			scanf("%d%d%d",&a[i],&b[i],&c[i]);
			p[i*3+0].c=min(a[i],b[i]);p[i*3+0].l=max(a[i],b[i]);p[i*3+0].h=c[i];
			p[i*3+1].c=min(a[i],c[i]);p[i*3+1].l=max(a[i],c[i]);p[i*3+1].h=b[i];
			p[i*3+2].c=min(c[i],b[i]);p[i*3+2].l=max(c[i],b[i]);p[i*3+2].h=a[i];
			e[i*3+0].clear();e[i*3+1].clear();e[i*3+2].clear();
		}
		n=n*3;

		for(int i=0; i<n; i++) {
			for(int j=i+1; j<n; j++) {
				if(p[i].c<p[j].c&&p[i].l<p[j].l) {
					e[i].push_back(j);
					in[j]++;
				}
				if(p[i].c>p[j].c&&p[i].l>p[j].l) {
					e[j].push_back(i);
					in[i]++;
				}
			}
		}
		queue<int>num;
		for(int i=0; i<n; i++) {
			if(in[i]==0) {
				num.push(i);
			}
		}
		int ANS=0;
		while(!num.empty()) {
			int tmp = num.front();
			num.pop();
			ans[tmp]=ans[tmp]+p[tmp].h;
			int len = e[tmp].size();
			for(int i=0; i<len; i++) {
				int u=e[tmp][i];
				ans[u]=max(ans[u],ans[tmp]);
				in[u]--;
				if(in[u]==0)num.push(u);
			}
			ANS=max(ANS,ans[tmp]);
		}
		printf("Case %d: maximum height = %d\n",++cas,ANS);
	}
	return 0;
}