坚持就是胜利 - - 

---

1.第N个泰波那切数

力扣链接：力扣

泰波那契序列 Tn 定义如下： 

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

 首先我们分析一下题目，在n>=0的条件下也就是说都是正数，然后给了一个算泰博纳妾数的公式，这道题很简单，但是我们还是一步步带着大家来分析：

首先在我们以后做动态规划的题，都按照一下这个模板来编写：

1.状态表示

首先我们先把公式重新推导一下，让每边减3得到Tn = Tn-3 + Tn-2 + Tn-1 ，Tn就是第n个泰博纳妾数，根据前三个泰波纳妾数推导出来的第n个，所以说dp[i]的状态就是第i个泰波纳妾数

2.状态转移方程

dp[i] = dp[i-1] + dp[i-2] + dp[i-3]    因为第i个泰波纳妾数等于前三个泰波纳妾数的和，所以转移方程就是这个

3.初始化

我们初始化的目的是为了防止越界，如下图：

第0个泰波那切数的前三个都是非法的，所以我们必须给定第0个泰波纳妾数，同理dp[1]和dp[2]同样会越界，而题目又贴心的给了我们初始值，dp[0] = 0,dp[1] = 1,dp[2] = 1 

4.填表以及确定填表顺序

因为我们是知道左边的值，依靠左边的值推出来右边的值，所以顺序是从左向右

5.返回值

既然让我们返回第n个泰波纳妾数，而我们的状态表示dp[i]就表示第i个泰波纳妾数，所以返回dp[n]就是第n个泰波纳妾数

思路理解了我们直接写代码：

class Solution {
public:
    int tribonacci(int n) {
        //1.创建dp表
        //因为是从0开始的所以要多开一个位置
        vector<int> dp(n+1);
        //处理边界条件
        if (n==0) return 0;
        if (n==1||n==2) return 1;
        //2.初始化
        dp[0] = 0,dp[1] = dp[2] = 1;
        //3.状态转移方程
        for (int i = 3;i<=n;i++)
        {
            dp[i] = dp[i-1]+dp[i-2]+dp[i-3];
        }
        //返回值
        return dp[n];
    }
};

 首先创建dp表，由于是从0开始的所以要多开一个位置存储第n个泰波纳妾数，所以空间大小为n+1，因为第0个，第1个，第2个泰波那切数都给出来了，所以我们只需要从第3个泰波那切数开始计算，然后我们处理边界条件，如果不处理那么数组会直接越界，最后返回dp[n]即可。 

下面我们再讲解一下用滚动数组优化的方式，在上面的代码中我们要求第n个太波那契数列数是没必要将n之前的所有泰波那契数都保存的，我们只需要保存前三个就可以算出来了，所以我们只需要用四个变量就能解决这个问题：

 一开始d是第3个泰波那契数，经过滚动后下一次d变成了第4个泰波那契数，下面我们实现一下代码：

class Solution {
public:
    int tribonacci(int n) {
        //初始化前3个泰波那契数
        int a = 0;
        int b = 1;
        int c = 1;
        int d = 0;
        if (n==0) return 0;
        if (n==1||n==2) return 1;
        for (int i = 3;i<=n;i++)
        {
            d= a+b+c;
            a = b;
            b = c;
            c = d;
        }
        return d;
    }
};

 需要注意的是：滚动的时候应该是a向d去依次赋值，不能反过来反过来会导致原本c的值被覆盖。

2.三步问题

力扣链接：力扣

三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。

 首先题目说有n阶台阶，小孩一次可以上1阶或者2阶或者3阶，然后求有多少种上楼的方式，然后还说了题目结果会很大需要取模，下面我们就演示一下上楼梯的步骤：

 首先从地平线到第一个台阶只有一种方法，所以第一个台阶的方法数就是1.

