模拟测试49

这次考试题还是蛮好的，只是人很水啊

T1

考场思路：

1.每次询问离线出来，再对于每一个k进行操作，$O(klnk)$枚举区间，再利用主席树查前驱，期望时间复杂度$O（nlogn^2）$但可以被卡到$O（n^2logn）$(对于k极小的询问)，如果优化就把k极小的询问预处理？不可实现弃辽

2.分块，不会处理每一块的答案，死了

所以正解还是分块，考虑预处理每一块答案。

对于一个k来说，答案是$max_{i=0}^{n/k}max_{j=i*k}^{i*k+k-1} \{a[j]-i*k\}$，开一个桶维护每一块内的元素，扫一边搞出<=每个数的数直接处理即可。复杂度为$O（n^2lnn/S+m*S）$当S取$\sqrt{nlogn}$的时候最小为$O（n\sqrt{nlogn}）$

#include<cstdio>
#include<cmath>
#include<iostream>
#define N 100001
#define sN 105
using namespace std;
inline int _max(int a,int b){return a>b?a:b;}
int bl[N+5],ans[sN][N+5],t[N+5],tl[N+5],tot,L[sN],a[N+5];
inline int read()
{
    int x=0,f=1;char c=getchar();
    while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9')x=x*10+c-48,c=getchar();
    return x*f;
}
inline void pre()
{
    int now;
    for(int i=1;i<=tot;i++)
    {
        now=L[i];
        while(bl[now]==i)t[a[now]]++,tl[a[now]]=a[now],now++;
        for(int j=1;j<=N;j++)if(!t[j])tl[j]=tl[j-1];now=L[i];
        for(int j=2;j<=N;j++)
        {
            for(int k=j-1;k<=N;k+=j)
                ans[i][j]=_max(ans[i][j],(tl[k]%j));
            ans[i][j]=_max(ans[i][j],(tl[N]%j));
        }
        while(bl[now]==i)t[a[now]]--,tl[a[now]]=0,now++;
    }
}
inline int query(int l,int r,int k)
{
    int mx=0;
    if(bl[l]==bl[r])
    {
        for(int i=l;i<=r;i++)mx=_max(mx,a[i]%k);
        return mx;
    }
    for(int i=l;bl[i]==bl[l];i++)mx=_max(mx,a[i]%k);
    for(int i=bl[l]+1;i<bl[r];i++)mx=_max(mx,ans[i][k]);
    for(int i=r;bl[i]==bl[r];i--)mx=_max(mx,a[i]%k);
    return mx;
}
int main()
{
    int n=read(),m=read();
    int t=sqrt(n*20)+1;
    for(int i=1;i<=n;i++)
    {
        bl[i]=(i-1)/t+1;//printf("%d\n",bl[i]);
        if(bl[i]!=bl[i-1])L[bl[i]]=i;
        a[i]=read();
    }tot=bl[n];pre();
    while(m--)
    {
        int l=read(),r=read(),k=read();
        printf("%d\n",query(l,r,k));
    }
    return 0;
}

T2

n^2思路很简单，但是会被卡空间。

所以换个角度，按x排序。

实际上就是找不断往中间收缩的方案数（感性理解）

考虑处理出前i-1个如何弄第i个，设dp[i][0/1]表示以i为起点往左/右走的方案数

如果i是起点，那么给i加上前面比它小的往右撇的方案即可

如果不是，那么i一定是第二个点，枚举起点和第三个点，给起点加上第三个点的贡献。

得出转移方程：

dp[i][0]+=dp[j][1] (j<i&&y[j]<y[i])

dp[j][1]+=dp[z][1] (j<i&&z>j&&z<i&&y[z]<y[j]&&y[j]<y[i])

#include<cstdio>
#include<algorithm>
#define FH_SB 6005
using namespace std;
const int mod=1e9+7;
int dp[FH_SB][2],s[FH_SB];
struct node{
    int fh,sb;
    inline void init(){scanf("%d%d",&fh,&sb);}
    friend bool operator <(const node a,const node b){ return a.fh<b.fh;}
}a[FH_SB];
int main()
{
    int n,ans=0;scanf("%d",&n);
    for(int i=1;i<=n;i++)a[i].init();
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++)
    {
        s[i]=1;dp[i][0]++;dp[i][1]++;
        for(int j=i-1;j;j--) s[j]=(s[j+1]+dp[j][1]*(a[j].sb<a[i].sb))%mod;
        for(int j=1;j<i;j++)
        {
            if(a[j].sb<a[i].sb)(dp[i][0]+=dp[j][1])%=mod;
            else (dp[j][1]+=s[j+1])%=mod;
        }
    }
    for(int i=1;i<=n;i++)(ans+=(dp[i][0]+dp[i][1])%mod)%=mod;
    printf("%d\n",ans-n);
}

 

T3不会，咕了。