C++数据结构算法（四）递推与递归

递推思想简介：

递推，意思就是用已经有的信息一点点推出想要知道的信息。

比如，平面上有一个机器人，一开始在坐标(0,0)处，第一秒向东移动一米，第二秒向南移动两米，第三秒向西移动三米，第四秒向北移动四米……机器人一直按照这个规律移动下去。由于我们知道了最开始的时候机器人的位置，我们就可以一秒一秒地推算出接下来每一个时刻机器人的位置。这就是递推。

显然，如果我们用人脑去模拟一个递推算法，是比较简单的，因为“根据已有信息推出未知信息”是我们常用的思考方式，符合直觉。

如果用电脑运行递推算法，我们应该考虑使用循环。我们可以在循环的过程中使用数组和临时变量记录下来每一步递推的过程和结果。比如在刚刚的机器人例子中，我们可以使用数组来记录每一秒结束时机器人的具体位置，使用临时变量来记录机器人当前的朝向。这和我们使用人脑模拟递推算法的区别不大。

• 递推思想：

  根据已有的东西一点点地推出未知的东西。

• 使用递推解题三步骤：

  • 数学建模
  • 找出递推式和初始条件
  • 写出代码。

• 张爽的青蛙（斐波那契）问题：地上有nn个石头从左到右排成一排，张爽同学养的青蛙要从第一个石头跳到最后一个石头上，每次可以选择向右跳一格或者跳两格，问总共有多少种不同的走法？

  • 递推式：f[n] = f[n-1] + f[n-2]；

  • 初始条件：f[1] = f[2] = 1。因为从1走到1只有一种方案（呆在原地不动），从1走到2也只有一种方案（走一格）；

  • 完整代码：

#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353; // 答案对998244353取模。
int k, f[1000010];

int main() {
    cin >> k;
    f[1] = f[2] = 1; // 初始条件
    for( int i = 3; i <= k; ++i )
        f[i] = (f[i-1] + f[i-2]) % MOD; // 递推式，记得取模
    cout << f[k] << endl;
    return 0;
}

• 卡特兰数问题：由nn对括号组成的括号序列，有多少种是合法的括号序列？

  • 递推式：f[n] = f[0] * f[k-1] + ... + f[k-1] * f[0]；

  • 初始条件：f[0] = 1，因为0对括号只能组成一种括号序列（空序列）；

  • 完整代码：

  • #include <bits/stdc++.h>
    using namespace std;
    const int MOD = 998244353;
    int n, f[100010];
    
    int main() {
        cin >> n;
        f[0] = 1; // 初始条件
        for( int i = 1; i <= n; ++i ) { // 求f[i]的值
            for( int k = 0; k < i; ++k ) {
                f[i] += int((long long)f[k] * f[i-k-1] % MOD); // 递推式
                // 注意，两个int相乘的结果可能爆int，因此乘法的过程要转换成long long以避免整数溢出
                f[i] %= MOD; // 记得取模
            }
        }
        cout << f[n] << endl;
        return 0;
    }

  • 时间复杂度：O(n^2)。

• 递推思想：

  根据已有的东西一点点地推出未知的东西。

• 使用递推解题三步骤：

  • 数学建模
  • 找出递推式和初始条件
  • 写出代码。

• 错位排列问题：有nn个信封和nn个信件，第ii个信件属于第ii个信封，我们想知道，有多少种不同的方法，使得没有任何一个信件被装入正确的信封中？

  • 递推式：f[n] = (n-1)(f[n-1] + f[n-2])；

  • 初始条件：f[1] = 0，因为只有1个信件和信封的时候，没有办法错位排列；f[2] = 1，只有2个信件和信封的时候，只有一种方法（交叉放）。

  • 完整代码：

• #include <bits/stdc++.h>
  using namespace std;
  const int MOD = 998244353;
  
  int f[1000010], n;
  
  int main() {
      cin >> n;
      f[1] = 0; // 初始条件
      f[2] = 1;
      for( int i = 3; i <= n; ++i ) {
          f[i] = (long long)(i-1) * (f[i-1] + f[i-2]) % MOD;
          // 注意取模，并且小心乘法会爆int
      }
      cout << f[n] << endl;
      return 0;
  }

• 杨辉三角（二维递推）问题：从nn个不同的物品中选取mm个，有多少种不同的选择方法？这是一个经典的组合数问题，而本题需要你解决一个更难的问题：给出k，你需要输出一个(k+1)*(k+1)(k+1)∗(k+1)的矩阵，其中第ii行第jj列表示，从ii个不同的物品中选jj个，有多少种不同的方法（行和列的标号从0开始）。

  • 递推式：f[i][j] = f[i-1][j-1] + f[i-1][j]；

  • 初始条件：f[i][0] = f[i][i] = 1; // 递推边界条件；

  • 完整代码：

#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;

int f[2010][2010] = {0}, k; // 初始化f数组为全0

int main() {
    cin >> k;
    for( int i = 0; i <= k; ++i ) {
        f[i][0] = f[i][i] = 1; // 递推边界条件
        for( int j = 1; j < i; ++j ) {
            f[i][j] = (f[i-1][j-1] + f[i-1][j]) % MOD; // 递推式，记得取模
        }
        for( int j = 0; j <= k; ++j ) {
            cout << f[i][j] << ' '; // 输出这一整行
        }
        cout << endl;
    }
    return 0;
}

• 时间复杂度：O(n^2)。

这就是递归

递归简介

递归，简单地来说，就是一个函数自己调用自己。

比如下面的代码，就是一个很简单的递归代码。

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

void f() {
    f(); // f函数调用自己
}

int main() {
    f();
    return 0;
}

• 递归是一个函数自己调用自己。

• 递归的本质是数学归纳法。

我们总是需要从数学归纳法的角度去思考递归，永远不要尝试展开递归过程。

• 斐波那契数列问题：输入正整数n，使用递归法求出斐波那契数列的第n项，答案对998244353取模。

  • 数学公式：

    • f(1) = f(2) = 1 // 初始值
    • f(n) = f(n-1) + f(n-2) // 递归公式

  • 完整代码：

#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;

int f( int n ) {
    if( n == 1 || n == 2 ) 
        return 1; // 边界条件
    else 
        return (f(n-1) + f(n-2)) % MOD; // 不要忘记取模
}

int main() {
    int n;
    cin >> n;
    cout << f(n) << endl;
    return 0;
}

• 求阶乘问题：输入非负整数n，使用递归法求出n的阶乘，答案对998244353取模。

  • 数学公式：

    • f(0) = 1 // 初始值
    • f(n) = f(n-1) * n // 递归公式

  • 完整代码：

• #include <bits/stdc++.h>
  using namespace std;
  const int MOD = 998244353;
  
  int f( int n ) {
      if( n == 0 ) 
          return 1;    // 0的阶乘等于1
      else return 
          (long long)f(n-1) * n % MOD; // 注意取模，小心爆int
  }
  
  int main() {
      int n;
      cin >> n;
      cout << f(n) << endl;
      return 0;
  }

• 理解递归的三板斧：

  1. 确认并牢记这个递归函数的功能，始终不能改。
  2. 仔细检查，写对边界条件。
  3. 递归调用自己时，放心大胆地用，假设这个函数就是对的。

• 写递归算法时，要牢记该函数只干一件事情，要写出所有边界条件，要放心大胆地递归调用自己。

• 递归算法的复杂度往往难以精确把握，只需要根据边界条件的执行次数和递归调用次数估算即可。