n阶台阶，一次走1步或2步，有多少种走法？

分析

这是个典型的动态规划算法问题，你能确定的只有当前的可能1步或者2步，加上以后的可能走法。
以后可能的走法就是递归体了。
所以从这个分析就可以得到递归算法的实现了。
因为任何递归算法都是树形结构。
所以把递归中的各个结点展示出来以后，会发现有很多重复的数值，重复计算太多是浪费CPU的资源。
因为n会得到n-1和n-2，并且n-1会得到n-2和n-3。
从这里可以看出来，n-2来自于n和n-1，并且有多少个n就有多少个n-2，有多少个n-1就有多少个n-2，于是n-2的个数就等于n的个数加n-1的个数，这个性质是什么？就是斐波那切数列。
于是问题变为求n阶斐波那切数列的总和。
说句题外话，斐波那切数列也叫兔子数列。
于是可以得到非递归的算法。

代码用法

import Foundation

print("总的走法有\(Solution.recursionAnswer(n: -1))种")
print("总的走法有\(Solution.nonRecursiveAnswer(n: 10))种")

输出

总的走法有0种
总的走法有143种
Program ended with exit code: 0

代码实现

import Foundation

class Solution {
    public static func recursionAnswer(n:Int) -> Int {
        guard n >= 1 else {
            return 0
        }
        var resultCounter:Int = 1
        if n - 1 > 0 {
            resultCounter += Solution.recursionAnswer(n: n - 1)
        }
        if n - 2 > 0 {
            resultCounter += Solution.recursionAnswer(n: n - 2)
        }
        return resultCounter
    }
    
    public static func nonRecursiveAnswer(n:Int) -> Int {
        guard n >= 1 else {
            return 0
        }
        if n == 1 {
            return 1
        }
        if n == 2 {
            return 2
        }
        var component0:Int = 1
        var component1:Int = 1
        var counter:Int = 3
        var result:Int = 2
        var middleValue:Int = 0
        while counter <= n {
            middleValue = component0 + component1
            component0 = component1
            component1 = middleValue
            counter += 1
            result += middleValue
        }
        return result
    }
}