【Java笔试强训】day24编程题

编程题

年终奖

@SuppressWarnings({"all"})
public class Bonus {
    // 问题：小东可以获取的最大价值
    // 子问题：小东走到某个格子时的最大价值
    // 状态F(i,j)：小东走到(i,j)格子时的最大价值
    // 转移方程：F(i,j) =max{F(i-1,j), F(i,j-1)} + board[i][j]}
    // 第一行：F(0,j) : F(0,j-1)
    // 第一列：F(i,0) : F(i-1,0)
    public int getMost(int[][] board) {
        // write code here
        int row = board.length;
        int col = board[0].length;

        // 处理第一行
        for (int i = 1; i < col; i++) {
            board[0][i] += board[0][i - 1];
        }
        // 处理第一列
        for (int i = 1; i < row; i++) {
            board[i][0] += board[i - 1][0];
        }
        // 处理剩余位置
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                // F(i,j) = max{F(i-1,j),F(i,j-1)} + board[i][j]
                board[i][j] += Math.max(board[i - 1][j], board[i][j - 1]);
            }
        }
        return board[row - 1][col - 1];
    }
}

迷宫问题

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

@SuppressWarnings({"all"})
class Node {
    int x, y;

    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

@SuppressWarnings({"all"})
public class Main {

    /**
     * @param mat     迷宫矩阵 row,col
     * @param x,y     当前位置
     * @param book    标记矩阵，标记当前位置是否走过
     * @param path    保存当前路径的每一个位置
     * @param minPath 保存最短路径
     */
    private static void getMinPath(int[][] mat, int row, int col,
                                   int x, int y, int[][] book, ArrayList<Node> path,
                                   ArrayList<Node> minPath) {
        // 判断(x,y)：是否越界，是否走过，是否有障碍
        if (x < 0 || x >= row || y < 0 || y >= col
                || book[x][y] == 1 || mat[x][y] == 1) {
            return;
        }
        // 把当前位置存入路径中
        path.add(new Node(x, y));
        // 标记当前位置
        book[x][y] = 1;
        // 判断当前位置是否为出口
        if (x == row - 1 && y == col - 1) {
            // 一条新的路径产生
            // 判断是否为更短的路径
            if (minPath.isEmpty() || path.size() < minPath.size()) {
                // 更新更短路径
                minPath.clear();
                for (Node n : path) {
                    minPath.add(n);
                }
            }
        }

        // 继续搜索(x,y)的上下左右四个方向
        getMinPath(mat, row, col, x + 1, y, book, path, minPath);
        getMinPath(mat, row, col, x - 1, y, book, path, minPath);
        getMinPath(mat, row, col, x, y - 1, book, path, minPath);
        getMinPath(mat, row, col, x, y + 1, book, path, minPath);

        // 把当前位置从路径中删除，寻找新的路径
        path.remove(path.size() - 1);
        book[x][y] = 0;


    }

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while ((str = reader.readLine()) != null) {
            String[] arr = str.split(" ");
            int row = Integer.parseInt(arr[0]);
            int col = Integer.parseInt(arr[1]);
            // 创建迷宫矩阵
            int[][] mat = new int[row][col];
            // 读入迷宫数据
            for (int i = 0; i < row; i++) {
                str = reader.readLine();
                arr = str.split(" ");
                for (int j = 0; j < col; j++) {
                    mat[i][j] = Integer.parseInt(arr[j]);
                }
            }
            // 搜索最短路径
            ArrayList<Node> path = new ArrayList<>();
            ArrayList<Node> minPath = new ArrayList<>();
            int[][] book = new int[row][col];
            getMinPath(mat, row, col, 0, 0, book, path, minPath);

            // 打印最短路径
            for (Node n : minPath) {
                System.out.println("(" + n.x + "," + n.y + ")");
            }
        }
    }
}