到达第二个台阶可以从第0个台阶跨越2步到达（这是一种方法），也可以从第一个台阶跨越1步到达，由于要想从第一个台阶到第二个台阶就得先到第一个台阶，而到达第一个台阶的方法数是1，所以从第一个台阶到达第二个台阶的方法数为1*1==1.所以到达第二个台阶的总次数为2

到达第三个台阶可以直接从第0个台阶跨越3步到达，也可以从第一个台阶跨越2步到，还可以从第二个台阶跨越1步到达。首先从第0个台阶跨越3步到达方法数是1，从第一个台阶跨越需要知道到达第一个台阶的方法数所以是1*1==1，从第二个台阶跨越1步到达首先要计算到达第二个台阶的方法数所以是2*1 == 2，所以总次数为1 + 1 + 2 = 4.

到达第4个台阶可以从第一个台阶直接跨越3步，也可以从第二个台阶跨越2步，也可以从第3个台阶跨越一步。第一个台阶直接跨越3步的方法数为：1*1==1，第二个台阶跨越2步的方法数为2*1==2，第3个台阶跨越一步的方法数为4*1==4，所以总方法数为1+2+4==7

下面我们直接套模板：

1.状态表示

我们可以看到如果是第5个台阶的话那么有13种方法，而我们创建一个dp表将每个台阶的方法数放入，如下图：

所以dp[i]就表示第i个台阶的方法数。 

2.状态转移方程

可以通过图看到，第5个台阶的方法数是前3个台阶的方法数之和，所以状态转移方程为：

dp[i] = dp[i-1]  + dp[i-2] + dp[i-3]

3.初始化

由于第0,1,2个台阶会越界，所以我们直接给出方法数：dp[0] = 1,dp[1] = 1,dp[2] = 2,这里可能有人会有疑问，为什么到达地平线还有1个方法呢？在这里我们只能说要算第3个台阶的方法数dp[0]必须给1，这是靠分析题目得出来的。

4.填表

从左向右填表

5.返回值

dp[i]表示第i个台阶的方法数，所以返回dp[n]即可。

class Solution {
public:
    int waysToStep(int n) {
       const int MOD = 1e9+7;
       //创建dp表
       vector<int> dp(n+1);
       //解决边界问题
       if (n==0||n==1) return 1;
       if (n==2) return 2;
       dp[0] = 1,dp[1] = 1,dp[2] = 2;
       for (int i = 3;i<=n;i++)
       {
           dp[i] = ((dp[i-1]+dp[i-2])%MOD+dp[i-3])%MOD;
       }
       return dp[n];  
    } 
};

本题需要注意的是要对每次求出的台阶数取模，否则就会越界，我们直接用变量保存将要取模的数

然后在计算结果时每次相加就取模一次。

3.使用最小花费爬楼梯

力扣链接：力扣

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

 这道题有一个隐含条件，直接看实例1，我们大多数人都会认为楼顶就是数组的最后一个位置也就是20的位置，如果是20那么答案应该是10才对，为什么是15呢？因为楼顶其实是在数组最后一个位置的下一个位置：

了解了这个后我们讲一下如何计算：

首先能到达顶楼的位置有两个，要不然是顶楼-1的位置，要不然就是顶楼-2的位置，因为题目已经告诉了每次只能爬一个台阶或者两个台阶。所以我们只需要求出顶楼-1位置的最小花费和顶楼-2位置的最小花费的较小值，我们以实例1为例：

 由于题目已经告诉从0或1开始爬楼梯，所以到达0位置和1位置的最小花费是0.15是第一个台阶到达第一个台阶最小花费是0，然后15跨两步到楼顶需要支付15，所以15->楼顶的最小花费是15.

要计算20这个台阶的最小花费就要先知道哪两个台阶能到20这个位置，很明显从第0个台阶跨两步到20，到达第0个台阶的花费为0，从第0个台阶到第2个台阶的花费为10，所以10->20的花费为10，同理15->20的花费为15，那么到台阶2的最小花费就是10，然后从20->楼顶的花费是20,所以20->楼顶的最小花费是10+20==30。

