bzoj3827:[Poi2014]Around the world

最新推荐文章于 2020-01-13 20:23:43 发布

原创最新推荐文章于 2020-01-13 20:23:43 发布 · 914 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#oi #poi #内存

bzoj 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了一种解决特定问题的算法，其核心思想在于枚举变量d，并通过计算每一点在当前d值下的可达范围来构建一棵树状结构。最终使用并查集进行维护，总的时间复杂度为O(n*s)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先枚举d(复杂度是O(s))。
接着计算从每一点出发在当前d的情况下最远可以到达那个点(复杂度为O(n))。
最后这些就形成了一棵以2*n为根的树(因为每个点只有一个指向的节点)。
最后在用并查集维护就行了。
总的复杂度是O(n*s)的。
但是这道题疯狂卡常和卡内存。(我这种蒟蒻就MLE和TLE了无数次）
详细看代码。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
inline int read()
{
    int x=0,f=1,ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-'){f=-1;}ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int next[2000001];
int dep[2000001];
int n,s;
int l[1000001];
int d;
inline int calc(int x)
{
    register int now=x;
    register int fa=x;
    while(fa-x<n)
    {
        fa=next[fa];
    }
    register int k;
    while(now-x<n)
    {
        k=next[now];
        next[now]=fa;
        now=k;
    }
    return dep[x]-dep[now];
}
int minn=0;
int main()
{
    n=read();s=read();
    for(int i=1;i<=n;i++)
    {
        l[i]=read();
        minn=max(minn,l[i]);
    }
    while(s--)
    {
        d=read();
        if(d<minn)
        {
            puts("NIE");
            continue;
        }
        register int sum=0;
        register int j=1;
        for(register int i=1;i<=2*n;i++)
        {
            while(j<2*n&&sum+l[(j>n)?j-n:j]<=d)
            {
                sum=sum+l[(j>n)?j-n:j];
                j++;
            }
            next[i]=j;
            sum-=l[(i>n)?i-n:i];
        }
        dep[2*n]=1;
        register int ans=99999999;
        dep[2*n]=0;
        for(int i=2*n;i>=1;i--)
        {
            dep[i]=dep[next[i]]+1;
        }
        for(int i=1;i<=n;i++)
        {
            ans=min(ans,calc(i));
        }
        printf("%d\n",ans);
    }
    return 0;
}