ABC371F Takahashi in Narrow Road 题解 模拟+线段树

题目链接：https://atcoder.jp/contests/abc371/tasks/abc371_f

题目大意：

有一条向东和向西延伸的道路，\(N\) 个人在这条道路上。道路从一个称为原点的点向东和向西无限延伸。

第 \(i\) 个人 \((1\leq i\leq N)\) 最初位于原点东侧距离原点 \(X_i\) 米处。

这些人可以沿着道路向东或向西移动。具体来说，他们可以执行以下移动任意次数。

选择一个人。如果目的地没有其他人，则将选择的人向东或向西移动 \(1\) 米。

注：这里说的目的地指的是，如果这个人要向东移动 \(1\) 米，则目的地就是东边 \(1\) 米的地方；如果这个人要向西移动 \(1\) 米，则目的地就是西边 \(1\) 米的地方。

他们总共有 \(Q\) 个任务，第 \(i\) 个任务 \((1 \leq i \leq Q)\) 描述如下：

第 \(T_i\) 个人到达坐标 \(G_i\)。

找出依次完成所有 \(Q\) 个任务所需的最小总移动次数。

解题思路：

首先本题中我们定义的 “连通块” 指的是一段挨着的人（即这一段错了最左边那个人以外，每个人的坐标都比它左边那个人大 \(1\)）。

以下图为例：

• 第一阶段：每个人都属于同一个连通块；
• 第二阶段：第 \(1\) 个人单独一个连通块，第 \(2\) 个人单独一个连通块，第 \(3 \sim 5\) 个人属于同一个连通块；
• 第三阶段：第 \(1 \sim 4\) 个人属于同一个连通块，第 \(5\) 个人单独一个连通块；
• 第四阶段：仍然是第 \(1 \sim 4\) 个人属于同一个连通块，第 \(5\) 个人单独一个连通块；
• 第五阶段：第 \(1\) 个人单独一个连通块，第 \(2 \sim 5\) 个人属于同一个连通块。

在整体的 \(Q\) 次移动中，每次移动：

• 最多有 \(n\) 个连通块合并成一个连通块；
• 最多有 \(1\) 个连通块被拆分为两个连通块。

考虑 暴力去合并与拆分连通块？\(\Rightarrow\) 其实是可行的。

因为每次操作最多（通过拆分）增加一个连通块，初始时最多 \(n\) 个连通块，而最终合并能够得到的最终的连通块的个数最少是一个。所以，我们实际上合并连通块的次数不超过 \(n+q-1\) 次。虽然一次合并操作就可能合并 \(n-1\) 次连通块（看上去很吓人），但是实际整个过程中，合并和拆分连通块的次数是 \(O(n+q)\)，均摊下来次数还是比较少的。

而且在代码实现时，我们可能是同时将一段区间的多个连通块合并成一个连通块，这样实际的合并次数就更少了。

在实现时，我们用线段树维护了一个信息，那就是每个人所在的连通块中最左边那个人的编号。在线段树中支持的操作有两个：

• bl(p)：（单点查询）查询第 \(p\) 个人所在的连通块中最左边那个人的编号；
• merge_people(l, r)：（区间更新）将区间 \([l, r]\) 合并成一个连通块。

同时我们实时更新每个区间最左边那个人（第 \(p\) 个人）的位置 \(x[p]\)。\(\Rightarrow\) 这很关键，因为以 \(p\) 为最左边的人的连通块中其他人的位置都是由 \(p\) 决定的。

如果 \(q\) 和 \(p\) 属于同一个连通块，\(x[p]\) 是第 \(p\) 个人此时实际所在的位置，则 \(q\) 所在的位置应为 \(x[p] + q - p\)（因为同一个连通块里的人是挨着的）。具体实现时，我开了一个 get_pos(p) 函数获取第 \(p\) 个人的位置。

题目里面是第 \(T_i\) 个人移动到坐标 \(G_i\)。我在分析移动的时候将其表示为第 \(p\) 个人移动到坐标 \(G\)。

所限我们一个通过 get_pos(p) 函数获得第 \(p\) 个人当前（即移动前）所在的坐标 \(P\)。

• 如果 \(P = G\)（起点等于中点），不需要移动；
• 如果 \(P \lt G\)，需要向右移动；
• 如果 \(R \gt G\)，需要向左移动。

所以接下来我们分 向右移动 和 向左移动两种情况进行分析。

向右移动

如果 \(p\) 向右移动，\(p\) 和他左边的那个人就差分开来了，第 \(1 \sim p-1\) 所属的连通块的信息不变（所以不需要额外处理第 \(p\) 个人左边的那些人的归属信息）；同时，以 \(p\) 为左端点肯定向右有连续的一段数字在向右移动后都归属于 \(p\)，对于第 \(p\) 个人右边的第 \(q\) 个人，因为 \(p\) 在移动后到达的位置是 \(G\)，而 \(q\) 如果和 \(p\) 在同一个连通块，则 \(q\) 最终的位置肯定是在位置 \(G + q - p\) 处，所以我们可以通过判断 \(q\) 当前所在的坐标是否 \(\le G+q-p\) 来判断 \(q\) 是否在 \(p\) 移动后和 \(p\) 属于同一个连通块。\(\Rightarrow\) 然后我们就可以通过二分查找找到最右边的那个和 \(p\) 属于同一个连通块的人 —— 设他是第 \(q\) 个人。

此时，将 \([p, q]\) 合并成一个连通块即可。

