P8518 [IOI2021] 分糖果 題解

下蛋爷發表於2024-08-16

Description

Khong 阿姨正在給附近一所學校的學生準備 \(n\) 盒糖果。盒子的編號分別為 \(0\) 到 \(n - 1\)，開始時盒子都為空。第 \(i\) 個盒子 \((0 \leq i \leq n - 1)\) 至多可以容納 \(c[i]\) 塊糖果（容量為 \(c[i]\)）。

Khong 阿姨花了 \(q\) 天時間準備糖果盒。在第 \(j\) 天 \((0 \leq j \leq q - 1)\)，她根據三個整數 \(l[j]\)、 \(r[j]\) 和 \(v[j]\) 執行操作，其中 \(0 \leq l[j] \leq r[j] \leq n - 1\) 且 \(v[j] \neq 0\)。對於每個編號滿足 \(l[j] \leq k \leq r[j]\) 的盒子 \(k\)：

  • 如果 \(v[j] > 0\)，Khong 阿姨將糖果一塊接一塊地放入第 \(k\) 個盒子，直到她正好放了 \(v[j]\) 塊糖果或者該盒子已滿。也就是說，如果該盒子在這次操作之前已有 \(p\) 塊糖果，那麼在這次操作之後盒子將有 \(\min(c[k], p + v[j])\) 塊糖果。

  • 如果 \(v[j] < 0\)，Khong 阿姨將糖果一塊接一塊地從第 \(k\) 個盒子取出，直到她正好從盒子中取出 \(-v[j]\) 塊糖果或者該盒子已空。也就是說，如果該盒子在這次操作之前已有 \(p\) 塊糖果，那麼在這次操作之後盒子將有 \(\max(0, p + v[j])\) 塊糖果。

你的任務是求出 \(q\) 天之後每個盒子中糖果的數量。

約束條件

  • \(1 \le n \le 200 000\)

  • \(1 \le q \le 200 000\)

  • \(1 \le c[i] \le 10 ^ 9\) （對所有 \(0 \le i \le n - 1\)）

  • \(0 \le l[j] \le r[j] \le n - 1\)（對所有 \(0 \le j \le q - 1\)）

  • \(−10 ^ 9 \le v[j] \le 10 ^ 9\) , \(v[j] ≠ 0\)（對所有 \(0 \le j \le q - 1\)）

Solution

不妨設 \(a_i\) 表示當前 \(i\) 的糖果數量，那麼每次操作就是讓 \(a_i\leftarrow\max\left(\min\left(a_i+v,c_i\right),0\right)\)，容易發現可以掃描線然後維護一個關於時間軸的線段樹。

如果取 min 和 max 中只有一種是很好做的，就是這題，但是兩個放在一起就不好做了。

容易發現只要找到最小的字尾 \([p,q]\) 使得這個字尾同時存在 min 和 max，那麼 \([p+1,q]\) 就只有一種 min 或者 max 了，所以確定 \(p\) 時刻的值就可以透過 \([p+1,q]\) 的操作得出答案。

考慮如何找到 \(p\)。

觀察可知如果 \([p,q]\) 字首和的極差 \(\geq c_i\) 就一定同時存在 max 和 min，並且如果極差 \(<c_i\) 就一定不會同時存在 max 和 min，所以只要線上段樹上二分即可。

時間複雜度：\(O\left((n+q)\log n\right)\)。

Code

#include "candies.h"

#include <bits/stdc++.h>

const int kMaxN = 2e5 + 5;

int n, q;
int c[kMaxN], l[kMaxN], r[kMaxN], v[kMaxN];
std::vector<std::pair<int, int>> vec[kMaxN];

struct SGT {
  int64_t mx[kMaxN * 4], mi[kMaxN * 4], posmx[kMaxN * 4], posmi[kMaxN * 4], tag[kMaxN * 4];

  void pushup(int x) {
    if (mx[x << 1] > mx[x << 1 | 1]) {
      mx[x] = mx[x << 1], posmx[x] = posmx[x << 1];
    } else {
      mx[x] = mx[x << 1 | 1], posmx[x] = posmx[x << 1];
    }
    if (mi[x << 1] < mi[x << 1 | 1]) {
      mi[x] = mi[x << 1], posmi[x] = posmi[x << 1];
    } else {
      mi[x] = mi[x << 1 | 1], posmi[x] = posmi[x << 1 | 1];
    }
  }

  void addtag(int x, int64_t v) { tag[x] += v, mx[x] += v, mi[x] += v; }

  void pushdown(int x) {
    if (tag[x]) {
      addtag(x << 1, tag[x]), addtag(x << 1 | 1, tag[x]);
      tag[x] = 0;
    }
  }

