【2024华为OD-E卷-100分-靠谱的车】（题目+思路+Java&C++&Python解析)

题目描述

靠谱的车

给定一个二维数组 cars，其中每个元素 cars[i] 表示一辆车的参数，格式为 [speed, distance]。

现在你要从这些车中选出一些车，使得这些车的平均速度最大，但有一个条件：任意两辆选中的车的速度不能相同。

注意：

• 平均速度定义为所有选中车的速度之和除以选中车的数量。
• 如果有多组车的组合可以得到相同的最大平均速度，则返回任意一组即可。

输入：

• 一个二维数组 cars，其中每个元素 cars[i] 是一个长度为 2 的数组，表示 [speed, distance]。

输出：

• 一个整数数组，包含选中的车的索引（0-based），使得这些车的平均速度最大，并且任意两辆车的速度不相同。

示例：

输入：[[4, 5], [5, 7], [6, 10], [2, 3]]
输出：[1, 2]  // 选择索引 1 和 2 的车，速度分别为 5 和 6，平均速度为 (5 + 6) / 2 = 5.5

思路分析

1. 预处理：将车的参数与索引关联起来，便于后续根据速度筛选车。
2. 排序：根据速度对车进行排序，排序的目的是为了快速找到速度不同的车。
3. 动态规划：使用动态规划来记录不同速度组合下的最大距离和对应车的索引集合。
4. 回溯：通过回溯找到达到最大平均速度的具体车的索引集合。

具体步骤如下：

1. 将车的速度、距离和索引存储在一个对象中或结构体中，方便后续操作。
2. 根据速度对车进行排序。
3. 使用一个 dp 数组记录以当前车为结尾的不同速度组合的最大距离。
4. 使用一个哈希表记录每个最大距离对应的车的索引集合。
5. 通过遍历 dp 数组找到最大距离，然后回溯找到对应的车的索引集合。

Java 编码解析

import java.util.*;

class Car {
    int speed;
    int distance;
    int index;

    public Car(int speed, int distance, int index) {
        this.speed = speed;
        this.distance = distance;
        this.index = index;
    }
}

public class Main {
    public static List<Integer> getMaxAverageSpeedCars(int[][] cars) {
        List<Car> carList = new ArrayList<>();
        for (int i = 0; i < cars.length; i++) {
            carList.add(new Car(cars[i][0], cars[i][1], i));
        }
        
        // Sort cars by speed
        Collections.sort(carList, Comparator.comparingInt(car -> car.speed));
        
        int n = carList.size();
        long[] dp = new long[n];
        Set<Integer>[] dpIndices = new HashSet[n];
        for (int i = 0; i < n; i++) {
            dp[i] = carList.get(i).distance;
            dpIndices[i] = new HashSet<>();
            dpIndices[i].add(carList.get(i).index);
            
            for (int j = 0; j < i; j++) {
                if (carList.get(i).speed != carList.get(j).speed && dp[j] + carList.get(i).distance > dp[i]) {
                    dp[i] = dp[j] + carList.get(i).distance;
                    dpIndices[i] = new HashSet<>(dpIndices[j]);
                    dpIndices[i].add(carList.get(i).index);
                }
            }
        }
        
        int maxIndex = -1;
        long maxDistance = 0;
        for (int i = 0; i < n; i++) {
            if (dp[i] > maxDistance) {
                maxDistance = dp[i];
                maxIndex = i;
            }
        }
        
        return new ArrayList<>(dpIndices[maxIndex]);
    }

    public static void main(String[] args) {
        int[][] cars = {{4, 5}, {5, 7}, {6, 10}, {2, 3}};
        List<Integer> result = getMaxAverageSpeedCars(cars);
        System.out.println(result);  // Output: [1, 2] or any valid combination
    }
}

C++ 编码解析

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>

using namespace std;

struct Car {
    int speed;
    int distance;
    int index;
};

bool compareCars(const Car &a, const Car &b) {
    return a.speed < b.speed;
}

vector<int> getMaxAverageSpeedCars(vector<vector<int>>& cars) {
    vector<Car> carList;
    for (int i = 0; i < cars.size(); i++) {
        carList.push_back({cars[i][0], cars[i][1], i});
    }
    
    sort(carList.begin(), carList.end(), compareCars);
    
    int n = carList.size();
    vector<long long> dp(n, 0);
    vector<set<int>> dpIndices(n);
    for (int i = 0; i < n; i++) {
        dp[i] = carList[i].distance;
        dpIndices[i].insert(carList[i].index);
        
        for (int j = 0; j < i; j++) {
            if (carList[i].speed != carList[j].speed && dp[j] + carList[i].distance > dp[i]) {
                dp[i] = dp[j] + carList[i].distance;
                dpIndices[i] = dpIndices[j];
                dpIndices[i].insert(carList[i].index);
            }
        }
    }
    
    int maxIndex = -1;
    long long maxDistance = 0;
    for (int i = 0; i < n; i++) {
        if (dp[i] > maxDistance) {
            maxDistance = dp[i];
            maxIndex = i;
        }
    }
    
    return vector<int>(dpIndices[maxIndex].begin(), dpIndices[maxIndex].end());
}

int main() {
    vector<vector<int>> cars = {{4, 5}, {5, 7}, {6, 10}, {2, 3}};
    vector<int> result = getMaxAverageSpeedCars(cars);
    for (int index : result) {
        cout << index << " ";
    }
    return 0;
}

Python 编码解析

class Car:
    def __init__(self, speed, distance, index):
        self.speed = speed
        self.distance = distance
        self.index = index

def get_max_average_speed_cars(cars):
    car_list = [Car(speed, distance, index) for index, (speed, distance) in enumerate(cars)]
    
    # Sort cars by speed
    car_list.sort(key=lambda car: car.speed)
    
    n = len(car_list)
    dp = [0] * n
    dp_indices = [set() for _ in range(n)]
    for i in range(n):
        dp[i] = car_list[i].distance
        dp_indices[i].add(car_list[i].index)
        
        for j in range(i):
            if car_list[i].speed != car_list[j].speed and dp[j] + car_list[i].distance > dp[i]:
                dp[i] = dp[j] + car_list[i].distance
                dp_indices[i] = dp_indices[j].copy()
                dp_indices[i].add(car_list[i].index)
    
    max_index = dp.index(max(dp))
    
    return list(dp_indices[max_index])

# Example usage
cars = [[4, 5], [5, 7], [6, 10], [2, 3]]
result = get_max_average_speed_cars(cars)
print(result)  # Output: [1, 2] or any valid combination