20190822美团机试

岗位Android开发

题目一 迷宫寻路

时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB

题目描述：
给定一个包含非负整数的 M x N 迷宫，请找出一条从左上角到右下角的路径，使得路径上的数字总和最小。每次只能向下或者向右移动一步。

输入
第一行包含两个整数M和N，以空格隔开，1≤N≤10，1≤N≤10。
接下来的M行中，每行包含 N个数字 。

输出
找出总和最小的路径，输出路径上的数字总和。

样例输入
        3 3
        1 3 1
        1 5 1
        4 2 1
样例输出
        7

题目分析
俺是直接用递归暴力求解了，反正只有下和右两种选择，然后定义好一个全局的count，一直用来记录最小的路径总和

//AC，应该是A了，记不住了 -_-!!
import java.util.Scanner;

public class Main {
    static int count = 10000000;
    static int M;
    static int N;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        M = in.nextInt();
        N = in.nextInt();
        int road[][] = new int[M][N];
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                road[i][j] = in.nextInt();
            }
        }
        M--;
        N--;
        dfs(road, 0, 0, 0);
        System.out.println(count);
    }

    public static void dfs(int road[][], int i, int j, int allnum) {
        allnum += road[i][j];
        if (M == i && N == j) {
            if (allnum < count)
                count = allnum;
        } else if (M == i && j < N) {
            dfs(road, i, j + 1, allnum);
        } else if (N == j && i < M) {
            dfs(road, i + 1, j, allnum);
        } else if (j < N && i < M) {
            dfs(road, i, j + 1, allnum);
            dfs(road, i + 1, j, allnum);
        }
    }
}

题目二 星际穿越

时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB

题目描述：

小团在一次星际旅行中，耗尽了飞船的能量，迷失在了空间魔方中，空间魔方中有NNN个能量粒子。美团云AI迅速帮小团分析出了空间魔方的能量分布图。

已知小团的飞船被困在能量值最高的点，能量值最高点有且只有一个。飞船每到达一个能量粒子就会吸收对应粒子的能量，该粒子会坍缩成小黑洞，飞船不可到达。小团驾驶的飞船只能从高能粒子驶向低能粒子，且每次只能从6个方向中选择一个前进。（±x,±y,±z）。
请帮助帮小团吸收最高的能量值。

输入
N（0≤N≤8）

NNN行空间能量数据，格式为：X Y Z P，XYZ表示点坐标，P表示空间能量分布（0≤P）

输出
可吸收到的最高的能量值

样例输入1
        2
        0 0 0 7
        0 0 1 2
        0 1 0 4
        0 1 1 3
        1 0 0 6
        1 0 1 1
        1 1 0 5
        1 1 1 0
样例输出
        28

    
输入样例2
        3
        0 0 0 1
        0 0 1 2
        0 0 2 3
        0 1 0 4
        0 1 1 5
        0 1 2 6
        0 2 0 7
        0 2 1 8
        0 2 2 9
        1 0 0 10
        1 0 1 11
        1 0 2 12
        1 1 0 13
        1 1 1 14
        1 1 2 13
        1 2 0 12
        1 2 1 11
        1 2 2 10
        2 0 0 9
        2 0 1 8
        2 0 2 7
        2 1 0 6
        2 1 1 5
        2 1 2 4
        2 2 0 3
        2 2 1 2
        2 2 2 1
输出样例2
        89

题目分析
也想用暴力来着，因为有边界，就各加了一行，这一加给我整蒙了，写不明白了，网上事后也没咋找到这个题，蒙了蒙了，记录一下，代码没有过，贴一下：

import java.util.Scanner;

public class Main2 {
    static int count = 0;
    static int N;


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        N = in.nextInt();
        int power[][][] = new int[N+2][N+2][N+2];
        //Arrays.fill(power,-1);
        for (int i = 0; i < (int)Math.pow(2,N); i++) {
            power[i][0][0] = -1;
            power[0][i][0] = -1;
            power[0][0][i] = -1;
            power[i][N-1][N-1] = -1;
            power[N-1][i][N-1] = -1;
            power[N-1][N-1][i] = -1;
            int x = in.nextInt() +1;
            int y = in.nextInt() +1;
            int z = in.nextInt() +1;
            power[x][y][z] = in.nextInt();
        }

        dfs(power, 0, 0,0, 0);
        System.out.println(count);
    }

    public static void dfs(int road[][][], int i, int j,int k, int allnum) {
        allnum += road[i][j][k];
        road[i][j][k] = -1;
        if (road[i+1][j][k] == -1 &&road[i-1][j][k] == -1 &&road[i][j+1][k] == -1 &&road[i][j-1][k] == -1 &&road[i][j][k+1] == -1 ) {
            if (allnum > count)
                count = allnum;
        } else if (road[i-1][j][k] != -1) {
            dfs(road, i-1, j ,k, allnum);
        } else if (road[i+1][j][k] != -1) {
            dfs(road, i+1, j ,k, allnum);
        } else if (road[i][j+1][k] != -1) {
            dfs(road, i, j +1 ,k, allnum);
        } else if (road[i][j-1][k] != -1) {
            dfs(road, i, j-1 ,k, allnum);
        }else if (road[i][j][k+1] != -1) {
            dfs(road, i, j ,k+1, allnum);
        } else if (road[i][j][k-1] != -1) {
            dfs(road, i, j ,k-1, allnum);
        }

    }
}