JAVA 洛谷经典dp——过河卒

这里写自定义目录标题

• • **f(i,j) = f(i-1,j) + f(i,j-1)**

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

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

现在要求你计算出卒从 AA 点能够到达 BB 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。
输入格式
一行四个正整数，分别表示 BB 点坐标和马的坐标。

输出格式
一个整数，表示所有的路径条数。

输入输出样例

输入	输出
6 6 3 3	6
–	–
5 5 2 2	0

先考虑如果没有任何马的限制，卒子可以随便向右向下走，那么可以想到，一个卒子只能从 当前格子的左侧格子 和 当前格子的上方格子 上走到当前格子。那么假设从 (0，0) 走到 当前格子的左侧格子 的路径条数是 ，从 (0，0)走到 当前格子的上方格子 的路径条数是 y，那么从 (0，0) 走到当前格子的路径条数就应该是 x+y。

其实我们已经得到了一个动态规划的转移方程，设 f(i,j)f(i,j) 表示从 (1,1)(1,1) 格子走到当前格子的路径条数，那么根据上一段得到的结论，可以得到：

f(i,j) = f(i-1,j) + f(i,j-1)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int b1 = sc.nextInt();
        int b2 = sc.nextInt();
        int m1 = sc.nextInt();
        int m2 = sc.nextInt();
        System.out.print(path(b1, b2, m1, m2));
        sc.close();
    }
    public static long path(int b1, int b2, int m1, int m2){
        // 马能走的八个方向
        int[][] dire = new int[][]{{-2,-1},{-1,-2},{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1}};
        // 棋盘
        long[][] chess = new long[25][25];
        // 给被被马挡住的点赋值为-1
        for (int i = 0; i < 8; i++){
            int newr = m1 + dire[i][0];
            int newc = m2 + dire[i][1];
            if (newr >= 0 && newr < chess.length && newc >= 0 && newc < chess[0].length){
                chess[newr][newc] = -1;
            }
        }
        // 别忘记马本身的位置也给附上-1奥
            chess[m1][m2] = -1;
		// 要先让马踩点，在给第一行，列赋值，因为如果第一行列有被马踩的点后面就不会经过
        // 既棋盘给第一行和列赋值为1,如果有-1，则-1后面不会经过，停止赋值
        for (int i = 0; i <= b1; i++){
            if (chess[i][0] == -1) break;
            else chess[i][0] = 1;
        }
        for (int j = 0; j <= b2; j++){
            if (chess[0][j] == -1) break;
            else chess[0][j] = 1;
        }
        // 如果起点或B点被马踩了 返回0
        if (chess[b1][b2] == -1 || chess[0][0] == -1) return 0;
        for (int i = 1; i <= b1; i++){
            for (int j = 1; j <= b2; j++){
            // 根据条件进行状态转移
                if (chess[i][j] == -1) continue;
                if (chess[i - 1][j] > 0)
                    chess[i][j] += chess[i - 1][j];
                if (chess[i][j - 1] > 0)
                    chess[i][j] += chess[i][j - 1];
            }
        }

        return chess[b1][b2];
    }
}

标签：JAVA,格子,int,条数,chess,sc,洛谷,dp,b1
来源： https://blog.csdn.net/baishixi22cc/article/details/123578906