递归在C++中确实很慢

我知道递归在某些语言中很快（甚至比迭代更快）。但我说的是C++（也许C也是一样的）。

我正在解决一个在线评委问题（不是家庭作业）。我使用自上而下的动态编程方法解决了这个问题。但我最后得了两个TLE。然后，我使用了自下而上的方法，解决方案被接受了。然而，在这个问题中，我认为自上而下应该更快，因为可以进行优化来跳过一些不需要计算的状态。

问题说明：http://www.hkoi.org/training2004/files/need-for-speed.pdf

代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;
int n, max_t; 
int num[51][50001];
int ts[50][50];
int ms[50];
int ls[50];
#ifdef RECURSION
int solve(int rn, int tleft)
{
    if (rn >= n)
        return 0;
    if (num[rn][tleft] != -1)
        return num[rn][tleft];
    int t;
    int max_num = solve(rn + 1, tleft);
    for (int i = rn; i < n; ++i)
    {
        t = ls[i];
        for (int j = 0; j < ms[i]; ++j)
        {
            t += ts[i][j];
            if (t > tleft)
                break;
            max_num = max(max_num, solve(i + 1, tleft - t) + j + 1);
        }
    }
    num[rn][tleft] = max_num;
    return max_num;
}
#endif
int main()
{
    scanf("%d %d", &n, &max_t);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d %d", ls + i, ms + i);
        for (int j = 0; j < ms[i]; ++j)
        {
            scanf("%d", ts[i] + j);
        }
        sort(ts[i], ts[i] + ms[i]);
    }
    for (int i = 0; i <= n; ++i)
    {
        for (int j = 0; j <= max_t; ++j)
        {
            #ifdef RECURSION
            num[i][j] = -1;
            #else
            num[i][j] = 0;
            #endif
        }
    }
    #ifdef RECURSION
    printf("%dn", solve(0, max_t));
    #endif
    #ifndef RECURSION
    int t;
    for (int i = n - 1; i >= 0; --i)
    {
        for (int j = 0; j <= max_t; ++j)
        {
            t = ls[i];
            num[i][j] = num[i + 1][j];
            for (int k = 0; k < ms[i]; ++k)
            {
                t += ts[i][k];
                if (t > j)
                    break;
                num[i][j] = max(num[i][j], num[i + 1][j - t] + k + 1);
            }
        }
    }
    printf("%dn", num[0][max_t]);
    #endif
}

正如您在递归版本中看到的，有一行max_num = max(max_num, solve(i + 1, tleft - t) + j + 1);。由于t增加了一个整数，但并不总是=1，因此跳过了某些情况。然而，在迭代版本中，会计算出许多无用的状态。

我认为，如果迭代解决方案更快，那么递归必须比迭代慢得多。我的说法正确吗？