模拟12题解

T1[A. 斐波那契(fibonacci)]

考场上发现了一个性质：一个节点的父节点=该节点编号-上一个fibonacci数

所以求父亲节点代码

int fa(int x)
{
    for(int i=mx;i;i--)
        if(fi[i]<x)
            return x-fi[i];
}

然后我只想到了建树的70%代码，数组越界了又少了30分QAQ

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define int long long
using namespace std;
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
const int mx=65;
const int maxn=1000000;
int fi[mx+10];
int d[maxn+5];
int f[maxn+5][25];
struct node{
    int v,nxt;
}e[maxn];int h[maxn],nu;
void add(int x,int y)
{
    e[++nu].v=y;
    e[nu].nxt=h[x];
    h[x]=nu;
}
int gfa(int x)
{
    for(int i=mx;i;i--)
        if(fi[i]<x)
            return x-fi[i];
}
void bfs()
{
    queue<int>q;
    d[1]=1;
    q.push(1);
    while(q.size())
    {
        int x=q.front();q.pop();
        for(int i=h[x];i;i=e[i].nxt)
        {
            int y=e[i].v;
            if(d[y])continue;
            d[y]=d[x]+1;
            f[y][0]=x;
            for(int j=1;j<=21;j++)
                f[y][j]=f[f[y][j-1]][j-1];
            q.push(y);
        }
    }
}
int lca(int x,int y)
{
    if(d[x]>d[y])swap(x,y);
    for(int i=21;i>=0;i--)
        if(d[f[y][i]]>=d[x])
            y=f[y][i];
    if(y==x)return x;
    for(int i=21;i>=0;i--)
        if(f[x][i]!=f[y][i])
            x=f[x][i],y=f[y][i];
    return f[x][0];    
}
signed main()
{
    //freopen("fibonacci2.in","r",stdin);
    int m=read(),mxx;
    fi[0]=fi[1]=1;
    for(int i=2;i<=mx;i++)
        fi[i]=fi[i-1]+fi[i-2];
    for(int i=2;i<=maxn;i++)
    {
        int fa=gfa(i);
        add(fa,i);
    }
    bfs();
    for(int i=1;i<=m;i++)
    {
        int x=read(),y=read();
        printf("%lld\n",lca(x,y));
    }
}
/*
g++ 1.cpp -o 1
./1

*/

可是考完才发现暴力既好写，又能A

对于输入的两个节点x,y将其中一个向上遍历，并把经过的路径都存入一个vector

然后另一个向上翻，如果在vector中能找到，那此时的y就是答案

时间复杂度$O(60mlog(n))$

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#define int long long
using namespace std;
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
const int mx=65;
int fi[mx+10];
int fa(int x)
{
    for(int i=mx;i;i--)
        if(fi[i]<x)
            return x-fi[i];
}
signed main()
{
    //freopen("data","r",stdin);
    int m=read();
    fi[0]=fi[1]=1;
    for(int i=2;i<=mx;i++)
        fi[i]=fi[i-1]+fi[i-2];
    vector<int>v;
    for(int i=1;i<=m;i++)
    {
        int x=read(),y=read();
        v.clear();
        while(x>1)
        {
            v.push_back(x);
            x=fa(x);
        }
        while(y>1)
        {
            vector<int>::iterator res=find(v.begin(),v.end(),y);
            if(res!=v.end())  break;
            y=fa(y);
        }
        printf("%lld\n",y);
    }
}
/*
g++ 1.cpp -o 1
./1

*/

vector中查找元素:

vector<int>::iterator res=find(v.begin(),v.end(),y);//在v中查找y
if(res!=v.end()) //找到了 

 

T2[B. 数颜色]「排序」「线段树」「分块」「莫队」

考场上只想到了$O(nm)$的纯暴力，

然而以上的这些都能拿到不少的部分分，更有主席树，树套树的高超方法，我却什么都搞不出来

65%+算法：动态开点线段树

考试时想用线段树，当时的思维是这样的：死板地维护区间1-n，然后查询。。。打到一半，诶，查询什么？线段树里开3e5个颜色的个数，不可能的。。。

然后就傻了，想想其他的数据结构我也没法维护。。

