A. Cherry
B. Cobb
C. Mikasa
D. Diane
E. You
A. Cherry
分析:
这道题需要求出在整个数组范围内,某一区间内的最大值乘于最小值所得的值的最大值。我们记录某一区间内的最大值乘于最小值所得的值的最大值为rmq;假设我们考虑三个相邻的的数 a[i] 和 a[i+1]和a[i+2](此时所考虑的区间为[i,i+2]),计算出该区间的rmq为ans。我们将区间分解为两个区间[i,i+1]和[i+1,i+2],区间1的rmq为r1,区间2的rmq为r2;那么ans和r1与r2之间又有什么关系呢?显然ans==max(r1,r2).为什么呢?由于涉及三个数的大小关系,所以有6种可能(我们记a[i]=a, a[i+1]=b, a[i+2]=c):
- a最大,b中间,c最小: ans==a*b;
- a最大,b最小,c中间:ans==a*b
- a中间,b最大,c最小:ans==a*b;
- a中间,b最小,c最大:ans==b*c;
- a最小,b中间,c最大:ans==b*c;
- a最小,b最大,c中间:ans==b*c;
由此可知,区间最大值rmq一定在相邻两个数之间取到,所以只需要遍历一遍数组,求出所有的相邻数乘积比较出最大值即可。
效率:时间复杂度为O(n).
注意:要用long long毕竟1e6 * 1e6超出int范围.
AC代码:
#include<iostream>
using namespace std;
const int N=2e5+5;
int main(){
int t;
cin>>t;
while(t--){
long long int ans=0;
int n;
int a[N];
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=2;i<=n;i++)
if((1LL*a[i]*a[i-1])>ans) ans=1LL*a[i]*a[i-1];
cout<<ans<<endl;
}
return 0;
}
B. Cobb
分析:
仔细观察k的范围,会发现k<=100;又显然1<=ai<=n,所以 ai | aj <=2 * n。i * j最大可达到n^2,而k*(ai | aj)最大也就是200 * n;显然,当n在一定大的时候,200*n所起的作用并不是很大,只需要在n一定大的时候遍历所有的n即可。那这个一定大的范围应该在哪里呢?我们记函数f( i , j )=i * j-k * (ai | aj).则f(n-1,n)=n * n-2 * k * n-n。我们需要找到可能的最小的i,使f(i, j)>f(n-1,n).假设ai=an=0,那么f(i,n)=i * n(此时i一定是最小的,因为被减数k * (ai | aj)为0,j为最大值n)。那么令 i * n>n * n-2 * k * n-n;
则i>n-2 * k-1。所以我们只需要从max(1,n-2 * k)开始遍历i即可得到答案。
效率:时间复杂度为O(k^2).
AC代码:
#include<bits/stdc++.h>
using namespace std;
const long long INF=1e12;
const int maxn=2e5+10;
int n,k,a[maxn];
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
inline long long f(int i,int j){
return 1LL*i*j-1LL*k*(a[i]|a[j]);
}
int main(){
int t;t=read();
while(t--){
memset(a,0,sizeof(a));
n=read(),k=read();
for(int i=1;i<=n;i++) a[i]=read();
long long ans=-INF;
int i,j;
i=max(1,n-2*k);
for(;i<=n;i++)
for(j=i+1;j<=n;j++)
ans=max(ans,f(i,j));
printf("%lld\n",ans);
}
return 0;
}
C. Mikasa
分析:
由于t<=30000,m<=1e9;显然直接暴力肯定会超时,这时候我们需要仔细想想一定要遍历每一个数吗?显然不需要,在想到好方法之前,大家得知道一件事:n^x=k,则n ^ k=x( ^为异或)。该题需要我们找到最小的非负整数ans,ans在n ^x(x属于0~ m)中没有出现。也就是让我们找到一个最小的k,使n ^ k>m;因为当n^k<=m(记住k==n ^ x)的时候,在n ^x的时候该k都已经出现过。所以我们可以通过比较n与m+1的二进制每一位数来得到最小的满足条件的k,也就是答案ans。那么应该怎样比较呢?首先先理解我们需要比较的公式 n^ k>=m,也就是n与最小的k异或的结果大于等于m+1。 那么我们可以从二进制最高位向最低位开始遍历每一位数字。首先要知道2的30次方刚好大于1e9,是满足条件的。所以我们从i=30开始遍历到i=0,然后比较n与m+1的第i+1位二进制数(因为i=0时,是第一位二进制数);比较情况有以下三种情况:假设n的第i+1位二进制为a,m+1的第i+1位二进制数是b。(a,b只能等于0或1)
- a==b:此时这两位的二进制数相等,为了让k最小,我们让k的第i+1位二进制数为0。因为如果a=b=1,a^0=1=b;否则a=b=0;a ^ 0=0=b。
- a=0,b=1:此时为了让n ^k >=m+1;n ^k的高位二进制应该大于等于m+1的该位。所以k的该位二进制只能等于1。这样a ^1=b。
- a=1,b=0:此时k的该位二进制可为0也可为1,(因为a ^1(或0)>=b)但由于是从高位开始遍历的,所以为了让k最小,只能让k=0。此时我们可以很清晰的发现,n ^ k在该位之前的所有二进制数都是相等的,而该位是n ^k=1>=m+1=0,由于这是高位,此时无论接下来的二进制是啥,n ^k都一定大于等于m+1。所以可以跳出循环了,并且让之后的k的二进制数全为0即为k的最小值。
效率:时间复杂度为O(1). 是不是很不可思议!!!
注意:求二进制的每一位数字应该用(x>>i)&1而不只是n>>i。因为n>>i所求的值是i+1位及之前所有二进制数字的值总和。用(x>>i)&1可以只判断这一位是0还是1.
AC代码:
#include<bits/stdc++.h>
using namespace std;
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
int main(){
int t=read();
while(t--){
int n=read(),m=read();
if(m<n) {
printf("0\n");
continue;
}
++m;
int ans=0;
for(int i=30;i>=0;i--){ //二进制从高位开始处理
if((n>>i&1)==(m>>i&1)) continue;
else if(!(n>>i&1)&&(m>>i&1)) ans+=(1<<i);
else break;
}
printf("%d\n",ans);
}
return 0;
}
D. Diane
分析:
这显然是一道找规律然后构造字符串的题。那么找规律就变成了关键也是难点。接下来我们就来看看通过题意能发现什么规律啊!我们需要让所有可能出现的相同子串出现次数为奇数,那么我们想想什么情况下子串出现次数为奇数呢?首先由于需要我们自己去构造字符串,所以尽量让构造的字符串简单,用的字母少肯定越好。我们假设字符串pp全是字母a,若字符串长度为k,则f(a)=k; f(aa)=k-1; f(aaa)=k-2; … (f(i)表示字符串中出现子串i的次数); 假设字符串qq全是字母a且字符串长度为k-1,则f(a)=k-1; f(aa)=k-2; f(aaa)=k-3…;那么对于pp+qq这个长串来说,假设每一个子串(a,aa,aaa或aaaa等等)其在串pp中出现次数都为x,那么在qq中都为x-1;因为x+x-1=2*x-1;一定为奇数。 所以规律便已经找到了。
我们只需要把每一个长度为n的字符串分为三部分,左边长为k=n/2,全是字母a,右边长为k-1=n/2-1,全是字母a;中间长为len=n-2*k+1。那么n为奇数时,len=2;只需要补bc即可;n为偶数时,len=1;只需要补b即可。
效率:时间复杂度为O(n).
注意:n=1时单独判断输出任意一个字母即可;否则会把n为奇数看待补上bc就超出n范围了.
AC代码如下:
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;cin>>t;
while(t--){
int n;cin>>n;
int l=n/2,r=l-1;
if(n==1) cout<<"a";
else if(n&1){
for(int i=1;i<=l;i++) cout<<"a";
cout<<"bc";
for(int i=1;i<=r;i++) cout<<"a";
}
else{
for(int i=1;i<=l;i++) cout<<"a";
cout<<"b";
for(int i=1;i<=r;i++) cout<<"a";
}
cout<<endl;
}
return 0;
}
E. You
分析:
蒻蒻一看这是一道2600分的题就已经被吓到了!!!不过在蒻蒻集许多大佬的思想集一身时,终于拨开云雾见光明了。首先用邻接表存树的无向边,应该是很基本的操作了。该题要求从1~n的每一个值k在gcd(a1,a2,…,an)=k时出现的次数,也就是不同的序列次数。那么我们就需要找点规律了,不然无从下手。我们可以开一个ans[maxn]数组,ans[i]记录gcd(a1,a2,…,an)是i的倍数的出现次数。为啥这样做呢?看完接下来的解析你就会明白了。我们可以发现这棵树有n-1条边,每条边连着两个结点u,v;那么分权有两种情况:如果先删除结点u,那么分权a[u]+1;否则就是a[v]+1;所以不难发现,每条边有两种情况,所以总情况次数为2^(n-1)。又因为1肯定是任意整数的因子(注意:gcd(0,x)=x);所以ans[1]=2^(n-1)。
对于其他的k>1;那么又是什么情况呢?
仔细观察,对于每一个分权序列a1,a2,…,an来说,由于只有n-1条边对分权有贡献,且每条边贡献为1,所以a1+a2+…+an=n-1;那么k>1的时候,只有当所有的ai(i=1,2,…,n)都能整除k的时候,k才是a1,a2,…,an的公因数(暂且不讨论是否是最大公因数)。所以所有的ai都能整除k,也就是a1+a2+…+an都能整除k;于是此时n-1便也能整除k。接下来就有两种情况:
- (n-1)%k!=0 :此时必定有不能整除k的ai;所以gcd(a1,a2,…,an)不可能等于k的倍数,即ans[k]==0。
- (n-1)%k==0 :此时就需要进行判断。判断是否每一个ai都是k的倍数,由于他们的和是k的倍数,但每一个ai却也不一定都是k的倍数。 此时可以用dfs深搜,从结点1开始搜索这棵树的所有结点,并先全部搜到树的叶节点之后再一步步回溯判断。判断也有多种情况:
一:对于叶节点v(父亲为u)的边来说,它的分权一定是赋给了点u;若是赋给了点v,那么就是先删除点v再删除点u;此时a[v]=1;那么a[v]就不能是k(k>1)的倍数。
二:对于非叶结点v(父亲为u)的边来说: 若此时a[v]%k = =0 ,也就是此时结点v的分权已经是k的倍数了,那么该条边的分权必然是给结点u;也就是先删除结点u再删除结点v;若此时a[v]%k != 0,那么该条边的分权必然是给结点v,也就是先删除结点v再删除节点u;但如果现在a[v]%k !=0的话;也就是结点v的分权不可能等于k的倍数,那么就可以跳出深搜了,并且ans[k]=0;否则a[v]%k == 0的话,就继续深搜下去,直到所有的结点都满足a[i]%k==0;此时ans[k]=1。思考一下,为什么此时ans[k] = =1呢?其实原理很简单,回过头看深搜的回溯过程,你会发现在以上的分析过后,每一条边的分权其实都是固定给了某个点,而不出现选择的情况。也就是每个点的分权都是固定的,即删除所有结点的次序是固定的,所以删除次序唯一,所以ans[k]=1。现在ans[maxn]数组已经处理完了,就只剩下最后一件事了,那就是找答案。我们可以发现对于k=2和k=4来说,若gcd(a1,a2,…,an)==4的话,那么它对k=2;也有贡献,也就是对于一个数k来说,ans[k]对所有k的因子都有贡献,所以k的因子就需要减掉k的贡献。我们可以逆序用i遍历n~1;找到所有的它的倍数j(j=2i,3i,…,一直到j<=n),然后ans[i]-ans[j]即可。最后的ans数组就记录了我们需要的答案。
效率:时间复杂度为O(nlogn+n*f(n-1)). f(n-1)为n-1的因子个数。 在创建ans[]数组时的判断和dfs需要O(n*f(n-1));在最后找答案的过程需要O(nlogn)。
AC代码如下:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=998244353;
const int maxn=2e5+10;
int n,ans[maxn],dp[maxn];
int flag;
vector<int>g[maxn];
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
void Init(){
for(int i=1;i<=n;i++) dp[i]=ans[i]=0,g[i].clear();
}
int quick_power(ll base,int power){
ll res=1;
while(power){
if(power&1) res=(res*base)%mod;
power>>=1;
base=(base*base)%mod;
}
res%=mod;
return (int)res;
}
void dfs(int u,int fa,int k){
for(int i=0;i<g[u].size();i++){
if(!flag) return ;
int v=g[u][i];
if(v==fa) continue;
dfs(v,u,k);
if(dp[v]%k){
dp[v]++;
if(dp[v]%k) flag=0;
}
else dp[u]++;
}
}
int main(){
int t=read();
while(t--){
n=read();
Init();
for(int i=1;i<n;i++){
int u=read(),v=read();
g[u].push_back(v);
g[v].push_back(u);
}
ans[1]=quick_power(2,n-1);
for(int i=2;i<=n;i++){
if((n-1)%i!=0) continue;
flag=1;
dfs(1,0,i);
ans[i]=flag;
memset(dp,0,sizeof(dp));
}
for(int i=n;i>=1;i--){
if((n-1)%i!=0) continue;
for(int j=2*i;j<=n;j+=i) ans[i]=(ans[i]-ans[j]+mod)%mod;
}
for(int i=1;i<=n;i++) printf("%d ",ans[i]);
printf("\n");
}
return 0;
}