因为上楼和下楼是⼀个可逆的过程，因此我们可以把下楼问题转化成上到第n个台阶，⼀共有多少种⽅案。
解法：动态规划

1. 状态表⽰：
   dp[i] 表⽰：⾛到第i 个台阶的总⽅案数。
   那最终结果就是在dp[n]处取到。
2. 状态转移⽅程：
   根据最后⼀步划分问题，⾛到第i 个台阶的⽅式有三种：
   a. 从i - 1 台阶向上⾛1 个台阶，此时⾛到i 台阶的⽅案就是dp[i - 1] ；
   b. 从i - 2 台阶向上⾛2 个台阶，此时⾛到i 台阶的⽅案就是dp[i - 2] ；
   c. 从i - 3 台阶向上⾛3 个台阶，此时⾛到i 台阶的⽅案就是dp[i - 3] ；
   综上所述，dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3] 。
3. 初始化：
   填i位置的值时，⾄少需要前三个位置的值，因此需要初始化dp[0] = 1, dp[1] = 1, dp[2] = 2，然后从i = 3开始填。
   或者初始化dp[1] = 1, dp[2] = 2, dp[3] = 4，然后从i = 4 开始填。
4. 填表顺序：
   明显是从左往右

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 65;

int n;
LL f[N]; //f[i]表示有i个台阶的时候，一共有多少种方案

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n;

    //初始化
    f[0] = 1; f[1] = 1; f[2] = 2;

    for (int i = 3; i <= n; i++)
    {
        f[i] = f[i - 1] + f[i - 2] + f[i - 3];       
    }

    cout << f[n] << endl;
    
    return 0;
}

动态规划的空间优化：
我们发现，在填写dp[i]的值时，我们仅仅需要前三个格⼦的值，第i-4个及其之前的格⼦的值已经毫⽆⽤处了。因此，可以⽤三个变量记录i位置之前三个格⼦的值，然后在填完i位置的值之
后，滚动向后更新

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 65;

int n;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n;

    LL a = 1, b = 1, c = 2;

    for (int i = 3; i <= n; i++)
    {
        LL t = a + b + c;
        a = b;
        b = c;
        c = t;
    }

    if (n == 1) cout << b << endl;
    else cout << c << endl;
    
    return 0;
}

学习动态规划最经典的⼊⻔题。
解法：动态规划

1. 状态表⽰：
   dp[i][j] 表⽰：⾛到[i, j] 位置的最⼤权值。
   那最终结果就是在dp 表的第n ⾏中，所有元素的最⼤值。
2. 状态转移⽅程：
   根据最后⼀步划分问题，⾛到[i, j] 位置的⽅式有两种：
   a. 从[i - 1, j] 位置向下⾛⼀格，此时⾛到[i, j] 位置的最⼤权值就是dp[i - 1][j] ；
   b. 从[i - 1, j - 1]位置向右下⾛⼀格，此时⾛到[i, j] 位置的最⼤权值就是dp[i - 1][j - 1] ；
   综上所述，应该是两种情况的最⼤值再加上[i,j]位置的权值：
   dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1]) + a[i][j]
3. 初始化：
   因为dp 表被0 包围着，并不影响我们的最终结果，因此可以直接填表。
   思考，如果权值出现负数的话，需不需要初始化？
   ◦ 此时可以全都初始化为$-\infty$ ，负⽆穷⼤在取max 之后，并不影响最终结果。
4. 填表顺序：
   从左往右填写每⼀⾏，每⼀⾏从左往右

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;

int n;
int a[N][N];
int f[N][N]; //f[i][j]表示从1，1走到i，j的时候，所有方案数的最大权值

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n;

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            cin >> a[i][j];

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            f[i][j] = max(f[i-1][j], f[i-1][j-1]) + a[i][j];    
        }
    }

    int ret = 0;
    for (int j = 1; j <= n; j++)
    {
        ret = max(ret, f[n][j]);        
    }
    cout << ret << endl;
    
    return 0;
}

动态规划的空间优化：
我们发现，在填写第i ⾏的值时，我们仅仅需要前⼀⾏的值，并不需要第i - 2 以及之前⾏的值。
因此，我们可以只⽤⼀个⼀维数组来记录上⼀⾏的结果，然后在这个数组上更新当前⾏的值

需要注意，当⽤因为我们当前这个位置的值需要左上⻆位置的值，因此滚动数组优化的时候，要改变第⼆维的遍历顺序

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;

int n;
int a[N][N];
int f[N]; //f[i][j]表示从1，1走到i，j的时候，所有方案数的最大权值

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n;

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            cin >> a[i][j];

    for (int i = 1; i <= n; i++)
    {
        for (int j = i; j >= 1; j--)
        {
            f[j] = max(f[j], f[j-1]) + a[i][j];    
        }
    }

    int ret = 0;
    for (int j = 1; j <= n; j++)
    {
        ret = max(ret, f[j]);        
    }
    cout << ret << endl;
    
    return 0;
}