【题解】Luogu P5313 僕たちはひとつの光([Ynoi2012]D2T2)

原题传送门

lovelive好评
比赛时只拿到了60pts,还是自己太菜了
这题的思想实际有点像Luogu P3674 小清新人渣的本愿Luogu P5071 [Ynoi2015]此时此刻的光辉
这题没有修改操作,我们像P3674一样考虑bitset
要求首项小于b且公差为b的等差数列的最大长度
把原序列分成n/b段,每一位表示是否存在
把所有的一个一个&起来就珂以判断答案了
但是,我们发现当b很小的时候,复杂度就能被卡成\(O(n^2)\)
像P5071一样考虑当b较小时,单独处理
当b值一样时我们珂以用莫队暴力解决(细节详见代码)
这样就珂以过这题了
#include <bits/stdc++.h>
#define N 200005 
#define getchar nc
using namespace std;
inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
inline void write(register int x)
{
    if(!x)putchar('0');if(x<0)x=-x,putchar('-');
    static int sta[20];register int tot=0;
    while(x)sta[tot++]=x%10,x/=10;
    while(tot)putchar(sta[--tot]+48);
}
struct query{
    int l,r,b,id,bl;
};
bool operator < (const query &a,const query &b){
    return a.bl!=b.bl?a.l<b.l:((a.bl&1)?a.r<b.r:a.r>b.r);
}
vector <query> q[N];
int n,m,a[N],blocksize,b[N],t,ans[N],lim,maxx;
int mex[205],cnt[N];
inline void ins(register int x)
{
    ++cnt[a[x]];
    while(cnt[mex[b[x]]*t+b[x]])
        ++mex[b[x]];
}
inline void rem(register int x)
{
    if(--cnt[a[x]]==0)
        mex[b[x]]=min(mex[b[x]],a[x]/t);
}
unsigned long long bit[N],f[N];
inline void add(register int x)
{
    if(++cnt[a[x]]==1)
        bit[a[x]>>6]^=1ull<<(a[x]&63);
}
inline void del(register int x)
{
    if(--cnt[a[x]]==0)
        bit[a[x]>>6]^=1ull<<(a[x]&63);
}
inline unsigned long long getbit(register int x,register int y)
{
    int l=x>>6,r=y>>6,s=x&63,t=y&63;
    if(l==r)
        return (bit[l]&((1ull<<s)-1^(2ull<<t)-1))>>s;
    return bit[l]>>s|(bit[r]&(2ull<<t)-1)<<(64-s);
}
int main()
{
    n=read();
    for(register int i=1;i<=n;++i)
        a[i]=read(),maxx=max(maxx,a[i]);
    m=read();
    for(register int i=1;i<=m;++i)
    {
        int l=read(),r=read(),qb=read();
        q[qb<=64?qb:0].push_back((query){l,r,qb,i,0});
    }
    for(t=0;t<=64;++t)
    {
        if(q[t].empty())
            continue;
        blocksize=max(1.0,sqrt(1ll*n*n/(int)q[t].size()));
        for(register int i=0;i<(int)q[t].size();++i)
            q[t][i].bl=(q[t][i].l-1)/blocksize+1;
        sort(q[t].begin(),q[t].end());
        if(t)
        {
            for(register int i=1;i<=n;++i)
                b[i]=a[i]%t;
            int l=1,r=0;
            for(register int i=0;i<(int)q[t].size();++i)
            {
                int id=q[t][i].id,ll=q[t][i].l,rr=q[t][i].r;
                while(ll<l)
                    ins(--l);
                while(rr>r)
                    ins(++r);
                while(ll>l)
                    rem(l++);
                while(rr<r)
                    rem(r--);
                for(register int j=0;j<t;++j)
                    ans[id]=max(ans[id],mex[j]);
            }
            memset(mex,0,sizeof(mex));
            for(register int i=l;i<=r;++i)
                cnt[a[i]]=0; 
        }
        else
        {
            int l=1,r=0;
            for(register int i=0;i<(int)q[t].size();++i)
            {
                int ll=q[t][i].l,rr=q[t][i].r,qb=q[t][i].b-1;
                lim=qb>>6;
                while(ll<l)
                    add(--l);
                while(rr>r)
                    add(++r);
                while(ll>l)
                    del(l++);
                while(rr<r)
                    del(r--);
                bool flag=true;
                for(register int j=0;j<=lim;++j)
                    f[j]=(1ull<<64)-1;
                for(register int j=0,s=0;;++j)
                {
                    for(register int k=0;k<lim&&s<=maxx;++k)
                    {
                        f[k]&=getbit(s,s+63);
                        s+=64;
                        flag&=!f[k];
                    }
                    f[lim]&=getbit(s,s+(qb&63));
                    s+=(qb&63)+1;
                    flag&=!f[lim];
                    if(flag)
                    {
                        ans[q[t][i].id]=j;
                        break;
                    }
                    flag=true;
                }
            }
            for(register int i=l;i<=r;++i)
                cnt[a[i]]=0; 
        }
    }
    for(register int i=1;i<=m;++i)
        write(ans[i]),puts("");
    return 0;
}

转载于:https://www.cnblogs.com/yzhang-rp-inf/p/10567943.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
题目 P5413 "YNOI2019 骑单车" 是一个经典的动态规划和贪心算法的问题。该题主要涉及两个概念:路径规划和状态转移方程。 **背景描述** 假设你在一个二维网格上,每个单元格代表一个地点,你需要从起点出发骑车到终点,并尽可能地减少骑行时间。网格中的每个单元格都有两种可能的状态:平地(速度不变)或斜坡(速度减半)。你的目标是找到一条最短的路线。 **关键点解析** 1. **动态规划**:通常用于求解最优化问题。在这个问题中,我们可以定义一个二维数组 dp[i][j] 表示从起点到位置 (i, j) 的最短行驶时间。状态转移方程会根据当前位置的性质(平地还是斜坡)以及到达此位置的最短路径来自之前的节点计算。 2. **状态转移**:对于平地,dp[i][j] = dp[pi][pj] + cost,表示直接移动到相邻位置的时间;对于斜坡,dp[i][j] = min(dp[pi][pj], dp[pi][pj-1]) + cost/2,因为斜坡速度减半,所以需要选择更早的时刻经过。 3. **贪心策略**:有时候,为了达到全局最优,初始看起来不是最优的选择可能是正确的。但在这个问题中,贪心策略可能并不适用,因为我们不能仅依据当前状态做出决策,需要考虑到整个路径。 4. **边界条件**:初始化 dp 数组时,起点时间设为 0,其余位置设为正无穷大,保证一开始就只会向可达的位置移动。 **代码实现** 实现这样的动态规划算法通常需要用到一个优先队列(如最小堆),以便于高效地查找之前节点的最优时间。 **相关问题--:** 1. 如何设计状态转移方程来处理平地和斜坡的情况? 2. 这个问题是否存在剪枝操作以提高效率? 3. 如果网格大小非常大,如何避免存储所有 dp 值导致的空间爆炸?

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值