殊不知，，我"忘"了一个叫权值线段树的东西，动态开点，每棵树维护每种color的在原区间的个数，时空复杂度$O(nlog(n))$

使用动动的代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
int a[300001];
int rt[300001],trsum[10000000],son[10000000][2],tot;
void change(int &x,int l,int r,int to,int d)
{
    if(!x)x=++tot;
    trsum[x]+=d;
    if(l==r)return;
    int mid=(l+r)>>1;
    if(to<=mid)change(son[x][0],l,mid,to,d);
    else change(son[x][1],mid+1,r,to,d);
}
int ask(int x,int l,int r,int L,int R)
{
    if(!x)return 0;
    if(l==L&&r==R)return trsum[x];
    int mid=(l+r)>>1;
    if(L>mid)return ask(son[x][1],mid+1,r,L,R);
    else if(R<=mid)return ask(son[x][0],l,mid,L,R);
    else return ask(son[x][0],l,mid,L,mid)+ask(son[x][1],mid+1,r,mid+1,R);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        change(rt[a[i]],1,n,i,1);
    }
    while(m--)
    {
        int opt;
        scanf("%d",&opt);
        if(opt==1)
        {
            int l,r,c;
            scanf("%d%d%d",&l,&r,&c);
            printf("%d\n",ask(rt[c],1,n,l,r));
        }
        else
        {
            int x;
            scanf("%d",&x);
            change(rt[a[x  ]],1,n,x  ,-1);
            change(rt[a[x  ]],1,n,x+1, 1);
            change(rt[a[x+1]],1,n,x+1,-1);
            change(rt[a[x+1]],1,n,x  , 1);
            a[x]^=a[x+1]^=a[x]^=a[x+1];
        }
    }
    return 0;
}

65%+算法：分块

我现在已经想不起来我当时怎么把分块给否了的，可能当时粗略一想空间不够，但是分完块就没几块了，复杂度$O(m\sqrt{n})$这么直接的算法我也想不到，想得严密一些不要轻易就放弃自己的想法

正解：

将（颜色，位置）按照二元组排序，对于查询操作，使用结构体lower_bound二分查找

对于修改操作，暴力修改结构体的pos，

注意若两个颜色不同，那么修改不会改变每个颜色块里的顺序

若相同，不用修改

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mid ((l+r)>>1)
using namespace std;
const int maxn=3e5+5;
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
int n,sum[maxn],jl[maxn]; 
struct node{
    int pos,da;
}a[maxn];
bool cmp(node x,node y){return (x.da==y.da)?x.pos<y.pos:x.da<y.da;}
int main()
{
//    freopen("data","r",stdin);
    n=read();int Q=read(),mc=0;
    for(int i=1;i<=n;i++)
    {
        a[i].da=read(),a[i].pos=i;
        sum[a[i].da]++;
        mc=max(mc,a[i].da);
        jl[i]=a[i].da;
    }
    for(int i=1;i<=mc;i++)
        sum[i]+=sum[i-1];
    sort(a+1,a+n+1,cmp);
    while(Q--)
    {
        int opt=read();
        if(opt==1)
        {
            int L=read(),R=read(),col=read();
            node l,r;
            l.da=col,l.pos=L;
            r.da=col,r.pos=R;
            int ll=lower_bound(a+sum[col-1]+1,a+sum[col]+1,l,cmp)-a;
            int rr=upper_bound(a+sum[col-1]+1,a+sum[col]+1,r,cmp)-a;
            printf("%d\n",rr-ll);
        }
        if(opt==2)
        {
            int i=read();
            int x=i,y=i+1;
            if(jl[x]==jl[y])continue;
            node xx,yy;
            xx.pos=x,xx.da=jl[x];int c1=jl[x];
            yy.pos=y,yy.da=jl[y];int c2=jl[y];
            int xp=lower_bound(a+sum[c1-1]+1,a+sum[c1]+1,xx,cmp)-a;
            int yp=lower_bound(a+sum[c2-1]+1,a+sum[c2]+1,yy,cmp)-a;
            a[xp].pos=y,a[yp].pos=x;
            jl[x]=yy.da,jl[y]=xx.da;
        }
    }
}
/*
g++ 2.cpp -o 2
./2

*/

结构体lower_bound:

bool cmp(node x,node y){return (x.da==y.da)?x.pos<y.pos:x.da<y.da;}
int ll=lower_bound(a+1,a+n+1,l,cmp)-a;//a中查找l返回下标ll

 

T3[C. 分组]「二分图」

性质：若要保证字典序最小，则从后往前枚举，让每一段区间尽量长，那么可以保证字典序最小

k==1时，从后往前枚举，看枚举到的点与已有的点有无矛盾，若有则该点为断点

k==2时，同样的枚举方式对于枚举到的点的判断方式：

每段区间就是一个二分图，

1：若三者互相矛盾 ，那么当枚举到第三个时，发现第三个与其中一个放不到两边，设置为断点

2：若有两个相同的颜色，第三个不同颜色，枚举到的第三个是不同颜色时，或是两个相同颜色中的一个，都要干掉

实现见代码注释

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
const int maxn=140000;
int mx,n,k,a[maxn+100],issqr[2*maxn+100],cnt,ans[maxn+100],v[maxn+100],fa[2*maxn+100];
int find(int x)
{
    if(fa[x]!=x)fa[x]=find(fa[x]);
    return fa[x];
}
int jud(int x,int y)//x y have had conflict  &&判断是否能在两边
{
    int x1=find(x),x2=find(x+maxn);//x1 x的敌人代表元素  x2  朋友
    int y1=find(y),y2=find(y+maxn);
    if(x1==y1||x2==y2)return 0;//have same friend or emery
    fa[x1]=y2,fa[x2]=y1;// divide into two different jihe
    return 1;    
}
void solve1()
{
    for(int i=1;i<=n;i++)mx=max(mx,a[i]);
    ans[cnt]=n;
    for(int i=n;i>=1;i--)
    {
        for(int j=sqrt(a[i]);j*j<=mx+a[i];j++)
        {
            if(j*j-a[i]>0&&v[j*j-a[i]])
            {
                for(int k=i+1;k<=ans[cnt];k++)v[a[k]]=0;
                ans[++cnt]=i;
                break;
            }
       }
       v[a[i]]=1;
    }
}
int vis[maxn],svis[maxn];
void solve2()
{
    for(int i=1;i<=2*maxn;i++)fa[i]=i;
    for(int i=1;i*i<=2*maxn;i++) issqr[i*i]=1;
    for(int i=n,j=n;i>=1;)
    {
        for(;j>=1;j--)
        {
            if(vis[a[j]])//如果这个点出现过一次
            {
                if(!issqr[2*a[j]])continue;//并且这个点与自己同颜色的矛盾
                if(svis[a[j]])goto fail;//如果这个点已经出现了两次，两个可以分到二分图的两边，所以不可能就再有了，成为断点
                for(int k=1;k*k<=mx+a[j];k++)//所以这是第二个点
                    if(k*k-a[j]>0&&vis[k*k-a[j]]&&k*k!=2*a[j])goto fail;//找到了另一个与该颜色矛盾，跳过成为断点
                svis[a[j]]=1;//这种颜色出现了两次，并且在二分图两边（1）
            }
            else //没有出现过
            {
                for(int k=1;k*k<=mx+a[j];k++)
                    if(k*k-a[j]>0&&vis[k*k-a[j]])//找到了与它矛盾的点
                        if(svis[k*k-a[j]]||jud(a[j],k*k-a[j])==0)//如果这个点已经在二分图的两边（1情况）  或 这两个点不能放在两边
                            {fa[a[j]]=a[j];fa[a[j]+maxn]=a[j]+maxn;goto fail;}//清空这个断点的并查集信息
                vis[a[j]]=1;
            }
        }
        fail:
        if(j==0)break;
        ans[++cnt]=j;
        for(;i>j;i--)fa[a[i]]=a[i],fa[a[i]+maxn]=a[i]+maxn,vis[a[i]]=svis[a[i]]=0;
    }
}
int main()
{
    n=read(),k=read();
    for(int i=1;i<=n;i++)
        a[i]=read(),mx=max(mx,a[i]);
    if(k==1)solve1();
    else solve2();
    printf("%d\n",cnt+1);
    for(int i=cnt;i>=1;i--) printf("%d ",ans[i]);
    puts("");
}
/*
g++ 1.cpp -o 1
./1

*/