取楼顶-1台阶的最小值和楼顶-2台阶的最小值相比较，最小的就是到楼顶的最小值，所以刚刚的实例2答案为15.

1.状态表示

dp[i]表示到达第i个台阶的最小花费

2.状态转移方程

dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])

3.初始化

因为题目告诉了从第0个台阶或者第1个台阶开始爬，所以之前到达0或1台阶的最小花费是0，所以dp[0]和dp[1]都等于0

4.填表

5.返回值

由于数组是从0开始的，size()的大小就是楼顶的位置，所以返回dp[size()]即可。

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        if (cost.size()<=0)
        {
            return 0;
        }
        //创建dp表
        int sz = cost.size();
        vector<int> dp(sz+1);
        //初始化
        dp[0] = dp[1] = 0;
        for (int i = 2;i<=sz;i++)
        {
            dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[sz];
    }
};

 上面我们是按照从前往后推的下面我们也可以换一个思想，从后往前推：

 比如我们现在在第7个台阶，那么我们支付了第7个台阶的费用后可以向后走一步也可以走两步，走一步到第8个台阶，第8个台阶花费100直接能到楼顶。走两步到第9个台阶，花费1直接就能到楼顶，这个时候我们第7个台阶到达楼顶的最小花费就是：第8个台阶和第9个台阶到达楼顶的最小花费的最小值，所以第7个台阶的最小花费就是1+1（+1是因为自己支付了费用要向后跳），以此类推从第7个台阶推到第0个台阶，又因为我们是从0或1出发，所以最后的返回值是0位置和1位置最小花费的最小值。

1.状态表示

dp[i]表示从i位置支付费用后到达楼顶花费的最小值

2.状态转移方程

dp[i] = min(dp[i+1],dp[i+2]) + cost[i]   (要记住我们从i位置起跳是需要花钱的所以要加上cost[i]）

3.初始化

可以看到我们的转移方程是i+1和i+2，所以在距离楼顶的2个位置和1个位置的台阶是无法计算的因为越界了，并且从这两个位置起跳到楼顶只需要花费自身cost的费用。所以dp[楼顶-1] = cost[楼顶-1],dp[楼顶-2] = cost[楼顶-2]

4.填表

从右向左填表：

5.返回值

返回dp[0]和dp[1]的较小值

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //创建dp表
        int sz = cost.size();
        vector<int> dp(sz);
        //初始化
        dp[sz-1] = cost[sz-1];
        dp[sz-2] = cost[sz-2];
        for (int i = sz-3;i>=0;i--)
        {
            dp[i] = min(dp[i+1],dp[i+2]) + cost[i];
        }
        return min(dp[0],dp[1]);
    }
};

4.解码方法

力扣链接：力扣

 首先我们要能读懂题，我们做的是解码工作，题目会给我们一个数字字符串，然后我们可以有多少种方法将数字转化为不同的字符顺序，要注意的是一旦有0作为前导就会解码失败，可以看实例3。（但是如果是两个字符，比如10那么可以解码为K那么就是一种方法）.首先题目要求字符串的解码总数，那我们根据经验就可以得出状态表示，解码总数就是以字符串最后一个字符为结尾的总解码数。

1.状态表示

dp[i]表示以i字符为结尾的总解码数

2.状态转移方程

首先我们要知道dp[i]的方法数就要看s[i]这个字符能否解码，如果这个字符>='1'并且<='9'那么就是可以解码的，一旦这个字符可以解码就说明总方法数是dp[i-1]，如下图：

 比如上图中dp[i]有三种方法分别是abc,acb,cba，当s[i]可以解码时就可以放在他们的后面，但是方法还是3种，因为我们要求的是以i为结尾的方法数而不是字符个数！当s[i]为0时那么在前面的所有努力都白费了，直接dp[i]等于0

