HDU-6356 Glad You Came （rmq）

最新推荐文章于 2020-06-23 20:39:12 发布

原创最新推荐文章于 2020-06-23 20:39:12 发布 · 298 阅读

0 ·

CC 4.0 BY-SA版权

多校同时被 2 个专栏收录

42 篇文章

订阅专栏

数据结构

5 篇文章

订阅专栏

本文详细介绍了如何使用逆向更新和线段树或RMQ（线段树或区间查询）来解决在大范围内进行多次更新操作后，计算最终数组抑或值的问题。特别关注于优化时间复杂度，适用于处理大量更新操作的场景。

题目：刚开始一个长度为n(n<=1e5)的全为0的数组a，生成q(q<=5e6)组更新（l,r,v）把 l 到 r 区间内小于v的数都更新成v，最后输出n个数字的抑或值。

思路：时间卡的好紧，比赛时，优先队列维护T，线段树也T，时间复杂度O(qlogn)，但是q太大了数据组数又比较多。赛后看官方题解分析的是rmq，O(nlogn)，更新时逆向更新就好。

#include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define u unsigned int
#define ll long long
const int maxn=1e5+10;
const u mod=(1<<30);
u x,y,z,w;
u rng61()
{
    x=x^(x<<11);
    x=x^(x>>4);
    x=x^(x<<5);
    x=x^(x>>14);
    w=x^(y^z);
    x=y;
    y=z;
    z=w;
    return z;
}

ll dp[maxn][25],f[maxn],p[110],a[maxn];
int main()
{
    #define int ll
    int t,sum=1,num=0;
    p[0]=1;
    cin>>t;
    for(int i=1;i<maxn;i++)
    {
        if(sum*2==i)
        {
            sum*=2;
            num++;
            p[num]=sum;
        }
        f[i]=num;
    }
    while(t--)
    {
        ll n,q;
        cin>>n>>q>>x>>y>>z;
        for(int i=1;i<=n;i++)
            for(int j=0;j<=22;j++)
                dp[i][j]=0;
        u nn=n;
        for(int i=1;i<=q;i++)
        {
            ll f1=rng61();
            ll f2=rng61();
            ll f3=rng61();
            int l=(int)min((f1%nn)+1,(f2%nn)+1);
            int r=(int)max((f1%nn)+1,(f2%nn)+1);
            int v=(int)(f3%mod);

            int d=f[r-l+1];//找到2的几次方
            dp[l][d]=max(dp[l][d],v);
            dp[r-p[d]+1][d]=max(dp[r-p[d]+1][d],v);
        }
        for(int j=f[n];j;j--)
        for(int i=1;i<=n;i++)
        {
            dp[i][j-1]=max(dp[i][j-1],dp[i][j]);///rmq的逆向
            if(i+p[j-1]<=n)
            dp[i+p[j-1]][j-1]=max(dp[i+p[j-1]][j-1],dp[i][j]);///rmq的逆向
        }
        ll ans=0;
        for(int i=1;i<=n;i++)
            ans^=1ll*i*1ll*dp[i][0];
        cout<<ans<<endl;
    }
    return 0;
}
/*
4
1 10 100 1000 10000
10 100 1000 10000 100000
100 1000 10000 100000 1000000
1000 10000 100000 1000000 10000000

*/