用方块和限制建造最大的堆叠塔

问题

问题是在尊重所有规则的情况下，建造由圆柱体组成的最高的塔。

• 将桌子上摆放的，数量为N个气瓶。
• 每个圆柱体有一种颜色:红色、橙色、绿色或蓝色。
• 每个圆柱体有一个高度h和一个半径为r的底。
• 要建塔，钢瓶应该堆叠，并且顶部圆柱体的底部应该比底部小柱体下面。除了第一个圆柱体，它可以有底部任何尺寸，因为它下面没有其他圆柱。

对于圆柱体的颜色也有一些非常有趣的限制。它们描述如下。

• 红色圆柱体不能放在橙色圆柱体上
• 橙色圆柱体不能放在蓝色圆柱体上
• 蓝色圆柱体不能放在绿色圆柱体上
• 绿色圆柱体不能放在红色圆柱体上

输入包含几个测试用例。每个测试用例的第一行包含一个整数N (1 <= N <= 10^3)，表示排列在表格上的圆柱体的数量，然后是N行，每一行有圆柱体的高度h (1 <= h <= 1000)，圆柱体基座的半径r (1 <= r <= 1000)，以及一个单词p，表示圆柱体的颜色。单词可以是:RED, ORANGE, GREEN或BLUE。输入结束表示为N = 0，不处理

对于每个测试用例，您的程序应该打印一行，其值为可以建造的最大圆柱体塔的高度，后跟单词"cm (s)"。

5   
5 3 RED    
4 2 ORANGE   
1 1 GREEN    
3 5 ORANGE    
2 4 BLUE    
3    
10 10 ORANGE    
5 10 GREEN    
6 5 RED    
0

15 centimeter(s)    
11 centimeter(s)

我试图用动态规划来解决这个问题，但它需要超过8秒才能给出一个大输入的答案(在限制范围内);这个解决方案适合这个问题吗?还有其他的算法吗?

#include <cstdio>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <string.h>
#define MAX 1000
#define NON -1
#define RED 3
#define ORA 2
#define BLU 1
#define GRE 0
struct cylinder_t{
    int h,r,c;
    cylinder_t():h(0),r(0),c(0){}
    cylinder_t(int height, int radius, int color):h(height),r(radius),c(color){}
};
inline bool compare (const cylinder_t &i,const cylinder_t &j) {
    return i.r > j.r;
}
cylinder_t cylinder[MAX];
inline bool canPut(int i, int last_cylinder_onStack){
    if(last_cylinder_onStack == NON)
        return true;
    if (cylinder[i].r >= cylinder[last_cylinder_onStack].r)
        return false;
    if((cylinder[i].c - cylinder[last_cylinder_onStack].c + 4)%4 == 1)
        return false;
    return true;
}
int memo[MAX][MAX];
int dp(int tower_size, int size, int last_cylinder_onStack){
    if(tower_size == size)
        return 0;
    if(last_cylinder_onStack != NON && memo[tower_size][last_cylinder_onStack] != -1)
        return memo[tower_size][last_cylinder_onStack];
    int maxHeight = 0;
    for (int c = tower_size; c < size; ++c) {
        if(canPut(c, last_cylinder_onStack))
            maxHeight = std::max(maxHeight, cylinder[c].h + dp(tower_size + 1, size, c));
    }
    if(last_cylinder_onStack == NON)
        return maxHeight;
    return memo[tower_size][last_cylinder_onStack] = maxHeight;
}
int main(void){
    //clock_t t;
    //t = clock();
    std::unordered_map<std::string, int> map;
    map["RED"]    = RED;
    map["ORANGE"] = ORA;
    map["GREEN"]  = GRE;
    map["BLUE"]   = BLU;
    int n;
    while(scanf("%d",&n), n != 0){
        for (int i = 0; i < n; ++i) {
            int height,radius;
            char color[15];
            scanf("%d %d %s",&height,&radius,&color[0]);
            cylinder[i].h = height;
            cylinder[i].r = radius;
            cylinder[i].c = map[std::string(color)];
        }
        std::sort(cylinder, cylinder + n, compare);
        memset(memo, -1, sizeof(memo));
        printf("%d centimeter(s)n",dp(0,n, NON));
    }
    //t = clock() - t;
    //printf("Took %lf seconds to execute n",((double)t)/CLOCKS_PER_SEC);
}

我已经在JAVA中为这个问题做了一个INPUT生成器:

import java.io.IOException;
import java.util.Random;

public class Main {
    public static void main(String[] args) throws IOException {
        Random r = new Random();
        String color[] = {"RED","ORANGE","GREEN","BLUE"};
        int t = 20;//number of test cases
        for (int i = 0; i < t; i++) {
            int n = r.nextInt(1000) + 1; //number of cylinders
            System.out.println(n);
            for (int j = 0; j < n; j++) {
                System.out.printf("%d %d %sn",r.nextInt(1000) + 1,r.nextInt(1000) + 1,color[r.nextInt(4)]);
            }
        }
        System.out.println("0");
    }
}