力扣周赛318 笔记

第一题

题目：

解法：先进行模拟，再将0置后，将0置后可以先把所有不是0的放在前面，也可以通过交换的方法原地实现（类似于冒泡不是0的就交换）。

第二题

题目：

解法：暴力求解是超时的，很明显的移动窗口题，本来没怎么做过移动窗口，考的时候嗯是悟出来了。窗口初始化后每次维护一下记录重复元素的hash表即可。

第三题

题目：

解法：根据提议，要维护两个最小值，可是我不太熟悉c++的priority queue，呜呜呜。

class Solution {
 public:
  // 时间复杂度O(nlogn)，空间复杂度O(n)
  long long totalCost(vector<int>& costs, int k, int candidates) {
    if (2 * candidates > costs.size()) return collision(costs, k);
    auto cmp = [&](int i, int j) {
      if (costs[i] == costs[j]) return i > j;
      return costs[i] > costs[j];//堆顶是队尾，所以是大于
    };
    priority_queue<int, vector<int>, decltype(cmp)> left(cmp), right(cmp);//priority_queue自定义比较函数格式
    int i = -1, j = costs.size();
    while (i < candidates - 1) left.emplace(++i), right.emplace(--j);
    long long cost = 0;
    while (i < j && k > 0) {
      int lmin = left.top(), rmin = right.top(),
          minIdx = (costs[lmin] <= costs[rmin]) ? lmin : rmin;
      if (minIdx <= i) left.pop(), left.emplace(++i);
      if (minIdx >= j) right.pop(), right.emplace(--j);
      cost += costs[minIdx];
      costs[minIdx] = INT_MAX;
      k--;
    }
    cost += collision(costs, k);
    return cost;
  }

 private:
  int collision(vector<int>& costs, int k) {
    if (k == 0) return 0;
    sort(costs.begin(), costs.end());
    return accumulate(costs.begin(), costs.begin() + k, 0);
  }
};

第四题

题目：

解法：做这道题首先要明白这道题是遵循贪心策略的，即不管对于某一个机器人去不去某个工厂，我们都应该按机器人和工厂的距离（位置）来进行排序，即假使在得到最小答案的情况下，按位置排序的1号机器人不会去按位置排序的1号工厂，那么二号机器人也是绝对不可能去1号工厂的（但是可能去1号去的工厂，或者排序在1号去的工厂之后的工厂），可以用邻项交换法证明。之后就可以用记忆化搜索了。

#define ll long long
class Solution {
public:
    ll dp[110][110];
    const ll inf = 1e16;
    long long minimumTotalDistance(vector<int>& robot, vector<vector<int>>& factory) {
        int m = robot.size();
        int n = factory.size();
        sort(robot.begin(), robot.end());
        sort(factory.begin(), factory.end());
        for(int i = 0; i < n; i ++ ) {
            for(int j = 0; j < m; j ++ ) {
                dp[i][j] = inf;
            }
        }
        function<ll (int,int)> f = [&](int i, int j) {
            //用[i, n - 1]的工厂修理[j, m - 1]的机器人
            if(j == m) return (ll)0; //修完了
            if(i == n) return inf; //没修完
            if(dp[i][j] != inf) return dp[i][j];
            ll res = f(i + 1, j); //一个不修
            ll sum = 0;//该工厂修多少
            for(int k = 1; k <= factory[i][1] && j + k - 1 < m; k ++ ) {
                sum += abs(robot[j + k - 1] - factory[i][0]);
                res = min(res, sum + f(i + 1, j + k));
            } 
            dp[i][j] = min(dp[i][j], res);
            return res;
        };
        return f(0, 0);
    }
};

以上题解只是对灵神题解的总结，非原创捏¹

---

1. 灵神b站题解 ↩︎