C++递推算法的具体使用

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    // 定义数组存储斐波那契数，假设n不超过45（保证在int范围内）
    int f[46];  // 第45项约为1.13e9，仍在int范围内
    
    // 初始化初始条件
    f[1] = 1;
    f[2] = 1;
    
    // 递推计算
    for (int i = 3; i <= n; i++) {
        f[i] = f[i-1] + f[i-2];
    }
    
    cout << f[n] << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    int a[46];  // 假设n不超过45
    a[1] = 1;
    a[2] = 2;
    
    for (int i = 3; i <= n; i++) {
        a[i] = a[i-1] + a[i-2];
    }
    
    cout << a[n] << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int m, n;
    cin >> m >> n;
    
    // 使用二维数组，假设m和n不超过20
    int b[21] = {0};
    
    // 初始化第一行和第一列
    b[1][1] = 1;
    
    // 递推计算
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == 1 && j == 1) continue; // (1,1)点是初始化条件不用递推
            b[i][j] = b[i-1][j] + b[i][j-1];
        }
    }
    
    cout << b[m][n] << endl;
    return 0;
}

#include <iostream>
using namespace std;

const int MOD = 100003; // 定义模数常量，避免魔法数字
int a[1001][1001] = {0}; // 显式初始化为0
bool b[1001][1001] = {false}; // 显式初始化为false

int main() {
    int n, m;
    cin >> n >> m;

    // 读入障碍物
    for (int i = 1; i <= m; i++) {
        int x, y;
        cin >> x >> y;
        b[x][y] = true;
    }

    // 初始化起点
    a[1][1] = 1;

    // 递推
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            // 跳过起点和障碍物
            if (i == 1 && j == 1) continue;
            if (b[i][j]) continue;
            a[i][j] = (a[i-1][j] + a[i][j-1]) % MOD;
        }
    }

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

#include<bits/stdc++.h>
using namespace std;
// 定义 long long 类型别名，用于存储可能的大数结果
#define ll long long

// 马的控制点方向数组：包括马本身及其8个走日位置，共9个方向
// dx和dy分别对应行和列的变化量，其中(0,0)表示马自身位置
int dx[] = {-2, -2, -1, -1, 0,  1,  1,  2, 2};
int dy[] = {-1,  1, -2,  2, 0, -2,  2, -1, 1};

// 标记数组：s[i][j]=true表示(i,j)是障碍点（马的控制点）
bool s[40];
// 动态规划数组：ans[i][j]表示从起点到达(i,j)的路径数
ll ans[40];

// 变量定义：bx,by为目标点坐标，mx,my为马的位置坐标
int bx, by, mx, my;

int main() {
	// 读入目标点坐标和马的位置坐标（原始坐标从(0,0)开始）
	cin >> bx >> by >> mx >> my;
	
	// 所有坐标加2：偏移操作，防止后续计算马的控制点时数组越界
	// 这样棋盘有效坐标从(2,2)开始，对应原坐标(0,0)
	bx+=2, by+=2, mx+=2, my+=2;
	
	// 标记马的控制点为障碍（包括马自身）
	// dx和dy数组长度为9，索引0~8
	for (int i = 0; i < 9; i++) {
		s[mx+dx[i]][my+dy[i]] = true;
	}
	
	// 递推初始化：起点(2,2)的路径数为1
	ans[2][2] = 1;
	
	// 递推：遍历从起点到目标点的所有位置
	for (int i = 2; i <= bx; i++) {
		for (int j = 2; j <= by; j++) {
			// 如果当前位置是障碍点或是起点，则跳过（起点已初始化）
			if (s[i][j] || i==2&&j==2) continue;
			
			// 状态转移方程：到达(i,j)的路径数等于从左边(i,j-1)和从上方(i-1,j)的路径数之和
			// 由于卒只能向右或向下移动，因此只需考虑这两个方向
			ans[i][j] = ans[i][j-1] + ans[i-1][j];
		}
	}
	
	// 输出结果：到达目标点(bx,by)的路径数
	cout << ans[bx][by];
	return 0;
}