堆箱子 叠罗汉

有一堆箱子，每个箱子宽为wi，长为di，高为hi，现在需要将箱子都堆起来，而且为了使堆起来的箱子不到，上面的箱子的宽度和长度必须小于下面的箱子。请实现一个方法，求出能堆出的最高的高度，这里的高度即堆起来的所有箱子的高度之和。
给定三个int数组w,l,h，分别表示每个箱子宽、长和高，同时给定箱子的数目n。请返回能堆成的最高的高度。保证n小于等于500。
测试样例：
[1,1,1],[1,1,1],[1,1,1]
返回：1

本题是一个利用动态规划求最大严格上升子序列的问题，由于要满足 底盘长宽的限制， 因此只需要找到满足 长与宽闲置的一个最大上升子序列即可，然后求出最大高度。

进行计算前，需要对初始数组进行排序(即三个传入参数)，按单关键字排序即可,即宽度或高度。
其中f[n]表示前 n个箱子可以堆的最大高度。

class Box {
     int f[501] = {0}; //存放n个箱子的最大上升高度
public:

    int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {

        for(int i = w.size()-1 ; i > 0; i--){
            for(int j = w.size()-1; j > w.size()- 1 - i ; j--){
                if(w[j] >= w[j-1]/*&& l[j] >= l[j-1]*/){
                    swap(w[j],w[j-1]);
                    swap(l[j],l[j-1]);
                    swap(h[j],h[j-1]);
                }
            }
        }

        for(int i = 0; i < w.size(); i++){
            cout<<w[i]<<" "<<l[i]<<" "<<h[i]<<endl;
        }
        f[0] = h[0];
        int maxv = f[0];
        for(int i = 1; i < n; i++){
            f[i] = h[i];
            int tmax = 0;
            for(int j = i-1; j >= 0; j--){
                if(w[i] < w[j] && l[i] < l[j]){
                    tmax = max(tmax,f[j]);
                }
            }
            f[i] += (tmax);
            maxv = max(maxv,f[i]);
        }
        return maxv;
    }
};

class Box {
public:
    int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {
        if(n==0) return 0;
        if(n==1) return h[0];
        for(int i=1;i<n;++i){
            for(int j=0;j<n-i;++j){
                if(w[j] > w[j+1]){
                    swap(w[j],w[j+1]);
                    swap(l[j],l[j+1]);
                    swap(h[j],h[j+1]);
                }
            }
        }
        int height[n];
        height[0]= h[0];
        int maxheight = h[0];
        for(int i=1;i<n;++i){
            height[i] = h[i];
            for(int j=i-1;j>=0;--j){
                if(w[i] > w[j] && l[i]>l[j]){
                    height[i] = max(height[i],h[i]+height[j]);
                }
            }
            maxheight = max(maxheight, height[i]);
        }
        return maxheight;
    }
};

typedef struct{
    int w;
    int l;
    int h;
}box;

bool comp(const box& l,const box& r){
    if(l.w < r.w)
        return true;
    else if(l.w > r.w)
        return false;
    else
        return l.l < r.l;
}

class Box {
public:
    int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {
        // write code here
        int size = w.size();
        vector<box> v;
        for(int i = 0;i < size;i++){
            box tmp;
            tmp.w = w[i];
            tmp.l = l[i];
            tmp.h = h[i];
            v.push_back(tmp);
        }
        sort(v.begin(),v.end(),comp);

        vector<int> dp(size,0);
        dp[0] = v[0].h;
        int g_max = v[0].h;
        for(int i = 1;i<size;i++){
            for(int j = 0;j < i;j++){
                if(v[i].w > v[j].w && v[i].l > v[j].l)
                    dp[i] = max(dp[i],dp[j]);
            }
            dp[i] += v[i].h;
            if(dp[i] > g_max)
                g_max = dp[i];
        }
        return g_max;
    }
};

int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {
        // write code here
        for(int i=1;i<n;i++){
            for(int j=0;j<n-i;j++){
                if(w[j]>w[j+1]){
                    swap(w[j+1],w[j]);
                    swap(l[j+1],l[j]);
                    swap(h[j+1],h[j]);
                }
            }
        }
        vector<int> res(n,0);   //记录h[i]在最上面时的最大高度
        int maxH=0;
        res[0]=h[0];
        for(int i=1;i<n;i++){
            res[i]=h[i];
            for(int j=i-1;j>=0;j--){
                if(w[i]>w[j] && l[i]>l[j])
                    res[i]=max(res[i],h[i]+res[j]);
            }
            maxH=max(res[i],maxH);
        }

        return maxH;
    }

class Box {
public:
    int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {
        // write code here
        for(int i=0;i<n;++i){
            for(int j=i+1;j<n;++j){
                if(w[i]>w[j]){
                    swap(w[i],w[j]);
                    swap(l[i],l[j]);
                    swap(h[i],h[j]);
                }
            }
        }
        vector<int> res(n,0);   //记录h[i]在最上面时的最大高度
        int maxH=0;
        res[0]=h[0];
        for(int i=1;i<n;i++){
            res[i]=h[i];
            for(int j=i-1;j>=0;j--){
                if(w[i]>w[j] && l[i]>l[j])
                    res[i]=max(res[i],h[i]+res[j]);
            }
            maxH=max(res[i],maxH);
        }

        return maxH;
    }
};

