华为OD机试真题---查找充电设备

华为OD机试真题中有一道关于“查找充电设备”的题目，具体描述可能略有不同，但核心内容是相似的。以下是对这道题目及其解答思路的详细归纳：

一、题目描述

某个充电站，可提供n个充电设备，每个充电设备均有对应的输出功率。任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素。功率集合P的最优元素，表示最接近充电站最大输出功率p_max的元素。

输入：

1. 第一行为充电设备个数n。
2. 第二行为每个充电设备的输出功率。
3. 第三行为充电站最大输出功率p_max。

输出：功率集合P的最优元素。

二、示例

1. 输入：

4
50 20 20 60
90

输出：90（当充电设备输出功率为50,20,20组合时，其充电功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90）。

2. 输入：

2
50 40
30

输出：0（所有充电设备的输出功率组合，均大于充电站最大充电功率30，此时最优元素为0）。

三、解题思路

1. 问题建模：

   • 首先，我们需要将问题抽象化，定义出问题的输入和输出。在这个问题中，输入是充电设备的数量n、每个设备的输出功率数组outputs以及充电站的最大输出功率pMax。输出则是功率集合P中的最优元素，即最接近pMax的功率值。

2. 动态规划数组的初始化：

   • 我们使用一个二维数组dp来存储中间结果。dp[i][j]表示前i个充电设备中，总功率不超过j的最大输出功率。初始化时，我们将所有元素设置为0，表示尚未计算。

3. 状态转移方程：

   • 对于第一个充电设备，如果其输出功率小于等于j，则dp[0][j]等于该设备的输出功率，否则为0。这是因为只有一个设备时，如果它的功率小于等于j，则可以选择它，否则不能。
   • 对于后续的充电设备（从第二个设备开始），我们有两种选择：选择当前设备或不选择当前设备。如果选择当前设备，并且总功率不超过j，则当前状态dp[i][j]的值为dp[i-1][j-outputs[i]] + outputs[i]（即加上当前设备的输出功率后的总功率）。如果不选择当前设备，则dp[i][j]的值等于前一个状态dp[i-1][j]的值。因此，状态转移方程为：dp[i][j] = max(dp[i-1][j], dp[i-1][j-outputs[i]] + outputs[i])。

4. 寻找最优解：

   • 在填充完dp数组后，我们遍历dp[n-1]行（即最后一行），这一行包含了前n个充电设备中所有可能的总功率值（不超过pMax）。我们计算每个值与pMax的差的绝对值，并找到差最小的值，这个值就是我们要找的最优功率组合。

四、代码实现

public class ChargingStation {

    /**
     * 寻找最优功率组合的函数
     * 该函数旨在从一组设备输出功率中找到一个组合，使其总功率最接近但不超过最大功率限制pMax
     * 
     * @param n 设备的数量
     * @param outputs 设备的输出功率数组
     * @param pMax 最大功率限制
     * @return 返回最接近但不超过pMax的最优功率组合
     */
    public static int findOptimalPowerCombination(int n, int[] outputs, int pMax) {
        // 创建一个二维数组dp，用于存储中间结果
        int[][] dp = new int[n][pMax + 1];
    
        // 初始化第一行
        for (int j = outputs[0]; j <= pMax; j++) {
            dp[0][j] = outputs[0];
        }
    
        // 填充dp数组的其他行
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= pMax; j++) {
                // 如果不选择当前设备
                dp[i][j] = dp[i - 1][j];
    
                // 如果选择当前设备，并且总功率不超过j
                if (j >= outputs[i]) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - outputs[i]] + outputs[i]);
                }
            }
        }
    
        // 在最后一行中找到最接近pMax的值
        // 初始化最优功率为0
        int optimalPower = 0;
        // 初始化最小差值为最大整数，用于后续寻找最小差值
        int closestDiff = Integer.MAX_VALUE;
        
        // 遍历所有可能的功率值，从0到最大功率pMax
        for (int j = 0; j <= pMax; j++) {
            // 计算当前功率值与最大功率的差值
            int diff = Math.abs(dp[n - 1][j] - pMax);
            // 如果当前差值小于已知的最小差值，则更新最小差值和最优功率
            if (diff < closestDiff) {
                closestDiff = diff;
                optimalPower = dp[n - 1][j];
            }
        }
    
        return optimalPower;
    }

    /**
     * 主函数执行最优功率组合查找任务
     */
    public static void main(String[] args) {
        // 定义设备数量
        int n = 4;
        // 定义每个设备的输出功率
        int[] outputs = {50, 20, 20, 60};
        // 定义最大功率限制
        int pMax = 90;

        // 调用方法计算最优功率组合
        int result = findOptimalPowerCombination(n, outputs, pMax);
        // 输出最优功率组合结果
        System.out.println("最优功率组合为: " + result);  // 输出90
    }
}

五、运行示例解析

