华为机考真题 -- 智能驾驶

题目描述：

有一辆汽车需要从 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
0,20,20,40
10,20,30,40

输出
-1

C++源码：

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
#include <string>
#include <sstream>
using namespace std;

int m, n;
vector<vector<int>> matrix;
const pair<int, int> offsets[] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };

class Node {
public:
    int x, y;
    int initial_energy;
    int remaining_energy;
    bool has_energy_booster;

    Node(int x, int y) : x(x), y(y), initial_energy(0), remaining_energy(0), has_energy_booster(false) {}
};

int bfs() {
    if (matrix[0][0] == 0 || matrix[m - 1][n - 1] == 0)
        return -1;

    queue<Node> q;

    Node src(0, 0);
    if (matrix[0][0] == -1) {
        src.initial_energy = 0;
        src.remaining_energy = 100;
        src.has_energy_booster = true;
    } else {
        src.initial_energy = matrix[0][0];
        src.remaining_energy = 0;
        src.has_energy_booster = false;
    }

    q.push(src);

    vector<vector<int>> distance_from_start(m, vector<int>(n, INT_MAX));
    vector<vector<int>> remaining_energy_at_destination(m, vector<int>(n, 0));

    distance_from_start[0][0] = src.initial_energy;
    remaining_energy_at_destination[0][0] = src.remaining_energy;

    while (!q.empty()) {
        Node cur = q.front(); q.pop();

        for (auto &offset : offsets) {
            int newX = cur.x + offset.first;
            int newY = cur.y + offset.second;

            if (newX < 0 || newX >= m || newY < 0 || newY >= n || matrix[newX][newY] == 0)
                continue;

            int initial_energy = cur.initial_energy;
            int remaining_energy = cur.remaining_energy;
            bool has_energy_booster = cur.has_energy_booster;

            if (matrix[newX][newY] == -1) {
                remaining_energy = 100;
                has_energy_booster = true;
            } else {
                remaining_energy -= matrix[newX][newY];
            }

            if (remaining_energy < 0) {
                if (has_energy_booster)
                    continue;
                else {
                    initial_energy -= remaining_energy;
                    remaining_energy = 0;
                }
            }

            if (initial_energy > 100)
                continue;

            if (initial_energy >= distance_from_start[newX][newY])
                continue;

            distance_from_start[newX][newY] = initial_energy;
            remaining_energy_at_destination[newX][newY] = remaining_energy;

            Node nxt(newX, newY);
            nxt.initial_energy = initial_energy;
            nxt.remaining_energy = remaining_energy;
            nxt.has_energy_booster = has_energy_booster;

            q.push(nxt);
        }
    }
    return distance_from_start[m - 1][n - 1] == INT_MAX ? -1 : distance_from_start[m - 1][n - 1];
}
// 用于读取一行输入并将其分割成整数向量
vector<int> getData() {
    string input;
    getline(cin, input);
    istringstream ss(input);
    vector<int> data;
    string temp;
    while (getline(ss, temp, ',')) // 通过逗号分隔读取数字
        data.push_back(stoi(temp)); // 将读取的字符串转换为整数
    return data;
}
int main() {

    vector<int> lineFirst = getData(); // 读取网格尺寸
    m = lineFirst[0]; // 行数
    n = lineFirst[1]; // 列数
    for (int i = 0; i < m; i++) {
        matrix.push_back(getData()); // 读取每行的网格信息
    }

    cout << bfs() << endl;
    system("pause");
    return 0;
}