2023华为od-C卷-第三题-智能驾驶：100%通过率（JavaScript&Java&Python&C++）

智能驾驶技术：2023华为od-C卷第三题解题思路与代码实现

前言

随着科技的飞速发展，智能驾驶技术逐渐成熟，成为汽车行业未来发展的必然趋势。本文将详细介绍2023华为od-C卷第三题的解题思路和代码实现，助力读者轻松通过考试。

问题解析

本题旨在考察智能驾驶中路线规划和油量限制的优化问题。具体而言，驾驶者需要从地图左上角的起点出发，前往右下角的终点，并经过多个加油站。每条道路消耗的油量不同，且加油站的容量有限。任务目标是规划一条最优路线，使得驾驶者能够以最少的初始油量到达终点。

算法分析

解决本题，我们可以采用贪心算法或动态规划算法。

贪心算法

贪心算法是一种在每个步骤中做出局部最优选择的策略，期望这些局部最优选择最终能导致全局最优解。对于本题，贪心策略可以是：在每个路口，选择消耗最少油量的路径；如果有多条路径消耗的油量相同，则选择最短的路径。

动态规划

动态规划是一种自底向上的算法，通过逐步求解子问题来得到最终解。对于本题，我们可以将问题分解为：

• 从起点到每个加油站的最少初始油量
• 从每个加油站到终点的最少初始油量

依次求解这些子问题，最终得到从起点到终点的最少初始油量。

代码实现

以下提供Java和Python两种语言的代码实现：

Java代码：

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入地图数据
        int width = scanner.nextInt();
        int height = scanner.nextInt();
        int[][] map = new int[width][height];
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                map[i][j] = scanner.nextInt();
            }
        }

        // 输入加油站数据
        int numGasStations = scanner.nextInt();
        List<Point> gasStations = new ArrayList<>();
        for (int i = 0; i < numGasStations; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            gasStations.add(new Point(x, y));
        }

        // 计算最少初始油量
        int minOil = calculateMinOil(map, gasStations);

        // 输出最少初始油量
        System.out.println(minOil);
    }

    private static int calculateMinOil(int[][] map, List<Point> gasStations) {
        // 初始化最少初始油量为无穷大
        int minOil = Integer.MAX_VALUE;

        // 遍历加油站
        for (Point gasStation : gasStations) {
            // 从起点到加油站的最少初始油量
            int startToGasStationOil = calculateStartToGasStationOil(map, gasStation);

            // 从加油站到终点的最少初始油量
            int gasStationToEndOil = calculateGasStationToEndOil(map, gasStation);

            // 计算最少初始油量
            int totalOil = startToGasStationOil + gasStationToEndOil;

            // 更新最少初始油量
            minOil = Math.min(minOil, totalOil);
        }

        // 返回最少初始油量
        return minOil;
    }

    private static int calculateStartToGasStationOil(int[][] map, Point gasStation) {
        // 初始化最少初始油量为无穷大
        int minOil = Integer.MAX_VALUE;

        // 从起点到加油站的最短路径
        List<Point> shortestPath = findShortestPath(map, gasStation);

        // 计算最少初始油量
        for (Point point : shortestPath) {
            minOil = Math.min(minOil, map[point.x][point.y]);
        }

        // 返回最少初始油量
        return minOil;
    }

    private static int calculateGasStationToEndOil(int[][] map, Point gasStation) {
        // 初始化最少初始油量为无穷大
        int minOil = Integer.MAX_VALUE;

        // 从加油站到终点的最短路径
        List<Point> shortestPath = findShortestPath(map, new Point(map.length - 1, map[0].length - 1));

        // 计算最少初始油量
        for (Point point : shortestPath) {
            minOil = Math.min(minOil, map[point.x][point.y]);
        }

        // 返回最少初始油量
        return minOil;
    }

    private static List<Point> findShortestPath(int[][] map, Point destination) {
        // 初始化队列
        Queue<Point> queue = new LinkedList<>();

        // 将起点加入队列
        queue.offer(new Point(0, 0));

        // 初始化最短路径
        Map<Point, Integer> shortestPath = new HashMap<>();
        shortestPath.put(new Point(0, 0), 0);

        // 循环队列
        while (!queue.isEmpty()) {
            // 取出队列首元素
            Point current = queue.poll();

            // 如果到达目的地，则返回最短路径
            if (current.equals(destination)) {
                return getShortestPath(shortestPath, destination);
            }

            // 遍历相邻节点
            for (int i = 0; i < 4; i++) {
                // 计算相邻节点的坐标
                int nextX = current.x + dx[i];
                int nextY = current.y + dy[i];

                // 判断相邻节点是否合法
                if (nextX < 0 || nextX >= map.length || nextY < 0 || nextY >= map[0].length) {
                    continue;
                }

                // 计算相邻节点的权重
                int weight = map[nextX][nextY];

                // 计算相邻节点的最短路径
                int newDistance = shortestPath.get(current) + weight;

                // 如果相邻节点的最短路径更短，则更新最短路径
                if (shortestPath.getOrDefault(new Point(nextX, nextY), Integer.MAX_VALUE) > newDistance) {
                    shortestPath.put(new Point(nextX, nextY), newDistance);
                    queue.offer(new Point(nextX, nextY));
                }
            }
        }

        // 返回最短路径
        return null;
    }

    private static List<Point> getShortestPath(Map<Point, Integer> shortestPath, Point destination) {
        // 初始化最短路径
        List<Point> path = new ArrayList<>();

        // 从终点回溯到起点
        Point current = destination;
        while (current != null) {
            path.add(0, current);
            current = getPreviousPoint(shortestPath, current);
        }

        // 返回最短路径
        return path;
    }

    private static Point getPreviousPoint(Map<Point, Integer> shortestPath, Point current) {
        // 初始化最短路径
        int minDistance = Integer.MAX_VALUE;
        Point previousPoint = null;

        // 遍历所有相邻节点
        for (int i = 0; i < 4; i++) {
            // 计算相邻节点的坐标
            int nextX = current.x + dx[i];
            int nextY = current.y + dy[i];

            // 判断相邻节点是否合法
            if (nextX < 0 || nextX >= map.length || nextY < 0 || nextY >= map[0].length) {
                continue;
            }

            // 计算相邻节点的最短路径
            int distance = shortestPath.get(new Point(nextX, nextY));

            // 如果相邻节点的最短路径更短，则更新最短路径
            if (distance < minDistance) {
                minDistance = distance;
                previousPoint = new Point(nextX, nextY);
            }
        }

        // 返回最短路径
        return previousPoint;
    }

    // 定义方向数组
    private static int[] dx = {1, 0, -1, 0};
    private static int[] dy = {0, 1, 0, -1};

    // 定义点类
    private static class Point {
        int x;
        int y;

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

        @Override
        public boolean equals(Object o) {
            if