day24—编程题

1.第一题

1.1题目

描述：
小东所在公司要发年终奖，而小东恰好获得了最高福利，他要在公司年会上参与一个抽奖游戏，游戏在一个66的棋盘上进行，上面放着36个价值不等的礼物，每个小的棋盘上面放置着一个礼物，他需要从左上角开始游戏，每次只能向下或者向右移动一步，到达右下角停止，一路上的格子里的礼物小东都能拿到，请设计一个算法使小东拿到价值最高的礼物。
给定一个66的矩阵board，其中每个元素为对应格子的礼物价值,左上角为[0,0],请返回能获得的最大价值，保证每个礼物价值大于100小于1000。

1.2思路

1. 本题使用动态规划求解
2. 定义f(i,j)表示从左上角走到坐标(i，j)处能获得的最大奖励
3. 搜索所有从左上角走到右下角的路径，找到最优路径
4. f(i,j)分三种情况：第一列：f(i, 0) = f(i-1, 0) + board(i, 0)；第一行：f(0,j) = f(0, j - 1) + b(0, j)；其它位置：f(i, j) = max{f(i-1, j), f(i, j - 1)} + board(i, j)
5. 最后返回右下角的值

1.3解题

import java.util.*;
public class Bonus {
    public int getMost(int[][] board) {
        int row = board.length;//行
        int col = board[0].length;//列
        //处理第一列
        for(int i = 1;i < row;i++){
            board[i][0] += board[i-1][0];
        }
        //处理第一行
        for(int j = 1;j < col;j++){
            board[0][j] += board[0][j-1];
        }
        for(int i = 1;i < row;i++){
            for(int j = 1;j < col;j++){
                board[i][j] += Math.max(board[i-1][j],board[i][j-1]);
            }
        }
        return board[row-1][col-1];
    }
}

2.第二题

2.1题目

描述：
定义一个二维数组 N*M ，如 5 × 5 数组下所示：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。
输入描述：
输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道
输出描述：
左上角到右下角的最短路径，格式如样例所示
示例：
输入：
5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

2.2思路

1. 定义一个节点存放坐标
2. 判断当前坐标是否越界，有障碍，走过，如果是就返回
3. 不是的话就把当前坐标存入路径并标记当前位置已经走过了
4. 然后判断当前位置是否为出口，如果是并且最短路径为空或者最短路径大于当前路径就更新最短路径
5. 递归继续搜索(x,y)的上下左右四个方向
6. 一条路径找完，把当前位置从路径中删除，将标记位置改为未走过，寻找新的路径

2.3解题

import java.util.*;
//存放坐标
class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Main {
    //参数：迷宫，行，列，当前位置的行、列，标记当前位置是否已经走过，保存当前走过的路径，保存最短走过的路径
    public static void getMinPath(int[][] array, 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 || array[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()) {
                for (Node noed : path) {
                    minPath.add(noed);
                }
            }
        }
        //递归继续搜索(x,y)的上下左右四个方向
        getMinPath(array, row, col, x + 1, y, book, path, minPath);
        getMinPath(array, row, col, x - 1, y, book, path, minPath);
        getMinPath(array, row, col, x, y + 1, book, path, minPath);
        getMinPath(array, row, col, x, y - 1, book, path, minPath);
        //把当前位置从路径中删除，将标记位置改为未走过，寻找新的路径
        path.remove(path.size() - 1);
        book[x][y] = 0;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        int[][] array = new int[row][col];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = sc.nextInt();
            }
        }
        int[][] book = new int[row][col];
        ArrayList<Node> path = new ArrayList<>();
        ArrayList<Node> minPath = new ArrayList<>();
        getMinPath(array, row, col, 0, 0, book, path, minPath);
        for (Node node : minPath) {
            System.out.println("(" + node.x + "," + node.y + ")");
        }
    }
}