P4088 [USACO18FEB] Slingshot P 题解

纪念一下打出的第一道铂金组题目，感谢HZX的讲评。

先来列个式子，第$i$个牛粪使用第$j$个弹弓（不考虑能否减少时间），需要的时间是多少？

显然是$|a_i-x_j|+|b_i-y_j|+t_j$。

式子中含有绝对值，这让人很棘手，这时候就需要用到一个经典的办法，分类讨论，把绝对值拆开。

这里只讨论一种情况，假设$a_i\le x_j$且$b_i\le y_j$，那么式子转化为$x_j-a_i+y_j-b_i+t_j$。

把与弹弓有关的值看做变量，其他的看做常量，式子化为$-(a_i+b_i)+(x_j+y_j+t_j)$。

这时候可以发现，我们只需要维护$x_j+y_j+t_j$的最小值即可得出答案，但如何维护？

首先需要保证的条件是$a_i\le x_j$，这个限制条件很好处理，只需要把牛粪和弹弓放在一起按第一关键字（$x_j$或$a_i$），第二关键字$b_i\le y_j$由小到大排序，倒序处理即可。

但是如果需要处理$y_j\le b_i$的情况呢？其实我们可以把它和上面一种情况放在一起处理，用树状数组以$y_j$或$b_i$为下标维护。

第一种情况在树状数组中可以直接正向维护，因为它是由小到大的（如果看不懂可以自己思考一下），那第二种情况呢？我们可以把第二种情况倒过来处理，这样就转化为由小到大了。

由于本人遣词造句能力过差，如果上面的内容看不懂可以结合代码理解一下。

写的比较快，所以不是很好，可能以后会改一下上面的题解吧。

#include 
using namespace std;
#define LL long long
const LL MAXN = 1e5 + 5;
LL n, m;
struct node1 {
    LL x, y, t;
} t1[MAXN];
struct node2 {
    LL a, b;
} t2[MAXN];
struct node3 {
    LL x, y;
    LL t;
    bool flg;
    LL number;
    bool operator<(const node3 &t) const { return x < t.x || (x == t.x && y < t.y); }
} t3[1000005];
LL cnt;
LL k[1000005], cntt;
map<LL, LL> num;
LL ans[MAXN];
LL tr1[1000005], tr2[1000005], kk;
LL lowbit(LL x) { return x & (-x); }
void update(LL x, LL val1, LL val2) {
    LL xx = kk - x + 1;
    while (x <= 1000000) {
        tr1[x] = min(tr1[x], val1);
        x += lowbit(x);
    }
    while (xx <= 1000000) {
        tr2[xx] = min(tr2[xx], val2);
        xx += lowbit(xx);
    }
}
LL getsum(LL x, LL flg) {
    LL res = LLONG_MAX;
    if (flg == 1) {
        while (x) {
            res = min(res, tr1[x]);
            x -= lowbit(x);
        }
    } else {
        LL xx = kk - x + 1;
        while (xx) {
            res = min(res, tr2[xx]);
            xx -= lowbit(xx);
        }
    }
    return res;
}
int main() {
    scanf("%lld%lld", &n, &m);
    for (LL i = 1; i <= n; i++) {
        scanf("%lld%lld%lld", &t1[i].x, &t1[i].y, &t1[i].t);
        t3[++cnt].x = t1[i].x;
        t3[cnt].y = t1[i].y;
        t3[cnt].t = t1[i].t;
        k[++cntt] = t1[i].y;
    }
    for (LL i = 1; i <= m; i++) {
        scanf("%lld%lld", &t2[i].a, &t2[i].b);
        t3[++cnt].x = t2[i].a;
        t3[cnt].y = t2[i].b;
        t3[cnt].flg = true;
        k[++cntt] = t2[i].b;
        t3[cnt].number = i;
    }
    sort(k + 1, k + cntt + 1);
    kk = unique(k + 1, k + cntt + 1) - k - 1;
    for (LL i = 1; i <= kk; i++) {
        num[k[i]] = i;
    }
    sort(t3 + 1, t3 + cnt + 1);
    memset(tr1, 0x3f, sizeof(tr1));
    memset(tr2, 0x3f, sizeof(tr2));
    for (LL i = 1; i <= m; i++) {
        ans[i] = abs(t2[i].a - t2[i].b);
    }
    for (LL i = 1; i <= cnt; i++) {
        if (!t3[i].flg) {
            update(num[t3[i].y], -t3[i].x - t3[i].y + t3[i].t, -t3[i].x + t3[i].y + t3[i].t);
        } else {
            LL s1 = getsum(num[t3[i].y], 1) + (t3[i].x + t3[i].y);
            LL s2 = getsum(num[t3[i].y], 2) + (t3[i].x - t3[i].y);
            ans[t3[i].number] = min(ans[t3[i].number], min(s1, s2));
        }
    }
    memset(tr1, 0x3f, sizeof(tr1));
    memset(tr2, 0x3f, sizeof(tr2));
    for (LL i = cnt; i >= 1; i--) {
        if (!t3[i].flg) {
            update(num[t3[i].y], t3[i].x - t3[i].y + t3[i].t, t3[i].x + t3[i].y + t3[i].t);
        } else {
            LL s1 = getsum(num[t3[i].y], 2) + (-t3[i].x - t3[i].y);
            LL s2 = getsum(num[t3[i].y], 1) + (-t3[i].x + t3[i].y);
            ans[t3[i].number] = min(ans[t3[i].number], min(s1, s2));
        }
    }
    for (LL i = 1; i <= m; i++) {
        printf("%lld\n", ans[i]);
    }
}