智能驾驶 - 华为OD统一考试(C卷)（java）

题目描述

有一辆汽车需要从 m * n 的地图的左上角（起点）开往地图的右下角（终点 ），去往每一个地区都需要消耗一定的油量，加油站可进行加油

请你计算汽车确保从起点到达终点时所需的最少初始油量

说明：

（1）智能汽车可以上下左右四个方向移动;

（2）地图上的数字取值是 0 或 −1 或者正整数;

−1：表示加油站，可以加满油，汽车的油箱容量最大为 100；

0 ：表示这个地区是障碍物，汽车不能通过;

正整数：表示汽车走过这个地区的耗油量

（3）如果汽车无论如何都无法到达终点，则返回 −1

输入描述

第一行为两个数字，M , N，表示地图的大小为 M * N ( 0 < M,N ≤ 200 )

后面一个M * N 的矩阵，其中的值是 0 或 −1 或正整数，加油站的总数不超过 200个

输出描述

如果汽车无论如何都无法到达终点，则返回-1

如果汽车可以到达终点，则返回最少的初始油量

示例1

输入：
2,2
10,20
30,40

输出：
70

说明：
行走的路线为：右 -> 下

示例2

输入：
4,4
10,30,30,20
30,30,-1,10
0,20,20,40
10,-1,30,40

输出：
70

说明：
因为题目是说的是初始油量最少，所以行走路线可能不唯。
我的行走路线是:右 -> 右 -> 下 -> 下 -> 左 -> 下->右->右
原题行走的路线为：右 -> 右 -> 下 -> 下 -> 下 -> 右

示例3

输入：
4,5
10,0,30,-1,10
30,0,20,0,20
10,0,10,0,30
10,-1,30,0,10

输出：
60

说明：
行走的路线为：下 -> 下 -> 下 -> 右 -> 右 -> 上 -> 上 -> 上 -> 右 -> 右 -> 下 -> 下 -> 下

示例4

输入：
4,4
10,30,30,20
30,30,20,10
10,20,10,40
10,20,30,40

输出：
-1

说明：
无论如何都无法到达终点

 注：我的这种方法是比较片面的，在考虑有两个加油站的时候，并没有选择省油的路径，而是，经过了两个加油站。所以比较片面，在有加油站的情况下，只考虑了终点到加油站的最短距离，加油站到加油站的最短距离或加油站到终点的最短距离，只能说勉强符合题目。

java代码

package odTest;

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

public class IntellectionDriven {
	static int[] inputSize;
	static int[][] hasPass;
	static int[][] grossRounte;
	static int[] sortLsit = new int[4];
	static Stack<Integer> stack = new Stack<>();
	static boolean flag = false;
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		inputSize = Arrays.stream(scanner.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
        
		hasPass = new int[inputSize[0]][inputSize[1]];
		grossRounte = new int[inputSize[0]][inputSize[1]];
		
		for(int i=0;i<inputSize[0];i++) {
			int[] inputLine = Arrays.stream(scanner.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
			for(int j=0;j<inputSize[1];j++) {
				grossRounte[i][j] = inputLine[j];
			}
		}
		for(int i = 0;i<inputSize[0];i++) {
			for(int j = 0;j<inputSize[1];j++) {
				hasPass[i][j] = -2;
			}
		}
		
		int currentOil = 100;
		
		int grossOil = JudgeOptimRoute(currentOil,0,0);
		if(grossOil>100||flag) {
			System.out.println(-1);
		}else {
		    System.out.println(grossOil);
		}
		
	}

	private static int JudgeOptimRoute(int currentOil, int indexX, int indexY) {
		if(indexX==inputSize[0]||indexX<0) {
			return 900;
		}
		if(indexY==inputSize[1]||indexY<0) {
			return 900;
		}
		if(hasPass[indexX][indexY] !=-2) {
			return 900;
		}
		if(grossRounte[indexX][indexY] == 0) {
			return 900;
		}
		if(inputSize[0]==indexX+1&&inputSize[1]==indexY+1) {
			return grossRounte[indexX][indexY];
		}
		hasPass[indexX][indexY] = 1;
		//上
		int res1 = JudgeOptimRoute(currentOil,indexX-1,indexY);
		stack.push(res1);
		//左
		int res2 = JudgeOptimRoute(currentOil,indexX,indexY-1);
		stack.push(res2);
		//右
		int res3 = JudgeOptimRoute(currentOil,indexX,indexY+1);
		stack.push(res3);
		//下
		int res4 = JudgeOptimRoute(currentOil,indexX+1,indexY);
		stack.push(res4);
		
		for(int i=0;i<4;i++) {
			sortLsit[i] = stack.pop();
		}
		Arrays.sort(sortLsit);
		if(sortLsit[0]==900&&inputSize[0]==indexX&&inputSize[1]==indexY) {
			hasPass[indexX][indexY] = -2;
			return grossRounte[indexX][indexY];
		}else if(sortLsit[0]==900){
			hasPass[indexX][indexY] = -2;
			return 900;
		}else if(grossRounte[indexX][indexY]==-1){
			flag = sortLsit[0]>100?true:flag;
			hasPass[indexX][indexY] = -2;
			return 0;
		}else{
			hasPass[indexX][indexY] = -2;
			return grossRounte[indexX][indexY]+sortLsit[0];
		}
		
	}

}