luogu 1969 积木大赛

题目链接

题意

初始序列为全\(0\)，可以对序列进行的操作为将\([l,r]\)整体\(+1\)，问操作多少次后可以得到序列\(a\).

思路

显然，最优的策略即是先找到整个序列的最小值，整体加上这么多，于是序列分成了两块；找到左半边的最小值，左半边整体加上；找到右半边的最小值，右半边整体加上……然而这样的做法是\(O(n^2)\)的，怎么办呢？

法一：线段树

用线段树维护区间最小值，区间修改+区间查询。

复杂度\(O(nlogn)\).

Code

#include <bits/stdc++.h>
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define inf 0x3f3f3f3f
#define maxn 100010
using namespace std;
typedef long long LL;
struct node {
    int l, r, p, min, tag;
}tr[maxn * 4];
void push_up(int rt) {
    if (tr[lson].min < tr[rson].min) tr[rt].min = tr[lson].min, tr[rt].p = tr[lson].p;
    else tr[rt].min = tr[rson].min, tr[rt].p = tr[rson].p;
}
void build(int rt, int l, int r) {
    tr[rt].l = l, tr[rt].r = r, tr[rt].min = inf;
    if (l == r) {
        scanf("%d", &tr[rt].min);
        tr[rt].p = l;
        return;
    }
    int mid = l + r >> 1;
    build(lson, l, mid); build(rson, mid+1, r);
    push_up(rt);
}
void push_down(int rt) {
    if (tr[rt].tag) {
        tr[lson].min += tr[rt].tag, tr[rson].min += tr[rt].tag;
        tr[lson].tag += tr[rt].tag, tr[rson].tag += tr[rt].tag;
        tr[rt].tag = 0;
    }
}
void modify(int rt, int l, int r, int del) {
    if (tr[rt].l == l && tr[rt].r == r) {
        tr[rt].min += del;
        tr[rt].tag += del;
        return;
    }
    push_down(rt);
    int mid = tr[rt].l + tr[rt].r >> 1;
    if (r <= mid) modify(lson, l, r, del);
    else if (l > mid) modify(rson, l, r, del);
    else modify(lson, l, mid, del), modify(rson, mid+1, r, del);
    push_up(rt);
}
int query(int rt, int l, int r, int& p) {
    if (tr[rt].l == l && tr[rt].r == r) { p = tr[rt].p; return tr[rt].min; }
    push_down(rt);
    int mid = tr[rt].l + tr[rt].r >> 1;
    if (r <= mid) return query(lson, l, r, p);
    else if (l > mid) return query(rson, l, r, p);
    else {
        int p1, p2;
        int ql = query(lson, l, mid, p1), qr = query(rson, mid+1, r, p2);
        if (ql < qr) { p = p1; return ql; }
        else { p = p2; return qr; }
    }
}
int solve(int l, int r) {
    if (l > r) return 0;
    int p;
    int mn = query(1, l, r, p);
    if (l == r) return mn;
    else {
        if (p-1 >= l) modify(1, l, p-1, -mn);
        if (p+1 <= r) modify(1, p+1, r, -mn);
        return solve(l, p-1) + mn + solve(p+1, r);
    }
}
int main() {
    int n;
    scanf("%d", &n);
    build(1, 1, n);
    printf("%d\n", solve(1, n));
    return 0;
}

法二：换个视角

考虑第\(i\)块积木和第\(i+1\)块积木，如果第\(i+1\)块的积木低于或等于第\(i\)块积木的高度，那么在搭第\(i\)块积木的时候或者在这之前肯定就已经顺便搭好了第\(i+1\)块积木；而如果第\(i+1\)块的积木高于第\(i\)块积木的高度，那么第\(i+1\)块积木就必须要自己弥补上空缺的部分。

其实这个想法的具体操作完全等价于之前的思路，只不过是将每次找最小值的过程归到了从前往后的计算中，因此，在后一块积木的高度低于前一块积木的高度时无需再进行计算，因为已经在前面被计算过了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
    int n;
    scanf("%d", &n);
    int p = 0, ans = 0;
    for (int i = 0; i < n; ++i) {
        int x;
        scanf("%d", &x);
        if (x > p) ans += x - p;
        p = x;
    }
    printf("%d\n", ans);
    return 0;
}

法三：分治

将左半边与右半边合并时，如果\(h[mid]\geq h[mid+1]\)，则第\(mid+1\)块及之后被截断之前的若干块的\(h[mid+1]\)的部分都在搭第\(mid\)块时完成了；如果\(h[mid]\lt h[mid+1]\)，则第\(mid+1\)块及之后被截断之前的若干块的\(h[mid]\)的部分也都在搭第\(mid\)块时完成了。

故solve(l,r)=solve(l,mid)+solve(mid+1,r)-min(h[mid],h[mid+1]);

Code

#include <bits/stdc++.h>
#define maxn 100010
using namespace std;
typedef long long LL;
int a[maxn];
int solve(int l, int r) {
    if (l == r) return a[l];
    int mid = l+r >> 1;
    return solve(l, mid) + solve(mid+1, r) - min(a[mid], a[mid+1]);
}
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    printf("%d\n", solve(1, n));
    return 0;
}