过河卒

[NOIP2002 普及组] 过河卒

题目描述

棋盘上 $A$ 点有一个过河卒，需要走到目标 $B$ 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 $C$ 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示，$A$ 点 $(0,0)$、$B$ 点 $(n,m)$，同样马的位置坐标是需要给出的。

现在要求你计算出卒从 $A$ 点能够到达 $B$ 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式

一行四个正整数，分别表示 $B$ 点坐标和马的坐标。

输出格式

一个整数，表示所有的路径条数。

样例 #1

样例输入 #1

6 6 3 3

样例输出 #1

6

提示

对于 $100\%$ 的数据，$1\le n,m\le 20$，$0\le$ 马的坐标 $\le 20$。

【题目来源】

NOIP 2002 普及组第四题
这是一个典型的动态规划问题，可以通过动态规划来解决。下面是解决这个问题的思路：

1. 定义一个二维数组 dp，其中 dp[i][j] 表示从起点 $(0,0)$ 到达坐标 $(i,j)$ 的路径数量。
2. 初始化数组 dp，将起点 $(0,0)$ 设为 1，因为只有一种方式可以到达起点。
3. 从左上角到右下角依次遍历棋盘，对于每一个位置 $(i,j)$：
   • 如果 $(i,j)$ 是马的位置或者受马的控制，则 dp[i][j] 设为 0，因为卒无法经过该点。
   • 否则，dp[i][j] = dp[i-1][j] + dp[i][j-1]，即可由上方或左方的点到达当前点的路径数量之和。
4. 最终 dp[n][m] 即为结果，表示从起点到目标点的路径数量。

下面是相应的 C++ 代码：

#include <iostream>
#include <vector>
using namespace std;

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

    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
    dp[0][0] = 1;

    // 设置马的控制点
    if (horse_x >= 2 && horse_y >= 1)
        dp[horse_x - 2][horse_y - 1] = 1;
    if (horse_x >= 1 && horse_y >= 2)
        dp[horse_x - 1][horse_y - 2] = 1;
    if (horse_x <= n - 2 && horse_y >= 1)
        dp[horse_x + 2][horse_y - 1] = 1;
    if (horse_x <= n - 1 && horse_y >= 2)
        dp[horse_x + 1][horse_y - 2] = 1;

    // 计算路径数量
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= m; ++j) {
            if ((i == horse_x && j == horse_y) ||
                (i - 1 >= 0 && j - 2 >= 0 && dp[i - 1][j - 2] == 1) ||
                (i - 2 >= 0 && j - 1 >= 0 && dp[i - 2][j - 1] == 1)) {
                dp[i][j] = 0; // 马的位置或受马的控制，路径数量设为 0
            } else {
                if (i - 1 >= 0)
                    dp[i][j] += dp[i - 1][j];
                if (j - 1 >= 0)
                    dp[i][j] += dp[i][j - 1];
            }
        }
    }

    cout << dp[n][m] << endl;

    return 0;
}

这段代码首先读取输入的目标点坐标和马的坐标，然后使用动态规划计算从起点到目标点的路径数量，并输出结果。