2019牛客暑期多校训练营（第三场）

Solutions

---

B：Crazy Binary String

题意：

给出$01$串，询问最长的“$01$数量相等”的字串和子序列。

思路：

字串的话，把$0$变成$-1$，求前缀和，如果$sum[r]-sum[l-1]=0$，说明$01$数量相等。

所以可以跑一遍，$map$找到符合的位置。取最大。

子序列：显示是$2{\ast}min(num[zero],num[one])$

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+10;

int n,sum[maxn];
char s[maxn];

map<int,int> mp;
int main() {
    scanf("%d",&n);
    scanf("%s",s+1);
    int one=0,zero=0;
    for(int i=1;i<=n;i++) {
        if(s[i]=='1') one++;
        else zero++;
        sum[i]=sum[i-1]+(s[i]=='1'?1:-1);
    }
    mp[0]=0;
    int ans=0;
    for(int i=1;i<=n;i++) {
        if(mp.find(sum[i])!=mp.end()) {
            ans=max(ans,i-mp[sum[i]]);
        } else mp[sum[i]]=i;
    }
    printf("%d %d\n",ans,min(one,zero)*2);
    return 0;
}

D：Big Integer

题意：

$A\left(i^j\right)$表示$i^j$个$1$，求$A\left(i^j\right)\equiv0mod\ p$有多少对 

• $1\leq\ i\leq\ n$
• $1\leq\ j\leq\ m$
• $p$为质数

思路：

$1111$可写为$\frac{{10}^n-1}9$，则可以转化为

$$\frac{{10}^n-1}9\equiv0mod\ p$$

$$\left({10}^n-1\right)\ast\ inv\left(9\right)\equiv0mod\ p$$

若$p=2或5$，明显答案为$0$，

若$p$与$9$互质，$inv\left(9\right)\neq0$，

所以 $${10}^n-1\equiv0mod\ p$$ 

即   $${10}^n\equiv1mod\ p$$

由欧拉定理得$\varphi\left(p\right)$必定满足，但不一定是最小的。

所以我们可以求得最小循环节$x$，复杂度$O\left(\sqrt{p}log\ p\right)$

转化为有多少对$x\mid{i^j}$

考虑固定$j$

对$x$进行质因数分解，

$x=p_1^{ax_1}\ast\ p_2^{ax_2}\ast\ldots\ast\ p_k^{ax_k}$

那么$i$的每种质因子的个数至少有$\lceil\frac{ax}j\rceil$

令$g=p_1^{\lceil\frac{ax_1}j\rceil}\ast\ p_2^{\lceil\frac{ax_2}j\rceil}\ast\ldots\ast\ p_k^{\lceil\frac{ax_k}j\rceil}$，$g\mid\ i$

在$n$的范围内有$\lceil\frac{n}g\rceil$个。

$g$随着$j$的改变而改变。

令$mx=max\left(ax_1,ax_2,\ldots\,ax_k\right)$，若$j\geq\ mx$，对后面的$j$，影响不会改变。有$\left(m-j\right)\ast\lceil\frac{n}g\rceil$个。

考虑$p=3$与$9$不互质，根据整除$3$的性质，有$n\setminus3\ast\ m$个，（数字之和为$3$的倍数）

//#define DEBUG
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
const int inf=0X3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = acos(-1.0);
//const int mod = 1000000007;
typedef long long ll;
 
int q_pow(int a,int b,int p) {
    int tmp=a%p;
    int ans=1;
    while(b) {
        if(b&1) ans=1ll*ans*tmp%p;
        tmp=1ll*tmp*tmp%p;
        b=b>>1;
    }
    return ans;
}
 
