【分块】UPC Contest2535 - 2020年夏混合个人训练第八十场 B 序列

问题 B: 序列

时间限制: 1 Sec 内存限制: 128 MB

题目描述
$eobiyye$ 给了你一个长度为n的序列 $ai$ ，序列中每个元素的初始值为$0$。
接下来她会对这个序列进行m次操作，每次操作有4个参数$l,r,s,e$，表示将区间$[l,r]$加上一个首项为$s$，末项为 $e$ 的等差数列。
若一次操作中$l=1,r=5,s=2,e=10$，则对序列中第1~5个数分别加上$2,4,6,8,10$。
现在$Geobiyye$要求你求出m次操作后序列中的每个数的值。

输入
第一行 $2$ 个整数 $n,m$，表示序列长度和操作数。
接下来 $m$ 行，每行 $4$ 个整数 $l,r,s,e$，含义见题目描述。
数据保证等差数列中的每一项都是整数。

输出
由于输出数据过大，$Geobiyye$只想要知道最终序列每一项的异或和，即。（其中表示二进制下的异或操作，在$c++$中为^）

样例输入 Copy

5 2
1 5 2 10
2 4 1 1

样例输出 Copy

3

提示
样例解释：

第一次操作加的数列：$246810$
第二次操作加的数列：$01110$
所有操作结束后序列每个元素值为：$257910$。
输出异或和，就是$3$。

【数据范围】

对于30%的数据：$n,m\le 1000$ 。
对于50%的数据：$n,m\le 100000$。
对于另外20%的数据：$s=e$。
对于100%的数据：$n,m\le 500000,1\le l＜r\le n$。
数据保证输入数据以及在任何时候序列中的数在$[0,9\times 10^{18}]$范围内。

本题输入文件较大，$Geobiyye$给了你一份快速读入的模板。

template <typename T> void read(T &x){
int f=1;x=0;char c=getchar();
for (;!isdigit(c);c=getchar()) if (c=='-') f=-f;
for (; isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}

你可以使用函数read(x)读入一个 $int$ 或$long$ $long$类型的整数。

以下为示范程序：

#include<bits/stdc++.h>
using namespace std;
template <typename T> void read(T &x){
int f=1;x=0;char c=getchar();
for (;!isdigit(c);c=getchar()) if (c=='-') f=-f;
for (; isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}
int n;
long long m;
int main(){
read(n);//读入int类型变量n
read(m);//读入long long类型变量m
return 0;
}

题目大意：
区间修改，单点查询。区间修改是在原序列的基础之上增加一个等差数列。输出所有操作完成后新序列所有元素的异或和。
解题思路：
采取分块来解决，每次维护一个块中加入的等差数列的首项和公差。
下面插入一张洛谷上一道相似的题，关于某位大佬题解的图片，大佬题解

关键点就是上图所展示的等差数列的性质，其他的就是分块的基本操作，如果不会分块的基本操作的活，在这里我推荐一下我的另一篇博客，那上边有分块专题的部分题解。数列分块题解

上代码：

#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma GCC optimize(3)
#pragma G++ optimize(3)
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 500010;
ll n,m,block,L[N],R[N],blong[N],num;
ll a[N],lazy1[N],lazy2[N];
/*
num块的个数 
block块的大小
a[i]原数列元素
lazy1[i]第i块的首项 
lazy2[i]第i块的公差 
L[i]表示第i块的左边界 
R[i]表示第i块的右边界 
blong[i]表示属于哪一块 
*/
inline ll read(){
    ll  x=0;
    bool f=0;
    char ch=getchar();
    while (ch<'0'||'9'<ch)    f|=ch=='-', ch=getchar();
    while ('0'<=ch && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return f?-x:x;
}
void build()
{
    block = sqrt(n);//每个块的大小，sqrt(n)时复杂度最低 
    if(n % block == 0) num = n / block;
    else num = n / block + 1;  //最后一个快可能不够block个 
    for(int i = 1;i <= num;i ++)
    {
        L[i] = (i - 1) * block + 1,R[i] = i * block;//每个块的左右边界  
    } 
    R[num] = n; //最后一块特殊处理 
    for(int i = 1;i <= n;i ++)
    {
        blong[i] = (i - 1) / block + 1;//块的个数从1开始，So不应写成i/block 
    } 
} 
void add(int l,int r,int k,int d)
{
    if(blong[l] == blong[r])
    {
        for(int i = l;i <= r;i++)
        {
            a[i] += k + (i - l) * d;
        }
        return;
    }
    ll res = k + d * (R[blong[l]] - l + 1);
    for(int i = l;i <= R[blong[l]];i++)
    {
        a[i] += k + 1ll*(i - l) * d;
    }
    for(int i = blong[l] + 1;i <= blong[r] - 1;i++)
    {
        lazy1[i] += res;
        lazy2[i] += d;
        res += d * (R[i] - L[i] + 1);
    }
    for(int i = L[blong[r]];i <= r;i++)
    {
        a[i] += res + (i - L[blong[r]]) * d;
    }
}
ll query(int x)
{
    ll k = lazy1[blong[x]],d = lazy2[blong[x]];
    ll res = a[x] + k + d * (x - L[blong[x]]);
    return res;
}
int main()
{
    n=read(),m=read();
    build();
    while(m--)
    {
        ll l,r,k,d,s,e;
        l=read(),r=read(),s=read(),e=read();
        k=s;d=(e-s)/(r-l);
        add(l,r,k,d);
    }
    ll ans = 0;
    for(int i=1;i<=n;i++)
    {
        //cout<<query(i)<<endl;
        ans^=query(i);
    }
    printf("%lld",ans);
    return 0;
}

另外需要说一下，这道题对时间的限制卡的比较紧，需要加上读入挂和一些玄学优化，比较的极限，正好能卡过。