P2672 [NOIP 2015 普及组] 推销员

原创于 2025-08-13 09:16:46 发布 · 318 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++ #数据结构 #算法 #python #机器学习

原题（或许？）：

link，点击这里喵。

题意：

阿明是一名推销员，他奉命到螺丝街推销他们公司的产品。螺丝街是一条死胡同，出口与入口是同一个，街道的一侧是围墙，另一侧是住户。螺丝街一共有 $N$ 家住户，第 $i$ 家住户到入口的距离为 $S_i$ 米。由于同一栋房子里可以有多家住户，所以可能有多家住户与入口的距离相等。阿明会从入口进入，依次向螺丝街的 $X$ 家住户推销产品，然后再原路走出去。

阿明每走 $1$ 米就会积累 $1$ 点疲劳值，向第 $i$ 家住户推销产品会积累 $A_i$ 点疲劳值。阿明是工作狂，他想知道，对于不同的 $X$ ，在不走多余的路的前提下，他最多可以积累多少点疲劳值。

解法：

显然我们可以贪心，进而可以发现我们要维护的东西实际上是未经过的 $2\times s - p_\texttt{now}$ 与经过了的 $a$ ，对于前者拆贡献，分别开两颗线段树即可。

代码 time ~

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

#define inf 0x3f3f3f3f
typedef long long lnt;

struct my_stream {
    int x;
    operator int() {
        scanf("%d", &x);
        return x;
    }
} __rp_read;
#define input() __rp_read

/*
可能会是性质的东西（雾）：
1. 我不知道, 但是好吃
2. 喜（悲）
*/

const int N = 2e5 + 10, M = N << 2;

int n;

struct DATA {
    lnt b, v;
} d[N]; // qmax

inline DATA operator*(const DATA &a, const DATA &b) { //
    return a.v < b.v ? b : a;
}

struct seg_tree {
#define cur _new[_cur]
#define lf _new[cur._lf]
#define rt _new[cur._rt]

    struct node {
        DATA v;
        int _lf, _rt;
    };
    static node _new[M];
    static int top;
    int root;

    void update(int &_cur, int ll, int rr, int b, DATA v) {
        if (_cur == 0) _cur = ++top;
        if (ll == rr && ll == b) {
            cur.v = v;
        } else {
            int mid = (ll + rr) >> 1;
            if (b <= mid) update(cur._lf, ll, mid, b, v);
            else update(cur._rt, mid + 1, rr, b, v);
            cur.v = lf.v * rt.v;
        }
    }

    DATA query(int &_cur, int ll, int rr, int l, int r) {
        if (_cur == 0) {
            return {0, -1};
        } else if (l <= ll && rr <= r) {
            return cur.v;
        } else {
            int mid = (ll + rr) >> 1;
            DATA ans = {0, -1};
            if (l <= mid) ans = ans * query(cur._lf, ll, mid, l, r);
            if (r > mid) ans = ans * query(cur._rt, mid + 1, rr, l, r);
            return ans;
        }
    }
} t1, t2;

seg_tree::node seg_tree::_new[M];
int seg_tree::top;

/*
t1 维护前缀 a
t2 维护后缀 a + 2 * s
*/

int main() { //
    n = input();
    for (int i = 1; i <= n; ++i) d[i].b = input();
    for (int i = 1; i <= n; ++i) d[i].v = input();
    for (int i = 1; i <= n; ++i) t1.update(t1.root, 1, n, i, {i, d[i].v});
    for (int i = n; i >= 1; --i) t2.update(t2.root, 1, n, i, {i, 2 * d[i].b + d[i].v});

    lnt p = 0; // 当前处理到的第几家了
    lnt ans = 0;
    for (int t = n; t >= 1; --t) {
        DATA v1 = {0, -1}, v2 = {0, -1};
        if (p >= 1) v1 = t1.query(t1.root, 1, n, 1, p);
        if (p <= n) v2 = t2.query(t2.root, 1, n, p, n); // 问题不大
        v2.v -= 2 * d[p].b;
        DATA v = v1 * v2;
        ans += v.v;
        p = max(p, v.b);
        t1.update(t1.root, 1, n, v.b, {0, -1});
        t2.update(t2.root, 1, n, v.b, {0, -1});
        printf("%lld\n", ans);
    }

    return 0;
}
/*
ABC
*/