这里要注意，如果 \(q \lt n\)，则合并前后 \(q\) 和 \(q+1\) 肯定不属于同一个连通块（不然二分找到的就是 \(q+1\) 或者更后面的数而不是 \(q\) 了）。

向左移动

向左移动时，我们也可以二分得到最左边的那个和 \(p\) 属于同一个连通块的人（设它是第 \(pp\) 个人），则 \([pp, p]\) 合并成一个连通块。

同时要注意，第 \(p\) 个人和第 \(p+1\) 个人在移动前可能是属于同一个连通块的，当 \(p\) 向左移动后，第 \(p+1\) 个人开始的一些人，他们所在的连通块的最左边的人会变为第 \(p+1\) 个人。

所以我们要在二分查找一下移动前 \(p\) 右边的那些人中最右边的那个和 \(p\) 属于同一个连通块的人，设为第 \(q\) 个人，如果 \(q \lt p\)，则将 \([p+1, q]\) 合并成一个新的连通块。

这样我们就实时更新了位置。

但是我们并没有计算移动次数。

所以接下来最关键的就是 cal(l, r) 函数。

它用于计算 \([l, r]\) 这些人的坐标之和。

我的 cal(l, r) 函数保证 \([l, r]\) 范围内是若干个完整的连通块（即 \(l\) 是它所在连通块最左边那个人，\(r\) 是他所在连通块最右边那个人）。

对于一个连通块 \([l, r]\)，如果我们知道 \(l\) 的坐标 \(x[l]\)，那么 \([l, r]\) 范围内所有人的坐标总和是一个等差数列之和，即 \((x[l] + x[l] + r - l) \times (r - l + 1) / 2\)。

我们只计算每次移动前后变化过的完整区间的坐标和，所以虽然每次移动都会调用 cal 函数，但是 cal 函数实际计算的完整区间的总数也是 \(O(n + q)\) 数量级的。

• 如果是往右移动（坐标整体变大），移动后 cal(l, r) 的值减去移动前 cal(l, r) 的值其实就是 \([l, r]\) 范围内坐标的增量，即最少移动次数；
• 如果是往右移动（坐标整体变小），移动前 cal(l, r) 的值减去移动后 cal(l, r) 的值其实就是一勺移动次数。

按照这个逻辑就可以得到最少移动次数总和了。

示例程序：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, q, x[maxn];
long long ans;

int tr[maxn<<2];
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
void push_up(int rt) {
    // ...
}
void push_down(int rt) {
    if (tr[rt]) {
        tr[rt<<1] = tr[rt<<1|1] = tr[rt];
        tr[rt] = 0;
    }
}
void build(int l, int r, int rt) {
    if (l == r) {
        tr[rt] = l;
        return;
    }
    int mid = (l + r) / 2;
    push_down(rt);
    build(lson), build(rson);
    push_up(rt);
}
int query(int p, int l, int r, int rt) { // 查询第 p 个人归属于哪个人
    if (l == r)
        return tr[rt];
    int mid = (l + r) / 2;
    push_down(rt);
    return (p <= mid) ? query(p, lson) : query(p, rson);
}
int bl(int p) {     // 查询第 p 个人归属于哪个人
    return query(p, 1, n, 1);
}
void update(int L, int R, int p, int l, int r, int rt) { // [L, R] 都归 p
    if (L <= l && r <= R) {
        tr[rt] = p;
        return;
    }
    int mid = (l + r) / 2;
    push_down(rt);
    if (L <= mid) update(L, R, p, lson);
    if (R > mid) update(L, R, p, rson);
    push_up(rt);
}
void merge_people(int l, int r) {   // 将 [l, r] 合并成一个连通块
    update(l, r, l, 1, n, 1);
}

int get_pos(int p) { // 获得第 p 个人当前实际所在的位置
    return x[ bl(p) ] + p - bl(p);
}

long long cal(int l, int r) {
    long long res = 0;
    int p = r;
    while (p >= l) {
        int pp = bl(p);
        assert(bl(pp) == pp);
        res += (long long) (get_pos(pp) + get_pos(p)) * (p - pp + 1) / 2;
        p = pp - 1;
    }
    assert(p == l - 1);
    return res;
}

void go_right(int p, int G) {
    // q 对应最右边一个和 p 挨着的人
    int l = p, r = n, q;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (G + mid - p >= get_pos(mid))
            q = mid, l = mid + 1;
        else
            r = mid - 1;
    }
    int pp = bl(p);
    ans -= cal(pp, q);
    x[p] = G;
    merge_people(p, q);
    ans += cal(pp, q);
}

void go_left(int p, int G) {
    // pp对应最左边一个和 p 挨着的人
    int l = 1, r = p, pp;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (G + mid - p <= get_pos(mid))
            pp = mid, r = mid - 1;
        else
            l = mid + 1;
    }
    // q对应（向左移动前）最右边一个和 p 挨着的人（没有则 q = -1）
    int q = p;
    l = p+1, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (bl(mid) <= p)
            q = mid, l = mid + 1;
        else
            r = mid - 1;
    }
    ans += cal(pp, q);
    if (p < q) {
        x[p+1] = get_pos(p+1);
        merge_people(p+1, q);
    }
    x[pp] = G + pp - p;
    merge_people(pp, p);
    ans -= cal(pp, q);
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", x+i);
    build(1, n, 1);
    scanf("%d", &q);
    while (q--) {
        int p, G; // 第 p 个人走到下标 G
        scanf("%d%d", &p, &G);
        int P = get_pos(p);
        if (P < G)
            go_right(p, G);
        else if (P > G)
            go_left(p, G);
    }
    printf("%lld\n", ans);
    return 0;
}