当然，我们可以详细解析一下之前给出的Java代码的运行示例。以下是逐步解析：

示例输入

int n = 4;
int[] outputs = {50, 20, 20, 60};
int pMax = 90;

在这个示例中，我们有4个充电设备，它们的输出功率分别是50、20、20和60。充电站的最大输出功率是90。

动态规划数组初始化

我们创建了一个二维数组dp，它的大小是n x (pMax + 1)，即4行91列（因为pMax是从0到90，共91个值）。数组dp用于存储中间结果，其中dp[i][j]表示前i个充电设备中，总功率不超过j的最大输出功率。

填充动态规划数组

1. 第一行初始化：

   • 对于j = 50到90，dp[0][j]被设置为50，因为只有一个充电设备（输出功率为50）时，这些值是可以达到的。
   • 对于j < 50，dp[0][j]保持为0，因为即使只有一个充电设备，也无法达到这些值。

2. 后续行填充：

   • 对于每个i（从1到3），我们遍历所有的j（从0到90）。
   • 如果不选择当前设备（即第i个设备），则dp[i][j]等于dp[i-1][j]。
   • 如果选择当前设备，并且总功率不超过j，则dp[i][j]可能是dp[i-1][j-outputs[i]] + outputs[i]（即加上当前设备的输出功率）和dp[i-1][j]中的较大值。

查找最优解

在填充完dp数组后，我们遍历dp[n-1]（即最后一行），找到最接近pMax的值。这是通过计算每个值与pMax的差的绝对值，并找到差最小的值来实现的。

示例解析结果

在我们的示例中，dp数组在填充完毕后可能如下所示（只展示部分值以节省空间）：

dp[0]: [0, 0, ..., 0, 50, 50, ..., 50]  // 只有第50列及之后是非零的
dp[1]: [0, 0, ..., 50, 70, 70, ..., 70]  // 加上第二个设备（20）后，70及之后是非零的
dp[2]: [0, 0, ..., 50, 70, 90, 90, ..., 90]  // 加上第三个设备（20）后，可以达到90
dp[3]: [0, 0, ..., 50, 70, 90, 110, ..., 110]  // 加上第四个设备（60）后，最大可以达到110

注意：上面的dp数组展示是简化的，并没有完全展开所有列。在实际代码中，dp数组会有91列。

最后，我们在dp[3]（即最后一行）中找到最接近90的值，发现dp[3][90]是90，因此最优功率组合为90。

输出结果

System.out.println("最优功率组合为: " + result);  // 输出90

这就是我们的Java代码如何运行并找到最优功率组合的详细解析。

六、代码实现的详细解读

代码部分已经给出了详细的注释和解释，但在这里我们再进行一些深入的解读。

• 初始化部分：

  int[][] dp = new int[n][pMax + 1];
  

  这里创建了一个二维数组dp，大小为n x (pMax + 1)，用于存储中间结果。数组的行数等于充电设备的数量，列数等于充电站最大输出功率加1（因为要从0开始计数）。

• 第一行初始化：

  for (int j = outputs[0]; j <= pMax; j++) {
      dp[0][j] = outputs[0];
  }
  

  这里只初始化了第一行，因为只有一个设备时，如果它的功率小于等于j，则可以选择它，否则不能。所以只有当j大于等于第一个设备的功率时，dp[0][j]才等于该设备的功率。

• 后续行填充：

  for (int i = 1; i < n; i++) {
      for (int j = 0; j <= pMax; j++) {
          dp[i][j] = dp[i - 1][j]; // 不选择当前设备
          if (j >= outputs[i]) {
              dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - outputs[i]] + outputs[i]); // 选择当前设备
          }
      }
  }
  

  这里使用了两个嵌套的循环来填充dp数组的其他行。对于每个i（从1到n-1），我们遍历所有的j（从0到pMax），并根据状态转移方程更新dp[i][j]的值。

• 查找最优解：

  int optimalPower = 0;
  int closestDiff = Integer.MAX_VALUE;
  for (int j = 0; j <= pMax; j++) {
      int diff = Math.abs(dp[n - 1][j] - pMax);
      if (diff < closestDiff) {
          closestDiff = diff;
          optimalPower = dp[n - 1][j];
      }
  }
  

  在填充完dp数组后，我们遍历dp[n-1]行（即最后一行），找到最接近pMax的值。这是通过计算每个值与pMax的差的绝对值，并找到差最小的值来实现的。最终，optimalPower变量存储了最优功率组合的值。

七、总结

通过动态规划的方法，我们可以有效地解决这个组合优化问题。动态规划的关键在于定义出问题的状态和状态转移方程，并通过填充动态规划数组来逐步求解问题。在这个问题中，我们定义了dp[i][j]表示前i个充电设备中总功率不超过j的最大输出功率，并通过状态转移方程逐步填充了dp数组。最后，我们在dp数组的最后一行中找到了最接近pMax的值，即为所求的最优功率组合。