当我们的s[i]可以和s[i-1]相结合变成一个新的字符时，那么就可以把s[i]和s[i-1]看成一个字符，那么总方法数就是前面i-2的方法数，所以是dp[i-2]

3.初始化

状态转移方程中只有0和1位置会越界，所以初始化0和1

首先如果第一个字符是>='1'&&<='9'，那么dp[0]就是1，否则就是0

如果第2个字符可以解码，那么方法数就是i-1的方法数那就是1，如果第二个字符还可以和第一个字符结合，那么方法数就变成2

4.填表

已知0和1位置，所以从左向右填表：

5.返回值

返回以字符串最后一个字符为结尾的总方法数

class Solution {
public:
    int numDecodings(string s) {
      //创建dp表
      int sz = s.size();
      vector<int> dp(sz,0);
      //初始化
      dp[0] = s[0]!='0';
      //解决边界条件
      if (dp[0]==0) return 0;
      if (sz==1) return dp[0];
      //初始化
      if (s[1]>='1'&&s[1]<='9')
      {
          dp[1] = 1;
      }
      int t = (s[0]-'0')*10 + s[1]-'0';
      if (t>=10&&t<=26)
      {
          ++dp[1];
      }
      for (int i = 2;i<sz;i++)
      {
          if (s[i]>='1'&&s[i]<='9')
          {
              dp[i] += dp[i-1];
          }
          int t = (s[i-1]-'0')*10+s[i]-'0';
          if (t>=10&&t<=26)
          {
              dp[i] += dp[i-2];
          }
      }
      return dp[sz-1];
    }
};

 需要注意的是如果s[0]为0那么是不能解码的，当字符串长度为1时要返回dp[0]也就是第一个字符的方法数，否则我们下面的初始化dp[1]会越界。

下面我们讲一下能优化初始化的思路：

我们可以给dp表多开一个空间，这个位置放的值要视情况而定，如下图：

 我们在原先dp表的基础上多开了一个位置，那么这个位置该放多少呢？首先我们知道，第一个字符是一定要初始化的，第一个字符对应的dp表的位置再dp[1]，我们将这个位置初始化使用动态转移方程的时候才不会越界（只要满足i-1,i-2不越界），dp[1]是我们自己初始化的，dp[2]需要状态转移方程计算，当第二个字符可以解码那么方法数是dp[i-1]也就是第一个字符的方法数1，然后第二个字符还可以和第一个字符结合，一旦结合解码数就变成dp[i-2]，而dp[i-2]是我们的虚拟位置，如果我们第一个虚拟位置初始化为0，计算dp[i-2]的时候就会少一个方法数，所以1才是正确的，我们也可以再举一个例子：

 拿"2 0"来说，0位置的方法数是dp[i-1]+dp[i-2]，由于是0所以dp[i-1]是0，dp[i-2]是我们的虚拟位置，2和0是可以结合的所以要有一种方法，如果虚拟位置为0就是0种方法就错了，所以虚拟位置应该为1.有了虚拟位置那么计算对应的字符串都需要-1，原来-1的要变成-2的字符，比如dp[i]的方法数是s[i-1]位置的字符的方法数。

class Solution {
public:
    int numDecodings(string s) {
      //创建dp表
      int sz = s.size();
      vector<int> dp(sz+1,0);
      //初始化
      dp[0] = 1;
      dp[1] = s[0]!='0';
      for (int i = 2;i<=sz;i++)
      {
          if (s[i-1]>='1'&&s[i-1]<='9')
          {
              dp[i] += dp[i-1];
          }
          int t = (s[i-2]-'0')*10+s[i-1]-'0';
          if (t>=10&&t<=26)
          {
              dp[i] += dp[i-2];
          }
      }
      return dp[sz];
    }
};

可以看到此方法不仅简化了代码而且让我们的初始化变的更简单。