  void build(int x, int l, int r) {
    mx[x] = mi[x] = tag[x] = 0, posmx[x] = posmi[x] = r;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
  }

  void update(int x, int l, int r, int ql, int qr, int v) {
    if (l > qr || r < ql) return;
    else if (l >= ql && r <= qr) return addtag(x, v);
    pushdown(x);
    int mid = (l + r) >> 1;
    update(x << 1, l, mid, ql, qr, v), update(x << 1 | 1, mid + 1, r, ql, qr, v);
    pushup(x);
  }

  int getpos(int x, int l, int r, int64_t nowmx, int64_t nowmi, int64_t v) {
    if (std::max(nowmx, mx[x]) - std::min(nowmi, mi[x]) < v || l == r) return l;
    pushdown(x);
    int mid = (l + r) >> 1;
    if (std::max(nowmx, mx[x << 1 | 1]) - std::min(nowmi, mi[x << 1 | 1]) >= v)
      return getpos(x << 1 | 1, mid + 1, r, nowmx, nowmi, v);
    else 
      return getpos(x << 1, l, mid, std::max(nowmx, mx[x << 1 | 1]), std::min(nowmi, mi[x << 1 | 1]), v);
  }

  std::pair<int64_t, int> querymin(int x, int l, int r, int ql, int qr) {
    if (l > qr || r < ql) return {1e18, -1};
    else if (l >= ql && r <= qr) return {mi[x], posmi[x]};
    pushdown(x);
    int mid = (l + r) >> 1;
    return std::min(querymin(x << 1, l, mid, ql, qr), querymin(x << 1 | 1, mid + 1, r, ql, qr));
  }

  std::pair<int64_t, int> querymax(int x, int l, int r, int ql, int qr) {
    if (l > qr || r < ql) return {-1e18, -1};
    else if (l >= ql && r <= qr) return {mx[x], posmx[x]};
    pushdown(x);
    int mid = (l + r) >> 1;
    return std::max(querymax(x << 1, l, mid, ql, qr), querymax(x << 1 | 1, mid + 1, r, ql, qr));
  }
} sgt;

std::vector<int> solve() {
  std::vector<int> ans;
  for (int i = 1; i <= q; ++i) {
    vec[l[i]].emplace_back(i, v[i]), vec[r[i] + 1].emplace_back(i, -v[i]);
  }
  sgt.build(1, 0, q);
  for (int i = 1; i <= n; ++i) {
    for (auto [x, v] : vec[i]) sgt.update(1, 0, q, x, q, v);
    int p = sgt.getpos(1, 0, q, -1e18, 1e18, c[i]);
    int64_t sump = sgt.querymin(1, 0, q, p, p).first;
    if (p && sump == sgt.querymin(1, 0, q, p, q).first) { // 後面只會頂上界
      auto [mx, id] = sgt.querymax(1, 0, q, p, q);
      if (mx - sump <= c[i]) ans.emplace_back(sgt.querymax(1, 0, q, q, q).first - sump);
      else ans.emplace_back(c[i] - (mx - sgt.querymax(1, 0, q, q, q).first));
    } else if (p) {
      auto [mi, id] = sgt.querymin(1, 0, q, p, q);
      if (sump - mi <= c[i]) ans.emplace_back(c[i] - (sump - sgt.querymin(1, 0, q, q, q).first));
      else ans.emplace_back(sgt.querymin(1, 0, q, q, q).first - mi);
    } else if (sgt.querymin(1, 0, q, 0, q).first >= 0) {
      auto [mx, id] = sgt.querymax(1, 0, q, p, q);
      if (mx <= c[i]) ans.emplace_back(sgt.querymax(1, 0, q, q, q).first);
      else ans.emplace_back(c[i] - (mx - sgt.querymax(1, 0, q, q, q).first));
    } else {
      auto [mi, id] = sgt.querymin(1, 0, q, p, q);
      if (mi >= 0) ans.emplace_back(sgt.querymin(1, 0, q, q, q).first);
      else ans.emplace_back(sgt.querymin(1, 0, q, q, q).first - mi);
    }
  }
  return ans;
}

std::vector<int> distribute_candies(std::vector<int> c, std::vector<int> l,
                                    std::vector<int> r, std::vector<int> v) {
  n = c.size(), q = l.size();
  for (int i = 0; i < n; ++i) ::c[i + 1] = c[i];
  for (int i = 0; i < q; ++i)
    ::l[i + 1] = l[i] + 1, ::r[i + 1] = r[i] + 1, ::v[i + 1] = v[i];
  return solve();
}

相關文章