typedef struct{
    int w;
    int l;
    int h;
}box;

bool comp(const box& l,const box& r){
    if(l.w < r.w)
        return true;
    else if(l.w > r.w)
        return false;
    else
        return l.l < r.l;
}

class Box {
public:
    int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) {
        // write code here
        int size = w.size();
        vector<box> v;
        for(int i = 0;i < size;i++){
            box tmp;
            tmp.w = w[i];
            tmp.l = l[i];
            tmp.h = h[i];
            v.push_back(tmp);
        }
        sort(v.begin(),v.end(),comp);

        vector<int> dp(size,0);
        int g_max = v[0].h;
        for(int i = 0;i<size;i++){
            dp[i] = v[i].h;
            for(int j = 0;j < i;j++){
                if(v[i].w > v[j].w && v[i].l > v[j].l)
                    dp[i] = max(dp[i],dp[j]+v[i].h);
            }
             if(dp[i] > g_max)
                g_max = dp[i];
        }
        return g_max;
    }
};

叠罗汉1

叠罗汉是一个著名的游戏，游戏中一个人要站在另一个人的肩膀上。同时我们应该让下面的人比上面的人更高一点。已知参加游戏的每个人的身高，请编写代码计算通过选择参与游戏的人，我们多能叠多少个人。注意这里的人都是先后到的，意味着参加游戏的人的先后顺序与原序列中的顺序应该一致。
给定一个int数组men，代表依次来的每个人的身高。同时给定总人数n，请返回最多能叠的人数。保证n小于等于500。
测试样例：
[1,6,2,5,3,4],6
返回：4

class Stack {
public:
    int BiSearch(int *b, int len, int w)  
    {  
        int left = 0, right = len - 1;  
        int mid;  
        while (left <= right)  
        {  
            mid = left + (right-left)/2;  
            if (b[mid] > w)  
                right = mid - 1;  
            else if (b[mid] < w)  
                left = mid + 1;  
            else    //找到了该元素，则直接返回  
                return mid;  
        }  
        return left;//数组b中不存在该元素，则返回该元素应该插入的位置  
    }  
    int getHeight(vector<int> men, int n) {
        // write code here
        int B[n];
        int len = 1;  
        B[0] = men[0];  
        int i, pos = 0;  

        for(i=1; i<n; ++i)  
        {  
            if(men[i] > B[len-1]) //如果大于B中最大的元素，则直接插入到B数组末尾  
            {  
                B[len] = men[i];  
                ++len;  
            }  
            else  
            {  
                pos = BiSearch(B, len, men[i]); //二分查找需要插入的位置  
                B[pos] = men[i];  
            }  
        }  

        return len;  

    }
};

叠罗汉2
题目描述
叠罗汉是一个著名的游戏，游戏中一个人要站在另一个人的肩膀上。为了使叠成的罗汉更稳固，我们应该让上面的人比下面的人更轻一点。现在一个马戏团要表演这个节目，为了视觉效果，我们还要求下面的人的身高比上面的人高。请编写一个算法，计算最多能叠多少人，注意这里所有演员都同时出现。

给定一个二维int的数组actors，每个元素有两个值，分别代表一个演员的身高和体重。同时给定演员总数n，请返回最多能叠的人数。保证总人数小于等于500。

测试样例：
[[1,2],[3,4],[5,6],[7,8]],4
返回：4

class Stack {
public:
    int getHeight(vector<vector<int> > actors, int n) {
        // write code here
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++)
                if(actors[j][0]>actors[i][0])
                    {
                    swap(actors[j][0],actors[i][0]);
                    swap(actors[j][1],actors[i][1]);
                }
        vector<int> dp(n+1,1);//dp表示前n个人最多能叠几个
        int maxnum=0;
        for(int i=0;i<n;i++)
            {
               int temp=1;
            for(int j=i-1;j>=0;j--)
                {
                  if(actors[j][1]>actors[i][1])
                      temp=max(temp,dp[j]+1);
            }
            dp[i]=temp;
            maxnum=max(maxnum,dp[i]);
        }
        return maxnum;
    }
};

#include<cstdio>
#include<iostream>
#include<algorithm>
#define MAX 1024
using namespace std;

typedef struct player{
    int n;
    int w;
    int h;
}man;

man a[MAX];
int h[MAX];

bool cmp(man a, man b){
    if(a.w > b.w){
        return true;
    } else if(a.w == b.w){
        if(a.h < b.h){
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

int dp(int N){
    int res = 0;
    for(int i = 1 ; i <= N ; i++){
        h[i] = 1;
        for(int j = 1 ; j < i ; j++){
            if(a[j].h >= a[i].h && h[j] >= h[i]){
                h[i] = h[j] + 1;
            }
        }
        if(h[i] > res){
            res = h[i];
        }
    }
    return res;
}



int main() {
    int N;
    while(cin >> N){
        for(int i = 1 ; i <= N ; i++){
        cin >> a[i].n >> a[i].w >> a[i].h;
    }
    sort(a + 1, a + N + 1, cmp);
    printf("%d\n", dp(N));
    }

    return 0;
}