【线性dp||dfs+dp】小y的tower

UPC2020年春混合个人训练 5.4日场

题目描述
如果时光回到从前，或许，一切只是虚无
小Y坐着时光穿梭机，到达了一个神奇的三维时空，在这里，开始了ta的梦幻之旅
这是一个神奇的三维世界，ta看到了许多三维立方体，每个立方体都有各自的长、宽、高。现在ta想搭起一个很高很高的tower，送给小L，但是ta非常有心，又希望这个tower有非常的稳定性（众所周知triangle是一个非常有稳定性的结构（大雾）2333）。于是，ta希望放在下面的立方体的长和宽都分别大于（严格大于哦）它上面的立方体的长和宽。现在ta想知道ta究竟能堆出多高的tower。
又由于三维立方体是长方体的，因此你可以把它随意转动，也就是说，它的长、宽、高是可以随意互换的。每种立方体的数量都可认为是无限个，当然，你不可能全部用上。
你能帮助小Y吗？
输入
第一行，一个整数n，表示三维立方体的数量。
接下来n行，每行三个整数，表示一个三维立方体的长、宽、高。
输出
一行，一个整数，表示可以堆起的tower的最大高度。
样例输入
2
4 8 5
2 6 3
样例输出
18
提示
样例解释
三维立方体表示为（长，宽，高）；
则从下到上依次为（8，5，4），（5，4，8），（3，2，6）。
【数据范围】
对于30%的数据，n<=10；
对于60%的数据，n<=30；
对于100%的数据，n<=100。
保证答案不在32位整数内，就是pascal选手的longint以内以及c++或c选手的int内！
解题思路一：对于每组数据，每个数都有一次机会做高，也就是有三种情况，这里的长宽没有严格的比较大小，另外开一个二维数组s[i][j]表示箱子j能放到i上面，这个题就能形成一个有向无环图，然后再用dp加递归计算出最大的高度

#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
const int maxn = 1e6+7;
typedef pair<ll,ll> PII;
vector<int>v[110];
deque<ll>q;
ll n,m;
struct node{
    ll x,y,z;
}a[maxn];
ll s[1000][1000],dp[maxn];   ///dp[i]表示以i为基点的最大高度
ll check(ll i,ll j){       ///判断j是否能放在i上面
    if(a[j].x<a[i].x&&a[j].y<a[i].y) return 1;
    if(a[j].x<a[i].y&&a[j].y<a[i].x) return 1;
    return 0;
}
ll dfs(ll k){       ///递归求以k为基点的最大值
    if(dp[k]) return dp[k];
    ll res=0;
    for(ll i=1;i<=3*n;i++)
    {
        if(s[k][i])
        {
            res=max(res,dfs(i));
        }
    }
    dp[k]=a[k].z+res;
    return dp[k];
}
int main(){
    ll c,k,g;
    scanf("%lld",&n);
    for(ll i=1;i<=3*n;i+=3)       ///开3倍，记录三种情况
    {
        scanf("%lld%lld%lld",&c,&k,&g);
        a[i].x=c,a[i].y=k,a[i].z=g;
        a[i+1].x=c,a[i+1].y=g,a[i+1].z=k;
        a[i+2].x=k,a[i+2].y=g,a[i+2].z=c;
    }
    for(ll i=1;i<=3*n;i++)
    {
        for(ll j=1;j<=3*n;j++)
        {
            if(check(i,j)) s[i][j]=1;
        }
    }
    ll maxx=0;
    for(int i=1;i<=3*n;i++)
        maxx=max(maxx,dfs(i));   ///计算最大值
    cout << maxx;
    return 0;
}

解题思路二：感谢大佬跃哥带来的线性dp，也是每组数据分三种情况，不过这里要分出具体的长和宽，排一波序，dp[i]表示以i结尾的最大高度，具体见代码

#include<bits/stdc++.h>
using namespace std;
struct cube{
	int length,wide,high;
}st[310];
int f[310],s;
bool cmp(cube x,cube y)
{
	return x.length > y.length;
}
int main()
{
	int n;
	cin>>n;
	while(n--)
	{
		int a[3];
		cin>>a[0]>>a[1]>>a[2];
		sort(a,a+3);
		s++;
		st[s].high=a[2],st[s].length=a[1],st[s].wide=a[0];
		s++;
		st[s].high=a[1],st[s].length=a[2],st[s].wide=a[0];
		s++;
		st[s].high=a[0],st[s].length=a[2],st[s].wide=a[1];
	}
	sort(st+1,st+s+1,cmp);   ///以长为标准，降序排列，保证以第i个立方体结尾的下面立方体在i的前面
	int ans=0;
	for(int i=1;i<=s;i++)
	{
		f[i]=st[i].high;    ///f[i]表示以当前立方体为最后一个的最优解 
		for(int j=i;j>=1;j--)
		{
			if(st[j].length>st[i].length&&st[j].wide>st[i].wide)
			{
				f[i]=max(f[i],f[j]+st[i].high);
			}
			ans=max(f[i],ans);
		}
	}
	cout<<ans<<endl;
	return 0;
}

的确当我们只有失去时才知道当时拥有的是什么，同样，只有当我们拥有了才知道曾经失去了什么