int main() {
    #ifdef DEBUG
    freopen("in.txt","r",stdin);
    #endif
    int _,p,n,m;
    for(scanf("%d",&_);_;_--) {
        scanf("%d%d%d",&p,&n,&m);
        if(p==2||p==5) {
            puts("0");
            continue;
        }
        if(p==3) {
            printf("%lld\n",1ll*n/3*m);
            continue;
        }
        int D=p-1,x=D;
        for(int i=1;i*i<=D;i++) {
            if(D%i) continue;
            if(q_pow(10,i,p)==1) x=min(x,i);
            if(q_pow(10,D/i,p)==1) x=min(x,D/i);
        }
        vector<pair<int,int>> factor;
        int maxx=-1;
        for(int i=2;i*i<=x;i++) {
            if(x%i==0) {
                int cnt=0;
                while(x%i==0) {
                    cnt++;
                    x/=i;
                }
                maxx=max(maxx,cnt);
                factor.push_back({i,cnt});
            }
        }
        if(x>1) factor.push_back({x,1});
       // puts("***");
        ll ans=0;
        for(int j=1;j<=m;j++) {
            ll g=1;
            for(auto it:factor) {
                int t=(it.second+j-1)/j;
                while(t--) {
                    g=g*(it.first);
                }
            }
            ans+=n/g;
            if(j>=maxx) {
                ans+=(m-j)*(n/g);
                break;
            }
        }
        printf("%lld\n",ans);
    }
}

F：Planting Trees

题意：

给出$n\times\ n$的矩阵，和一个$m$，求最大的子矩阵，要求子矩阵的最大值和最小值差值小于等于$m$。

思路：

枚举上下边界，然后单调队列处理左右边界。

把每一列的最大值、最小值记下来，然后用单调队列维护，如果差值大于$m$就往右移动。

//#define DEBUG
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
const int inf=0X3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int mod = 1000000007;
typedef long long ll;

int a[610][610];
int b1[610],b2[610];
int q1[610],q2[610],l1,l2,r1,r2;

int main() {
    #ifdef DEBUG
    freopen("in.txt","r",stdin);
    #endif
    int _;
    for(scanf("%d",&_);_;_--) {
        int n,m,ans=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=n;j++)
                scanf("%d",&a[i][j]);
        }
        for(int i=1;i<=n;i++) {//上界
            for(int j=1;j<=n;j++) b1[j]=b2[j]=a[i][j]; //初始化
            for(int j=i;j<=n;j++) {// 下界
                for(int k=1;k<=n;k++) b1[k]=min(b1[k],a[j][k]),b2[k]=max(b2[k],a[j][k]); //维护
                l1=l2=1;r1=r2=0;
                if((j-i+1)*n<=ans) continue; //剪枝
                for(int w=1,k=1;k<=n;k++) {//左右边界
                    while(l1<=r1&&b1[q1[r1]]>=b1[k]) --r1; //单调增
                    q1[++r1]=k;
                    while(l2<=r2&&b2[q2[r2]]<=b2[k]) --r2; //单调减
                    q2[++r2]=k;
                    while(w<=k&&b2[q2[l2]]-b1[q1[l1]]>m) {
                        w++;
                        while(l1<=r1&&q1[l1]<w) ++l1;
                        while(l2<=r2&&q2[l2]<w) ++l2;
                    }
                    if((j-i+1)*(n-w+1)<=ans) break;
                    if(w<=k) ans=max(ans,(j-i+1)*(k-w+1));
                }
            }
        }
        printf("%d\n",ans);
    }
}

G：Removing Stones

题意：

给出$n$堆石子，每次可以选非空且不同的两堆，然后各取一个石子，此操作可以进行任意次，很明显只要数量为偶数，Mark必定可以完成，现在问你有多少个区间$\left(l,r\right)$，Mark可以完成。

思路：

很明显题目可以转化为求多少个这样的区间$\left(l,r\right)$：

$$max_{l\leq\ i\leq\ r}\ \leq\ \sum_{i=l}^ra_i$$

可以用$RMQ$查询最大值，前缀和查询区间和，考虑计数，可以分治。

每次在小区间枚举一个端点，在大区间二分另一个端点

比如左边区间小，就在右边二分找另一个端点。

记最值下标为$k$，则需满足$2\ast\ a[k]\leq\ sum[r]-sum[l-1]$

