蓝桥杯算法训练-过河马

蓝桥杯算法训练题解有兴趣的可以支持下。

题目

问题描述

在那个过河卒逃过了马的控制以超级超级多的走法走到了终点之后，这匹马表示它不开心了……
　　于是，终于有一天，它也过河了！
　　由于过河马积累了许多的怨念，所以这次它过了河之后，再也没有什么东西可以限制它，它可以自由自在的在棋盘上驰骋。一开始，它是在一个n行m列棋盘的左下角（1,1）的位置，它想要走到终点右上角（n，m）的位置。而众所周知，马是要走日子格的。可是这匹马在积累了这么多怨念之后，它再也不想走回头路——也就是说，它只会朝向上的方向跳，不会朝向下的方向跳。
　　那么，这匹马它也想知道，它想从起点跳到终点，一共有多少种走法呢？

题解

经典的摘樱桃问题，最简单的计数dp。

代码

• 记忆化搜索的java代码

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author: Zekun Fu
 * @date: 2022/10/18 14:30
 * @Description: 过河马
 */
public class Main {

    private static int n, m;
    private static long[][] f;
    private static int[][]dirs =  {{1, 2}, {2, 1}, {1, -2}, {2, -1}};
    private static long mod = (int)1e9 + 7;
    private static boolean check(int a, int b) {
        if (a < 0 || a >= n || b < 0 || b >= m)
            return false;
        return true;
    }
    private static long dfs(int a, int b) {
        if (a == n - 1 && b == m - 1) return 1;
        if (a > n || b > m) return 0;
        long ans = f[a][b];
        if (ans != -1) return ans;
        ans = 0;
        for (int i = 0; i < 4; i++) {
            int na = a + dirs[i][0];
            int nb = b + dirs[i][1];
            if (check(na, nb))
                ans = (dfs(na, nb) + ans) % mod;
        }
        f[a][b] = ans;
        return ans;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        f = new long[n][m];
        for (int i = 0; i < n; i++)
            Arrays.fill(f[i], -1);
        System.out.println(dfs(0, 0));
    }
}

• c++递推代码

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

const int maxn = 106, mod = 1e9 +7;
int dp[maxn][maxn];
int n, m;
int dirs[4][2] = {{1, 2}, {1, -2}, {2, 1}, {2, -1}};

int main() {
    scanf("%d%d", &n, &m);
    dp[1][1] = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for (int k = 0; k < 4; k++) {
                int ni = i + dirs[k][0];
                int nj = j + dirs[k][1];
                if (ni >= 0 && ni <= n && nj >= 0 && nj <= m) {
                    dp[ni][nj] = ((LL)dp[ni][nj] + dp[i][j]) % mod;
                }
            }
        }
    }
    printf("%d\n", dp[n][m]);
}