【算法】车队

难度：中等

题目：

在一条单行道上，有 n 辆车开往同一目的地。目的地是几英里以外的 target 。

给定两个整数数组 position 和 speed ，长度都是 n ，其中 position[i] 是第 i 辆车的位置， speed[i] 是第 i 辆车的速度(单位是英里/小时)。

一辆车永远不会超过前面的另一辆车，但它可以追上去，并以较慢车的速度在另一辆车旁边行驶。

车队 是指并排行驶的一辆或几辆汽车。车队的速度是车队中 最慢 的车的速度。

即便一辆车在 target 才赶上了一个车队，它们仍然会被视作是同一个车队。

返回到达目的地的车队数量 。

示例 1：

**输入：**target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]

**输出：**3

解释：

• 从 10（速度为 2）和 8（速度为 4）开始的车会组成一个车队，它们在 12 相遇。车队在 target 形成。
• 从 0（速度为 1）开始的车不会追上其它任何车，所以它自己是一个车队。
• 从 5（速度为 1） 和 3（速度为 3）开始的车组成一个车队，在 6 相遇。车队以速度 1 移动直到它到达 target。

示例 2：

**输入：**target = 10, position = [3], speed = [3]

**输出：**1

解释：

只有一辆车，因此只有一个车队。

示例 3：

**输入：**target = 100, position = [0,2,4], speed = [4,2,1]

**输出：**1

解释：

• 从 0（速度为 4） 和 2（速度为 2）开始的车组成一个车队，在 4 相遇。从 4 开始的车（速度为 1）移动到了 5。
• 然后，在 4（速度为 2）的车队和在 5（速度为 1）的车成为一个车队，在 6 相遇。车队以速度 1 移动直到它到达 target。

提示：

• n == position.length == speed.length
• 1 <= n <= 105
• 0 < target <= 106
• 0 <= position[i] < target
• position 中每个值都 不同
• 0 < speed[i] <= 106

解题思路一：

1. 首先，我们需要将汽车按照它们的初始位置从后往前排序，这样可以确保我们总是先处理最接近目标的汽车。
2. 对于每辆汽车，我们计算出它单独到达目标所需的时间。
3. 使用单调递减栈来存储每个车队到达目标的时间。当我们遇到一辆新汽车时，我们将其到达时间与栈顶的车队时间比较。

• 如果新汽车的到达时间小于等于栈顶车队的到达时间，这意味着它能够加入当前的车队。
• 否则，它将形成一个新的车队，因为它的到达时间比任何已有的车队都要晚。

1. 我们在栈中维护的车队数量即为最终的答案。

   /**

   • @param {number} target

   • @param {number[]} position

   • @param {number[]} speed

   • @return {number} */ var carFleet = function(target, position, speed) { // 将汽车按位置从后往前排序 const cars = position.map((p, i) => [p, speed[i]]); cars.sort((a, b) => b[0] - a[0]);

     const fleets = []; for (const [pos, spd] of cars) { // 计算汽车到达目标的时间 const time = (target - pos) / spd; // 如果栈为空或者当前汽车的到达时间大于栈顶车队的到达时间，则形成新的车队 if (!fleets.length || time > fleets[fleets.length - 1]) { fleets.push(time); } }

     return fleets.length; };

解题思路二：

我们可以采用一种动态规划的思想，但实际上，这个问题可以通过对车辆按照位置逆序排序，然后计算每辆车到达目的地所需的时间来解决。由于一辆车永远不会超过前面的另一辆车，所以我们可以从后往前检查每辆车，看它是否可以加入前方的车队。

具体步骤如下：

1. 首先，我们需要将车辆按照位置从后往前排序，因为后面的车辆有可能追上前面的车辆。

2. 我们需要计算每辆车到达目的地的时间，这可以通过(target - position[i]) / speed[i]来计算。

3. 对于每一辆车，我们检查它是否可以加入前面车队。如果当前车辆到达目的地的时间大于等于前面一辆车的时间，那么它将加入到前面的车队中。否则，它将形成一个新的车队。

   /**

   • @param {number} target

   • @param {number[]} position

   • @param {number[]} speed

   • @return {number} */ var carFleet = function(target, position, speed) { // 结合位置和速度，方便一起排序 const cars = position.map((pos, i) => [pos, speed[i]]);

     // 按照位置逆序排序 cars.sort((a, b) => b[0] - a[0]);

     let fleets = 0; let prevTime = 0;

     for (const [pos, spd] of cars) { const time = (target - pos) / spd;

      // 如果当前车辆到达时间晚于或等于前一辆车，那么它会加入前一辆车的车队
      // 否则，形成新的车队
      if (time > prevTime) {
          fleets++;
          prevTime = time;
      }
     

     }

     return fleets; };