AI刷题-绿洲之旅：最少补给次数探索-优快云博客

  struct Station {
  int pos;
  int sup;
};
  int current_position = 0;
  int current_water = w;
  int supply_count = 0;

  vector<Station> stations;
for (int i = 0; i < position.size(); ++i) {
    stations.push_back({position[i], supply[i]});
  }

2. 计算与下一补给点的距离：

可以到达的话则对两个变量进行更新，反之则无法到达，返回-1；

int distance_to_next = stations[i].pos - current_position;
    // 如果当前水量不足以到达下一个补给站，返回 -1
    if (current_water < distance_to_next) {
      return -1;
    }
    current_position = stations[i].pos;
    current_water -= distance_to_next;

3.选择最优补给点：

核心在于贪心，只要有能到达并且补给量最大的补给站，那就进行补给。所以我们只需要简单做个遍历即可。

// 选择最优的补给站进行补给
    int max_supply = 0;
    int max_index = -1;
    for (int j = i; j < stations.size() &&
                    stations[j].pos <= current_position + current_water;
         j++) {
      if (stations[j].sup > max_supply) {
        max_supply = stations[j].sup;
        max_index = j;
      }
    }

if (max_index != -1) {
      current_water += max_supply;
      supply_count++;

      i = max_index;
    }

4. 两个返回的地方：

（1）每次循环完都需要判断当前的水是否足够到达终点，不能则继续下一次遍历

（2）当补给点遍历完后判断是否能够到达终点，不能则返回-1

if (current_water >= d - current_position) {
    return supply_count;
  } else {
    return -1;
  }

最终代码：

#include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;

// 将补给站信息合并到一个结构体中，并按位置排序
struct Station {
  int pos;
  int sup;
};

int solution(int d, int w, std::vector<int> position, std::vector<int> supply) {
  // Please write your code here
  if (w >= d) {
    return 0;
  }
  int current_position = 0;
  int current_water = w;
  int supply_count = 0;

  vector<Station> stations;
  for (int i = 0; i < position.size(); ++i) {
    stations.push_back({position[i], supply[i]});
  }
  sort(stations.begin(), stations.end(),
       [](const Station &a, const Station &b) { return a.pos < b.pos; });
  for (int i = 0; i < stations.size(); i++) {
    int distance_to_next = stations[i].pos - current_position;
    // 如果当前水量不足以到达下一个补给站，返回 -1
    if (current_water < distance_to_next) {
      return -1;
    }
    current_position = stations[i].pos;
    current_water -= distance_to_next;

    // 选择最优的补给站进行补给
    int max_supply = 0;
    int max_index = -1;
    for (int j = i; j < stations.size() &&
                    stations[j].pos <= current_position + current_water;
         j++) {
      if (stations[j].sup > max_supply) {
        max_supply = stations[j].sup;
        max_index = j;
      }
    }
    if (max_index != -1) {
      current_water += max_supply;
      supply_count++;

      i = max_index;
    }
    if (current_water >= d - current_position) {
      return supply_count;
    }
  }
  if (current_water >= d - current_position) {
    return supply_count;
  } else {
    return -1;
  }
}

int main() {
  //  You can add more test cases here
  std::vector<int> testPosition = {170,  192,  196,  234,  261,  269,  291,
                                   404,  1055, 1121, 1150, 1234, 1268, 1402,
                                   1725, 1726, 1727, 1762, 1901, 1970};
  std::vector<int> testSupply = {443, 185, 363, 392, 409, 358, 297,
                                 70,  189, 106, 380, 130, 126, 411,
                                 63,  186, 36,  347, 339, 50};

  std::cout << (solution(10, 4, std::vector<int>{1, 4, 7},
                         std::vector<int>{6, 3, 5}))
            << std::endl;
  std::cout << (solution(7, 23, std::vector<int>{5}, std::vector<int>{22}))
            << std::endl;
  std::cout << (solution(2000, 200, testPosition, testSupply)) << std::endl;

  return 0;
}