枚举左边，所以$sum[r]\geq\ 2\ast\ a[k]+sum[l-1]$，找第一个大于$2\ast\ a[k]+sum[l-1]$的位置

若右边区间小，同理。

//#define DEBUG
#include<bits/stdc++.h>
using namespace std;
const int N=300010;
const int inf=0X3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int mod = 1000000007;
typedef long long ll;

ll sum[N],ans;
int n,lg[N],a[N],dp[N][20];

void rmq() {
    lg[0]=-1;
    for(int i=1;i<=n;i++) {
        lg[i]=(i&(i-1))?lg[i-1]:lg[i-1]+1;
        dp[i][0]=i;
    }
    for(int j=1;j<=lg[n];j++) {
        for(int i=1;i+(1<<j)-1<=n;i++)
            dp[i][j]=a[dp[i][j-1]]>a[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
}

int query(int l,int r) {
    int k=lg[r-l+1];
    return (a[dp[l][k]]>a[dp[r-(1<<k)+1][k]])?dp[l][k]:dp[r-(1<<k)+1][k];
}


int bs1(int l,int r,ll v) {
    if(sum[r]<v) return r+1;
    int res=-1,mid;
    while(l<=r) {
        mid=(l+r)>>1;
        if(sum[mid]>=v) {
            res=mid;
            r=mid-1;
        } else l=mid+1;
    }
    return res;
}

int bs2(int l,int r,ll v) {
    if(sum[l-1]>v) return l-1;
    int res=-1,mid;
    while(l<=r) {
        mid=(l+r)>>1;
        if(sum[mid-1]<=v) {
            res=mid;
            l=mid+1;
        } else r=mid-1;
    }
    return res;
}

void work(int l,int r) {
    if(r-l+1<=1) return ;
    if(r-l+1==2) {
        if(a[l]==a[r]) ans++;
        return;
    }
    int k=query(l,r);
    if(k-l<r-k) {
        for(int i=l;i<=k;i++) {
            int j=bs1(k,r,2ll*a[k]+sum[i-1]);
            ans+=(r-j+1);
        }
    } else {
        for(int i=k;i<=r;i++) {
            int j=bs2(l,k,sum[i]-2ll*a[k]);
            ans+=(j-l+1);
        }
    }
    work(l,k-1);
    work(k+1,r);
}


int main() {
    #ifdef DEBUG
    freopen("in.txt","r",stdin);
    #endif
    int _;
    for(scanf("%d",&_);_;_--) {
        scanf("%d",&n);
        sum[0]=0;
        for(int i=1;i<=n;i++) {
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
        }
        rmq();
        ans=0;
        work(1,n);
        printf("%lld\n",ans);
    }
}

H：Magic Line

题意：

给出平面上$n$个点，要画一条直线，把这些点划分为数量相等的两部分。

思路：

对$x,y$双关键字排序，然后取中间(偏左)的那个点，然后稍微偏一点即可。(两个纵坐标加的数不要互为相反数，***钻一点)

#include<bits/stdc++.h>
using namespace std;
const int maxn=10010;

int _,n;
struct Point{
    int x,y;
    bool operator < (const Point &b)const {
        return x<b.x||(x==b.x&&y<b.y);
    }
}p[maxn];

int main() {
    for(scanf("%d",&_);_;_--) {
        scanf("%d",&n);
        for(int i=1;i<=n;i++) {
            scanf("%d%d",&p[i].x,&p[i].y);
        }
        sort(p+1,p+n+1);
        printf("%d %d %d %d\n",p[n/2].x-1,p[n/2].y+99999999+1,p[n/2].x+1,p[n/2].y-99999999);
    }
}

J：LRU management

题意：

给出一个容器，最多放$m$块，然后一些列操作，

$opt=1$，不改变序列，

如果能找到，根据v的值，输出它前后或者本身的$data$。

$opt=0$，改变序列，

如果能找到，输出它的$data$，并把它移动到末尾，

如果找不到，输出$v$值，并把它加入末尾。

如果某一步大于容器大小，就把第一个移出。

思路：

数组模拟双向链表+$trie$树映射 或 $unorderedmap+list$ 具体见题解代码

（数组模拟就是爽）

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;

int trie[N*10][10],pointer[N*10];
int pos[N*10],tot;

int L[N],R[N],data[N];
int st,ed,size;

void Insert(int x,int v) {
    data[x]=v;
    if(!st) st=ed=x;
    else L[R[ed]=x]=ed,ed=x;
    ++size;
}

void Erase(int x) {
    int pre=L[x],bak=R[x];
    if(pre) R[pre]=bak;
    if(bak) L[bak]=pre;
    data[x]=L[x]=R[x]=0;
    if(st==x) st=bak;
    if(ed==x) ed=pre;
    --size;
}

void trieInsert(char* s,int it) {
    int p=1;
    for(int i=0;s[i];i++) {
        int &t=trie[p][s[i]-'0'];
        if(!t) pos[t=++tot]=0;p=t;
    }
    pos[pointer[it]=p]=it;
}

int trieFind(char *s) {
    int p=1;
    for(int i=0;s[i]&&p;i++) {
        int t=trie[p][s[i]-'0'];
        p=t;
    }
    return pos[p];
}


int main() {
    int _;
    for(scanf("%d",&_);_;_--) {
        int q,m;
        scanf("%d%d",&q,&m);
        pointer[tot=1]=0;
        st=ed=size=0;
        int number=0;
        while(q--) {
            int opt,v;char s[12];
            scanf("%d%s%d",&opt,s,&v);
            int it=trieFind(s);
            if(opt==1) {
                if(it==0||L[it]==0&&v==-1||R[it]==0&&v==1)
                    puts("Invalid");
                else {
                    if(v==-1) it=L[it];
                    if(v==1) it=R[it];
                    printf("%d\n",data[it]);
                }
            } else {
                if(it) {
                    v=data[it];
                    Erase(it);
                } else if(size==m){
                    pos[pointer[st]]=0;
                    Erase(st);
                }
                Insert(++number,v);
                trieInsert(s,number);
                printf("%d\n",v);
            }
        }
        for(int i=1;i<=tot;i++) {
            for(int k=0;k<10;k++) trie[i][k]=0;
            pos[i]=0;
        }
        while(st) Erase(st);
    }
    return 0;
}

 $unorderedmap+list$

学到了$map$里放迭代器，用$decltype(list)::iterator$，以及$prev和next$

//#define DEBUG
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
const int inf=0X3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int mod = 1000000007;
typedef long long ll;
 
int main() {
    #ifdef DEBUG
    freopen("in.txt","r",stdin);
    #endif
    int _;
    for(scanf("%d",&_);_;_--) {
        list<pair<ll,ll>> list;
        unordered_map<ll,decltype(list)::iterator> map;
        int q,m;
        scanf("%d%d",&q,&m);
        while(q--) {
            int opt;
            ll v;
            char s[15];
            scanf("%d%s%lld",&opt,s,&v);
            ll id;
            sscanf(s,"%lld",&id);
            id+=1ll*10000000000*strlen(s)+id;
            if(opt==0) {
                auto it=map.find(id);
                if(it!=map.end()) {
                    auto p=map[id];
                    v=p->second;
                    //map.erase(p->first);
                    list.erase(p);
                }
                list.push_back({id,v});
                map[id]=prev(list.end());
                if(list.size()>m) {
                    auto p=list.begin();
                    map.erase(p->first);
                    list.pop_front();
                }
                printf("%lld\n",v);
            } else {
                bool ok=true;
                auto it=map.find(id);
                if(it==map.end()) ok=false;
                else {
                    auto p=map[id];
                    if(v==-1) {
                        if(p==list.begin()) ok=false;
                        else printf("%lld\n",prev(p)->second);
                    } else if(v==1) {
                        if(next(p)==list.end()) ok=false;
                        else printf("%lld\n",next(p)->second);
                    } else printf("%lld\n",p->second);
                }
                if(!ok) puts("Invalid");
            }
        }
    }
}