【二维cdq】P3374 【模板】树状数组 1

P3374 【模板】树状数组 1

题目链接

这道题的特殊处理方法：因为查询是对于区间的， 那么我们把一个查询操作转换为两个前缀和的查询， 只不过这两个查询的系数不同， 右值的前缀和是1 左值的前缀和是-1， 这样应用在答案上得到时候就是相当于前缀和做的区间查询。

对于操作的记录主要有两个维度， 第一个是修改的时间；第二个是修改的位置和值， 那么做法是我们函数中任何时候基于时间维度排序， 因为cdq是递归的， 那么在递归回来之后我们要保证左边一半的时间维度全部比右边一半的时间维度小， 那么也就是让左边的所有点时间都小，同时对于单独的某一边，第二个维度即位置是单调递增的， 所以我们不难看出左边一半中所有的修改都会对右边一半的所有操作产生可能的影响，原因是左边的操作时间比右边的查询时间早， 那么只要左边的修改位置处于右边某一个查询的范围内，那么就肯定会产生之间性的影响。

那么怎么处理这样的影响呢？ 上面说了时间已经被分割成了两个部分， 那么对于每一个部分让位置这个属性递增，效果就是我们能用双指针发现并且处理所有的修改的影响：左边下标从 L 开始， 右边下标从mid + 1 开始

• 如果发现左边所指的pos比较小或者一样，那么这个修改肯定会影响右边这个查询的结果，所以我们先把这个影响缓存起来，因为如果右边当前的位置会被影响， 那么这个位置更右边的所有查询都会被影响，所以直接缓存做一个累积的效果。左指针右移。
• 如果左边所指的pos比较大，那么当前右边的值不会被这个修改影响， 那么先把左边原来累积的影响加在这个右边的值上， 直接应用在答案的缓存数组中。右指针右移。

这个区间结束后，我们对于当前区间进行排序， 通常不会考虑用传统的排序如sort()等直接排序， 因为递归中层数未知，如果用sort时间的累积效果会变大，更安全的做法是用双指针对于第二个维度即位置做排序。相当于并归排序。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define min(i, j) (i < j ? i : j)
#define max(i, j) (i > j ? i : j)
const int maxn = 1e6 + 10;
const int maxm = 1e6 + 10;

ll saveori[maxn];
ll sum[maxn];

struct node
{
    int t;//操作的类型
    int pos;//操作的位置
    int val;//如果是修改，在这里记录修改的值
    int id;//这个是第几个操作，因为输出要根据题目给的操作的顺序输出
    int flag;//存查询的系数1或者-1
} ops[maxn], temp[maxn];
ll ans[maxn];

void cdq(int l, int r)
{
    if (l == r)
    {
        if (ops[l].t == 2)
        {
            ans[ops[l].id] += ops[l].flag * sum[ops[l].pos];
        }
        return;
    }
    int mid = (l + r) / 2;
    cdq(l, mid);
    cdq(mid + 1, r);

    int larr = l;
    int rarr = mid + 1;
    ll tempsum = 0;
    while (larr <= mid && rarr <= r)
    {
        if (ops[larr].t == 2)
        {
            larr++;
            continue;
        }
        if (ops[rarr].t == 1)
        {
            rarr++;
            continue;
        }
        node lo = ops[larr];
        node ro = ops[rarr];
        if (lo.pos <= ro.pos)
        {
            tempsum += lo.val;
            larr++;
        }
        else
        {
            ans[ro.id] += tempsum * ro.flag;
            rarr++;
        }
    }

    while (rarr <= r)
    {
        node ro = ops[rarr];
        if (ro.t == 2)
        {
            ans[ro.id] += tempsum * ro.flag;
        }
        rarr++;
    }

    larr = l;
    rarr = mid + 1;
    int idx = 0;
    while (larr <= mid || rarr <= r)
    {
        if (larr <= mid && rarr <= r)
        {
            node ro = ops[rarr];
            node lo = ops[larr];
            if (ro.pos < lo.pos)
            {
                temp[idx++] = ro;
                rarr++;
            }
            else
            {
                temp[idx++] = lo;
                larr++;
            }
        }
        else if (larr <= mid)
        {
            temp[idx++] = ops[larr++];
        }
        else
        {
            temp[idx++] = ops[rarr++];
        }
    }
    for (int i = 0; i < idx; i++)
    {
        ops[l + i] = temp[i];
    }
}

vector<int> v;
int main()
{
    // freopen("in.txt", "r", stdin);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> saveori[i];
        sum[i] = sum[i - 1] + saveori[i];
    }
    int id = 0;
    for (int i = 1; i <= m; i++)
    {
        id++;
        int t, x, y;
        cin >> t >> x >> y;
        if (t == 1)
        {
            ops[id].pos = x;
            ops[id].val = y;
            ops[id].t = t;
            ops[id].id = i;
            ops[id].flag = 1;
        }
        else if (t == 2)
        {
            v.push_back(i);
            ops[id].pos = x - 1;
            ops[id].t = t;
            ops[id].flag = -1;
            ops[id].id = i;

            id++;
            ops[id].pos = y;
            ops[id].t = t;
            ops[id].flag = 1;
            ops[id].id = i;
        }
    }
    cdq(1, id);
    for (int ttt : v) {
        cout << ans[ttt] << endl;
    }
}