P4088 [USACO18FEB] Slingshot P 题解

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

先来列个式子,第 i i i个牛粪使用第 j j j个弹弓(不考虑能否减少时间),需要的时间是多少?

显然是 ∣ a i − x j ∣ + ∣ b i − y j ∣ + t j |a_i-x_j|+|b_i-y_j|+t_j aixj+biyj+tj

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

这里只讨论一种情况,假设 a i ≤ x j a_i \leq x_j aixj b i ≤ y j b_i \leq y_j biyj,那么式子转化为 x j − a i + y j − b i + t j x_j-a_i+y_j-b_i+t_j xjai+yjbi+tj

把与弹弓有关的值看做变量,其他的看做常量,式子化为 − ( a i + b i ) + ( x j + y j + t j ) -(a_i+b_i)+(x_j+y_j+t_j) (ai+bi)+(xj+yj+tj)

这时候可以发现,我们只需要维护 x j + y j + t j x_j+y_j+t_j xj+yj+tj的最小值即可得出答案,但如何维护?

首先需要保证的条件是 a i ≤ x j a_i \leq x_j aixj,这个限制条件很好处理,只需要把牛粪和弹弓放在一起按第一关键字( x j x_j xj a i a_i ai),第二关键字 b i ≤ y j b_i \leq y_j biyj由小到大排序,倒序处理即可。

但是如果需要处理 y j ≤ b i y_j \leq b_i yjbi的情况呢?其实我们可以把它和上面一种情况放在一起处理,用树状数组以 y j y_j yj b i b_i bi为下标维护。

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

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

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

#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]);
    }
}

你可能感兴趣的:(算法,数据结构)