传送门
\(A\)
咕咕
const int N=1005;
char s[N];int val[N],n;
int main(){
scanf("%s",s+1),n=strlen(s+1);
fp(i,1,n)++val[s[i]];
if((val['W']!=0)^(val['E']!=0))return puts("No"),0;
if((val['S']!=0)^(val['N']!=0))return puts("No"),0;
return puts("Yes"),0;
}\(B\)
不难发现每个数能和自己匹配就和自己匹配，最多只会和左边右边分别匹配一次，那么我们记\(f_{i,0/1}\)表示考虑\(i\)，且\(i\)留下了\(0/1\)个的方案数，从左往右\(dp\)即可
typedef long long ll;
const int N=1e5+5;const ll inf=1e18;
int a[N],k,n;ll f[N][2],res;
int main(){
scanf("%d",&n);
fp(i,1,n)scanf("%d",&a[i]);
memset(f,0xef,sizeof(f));
f[0][0]=0;
fp(i,1,n){
if(!a[i])f[i][0]=max(f[i-1][0],f[i-1][1]);
else{
f[i][0]=max(f[i-1][0]+(a[i]>>1),max(f[i-1][1]+(a[i]>>1),f[i-1][1]+((a[i]-1)>>1)+1));
f[i][1]=max(f[i-1][0]+((a[i]-1)>>1),max(f[i-1][1]+((a[i]-1)>>1),a[i]>=2?f[i-1][1]+((a[i]-2)>>1)+1:-inf));
}
}
printf("%lld\n",max(f[n][0],f[n][1]));
return 0;
}\(C\)
重新标号之后发现一直进行操作\(2\)的话奇数位上的只能一直在奇数位上，那么一个偶数要到奇数位上至少需要经过一次\(1\)操作，把所有偶数在奇数位上和奇数在偶数位上的个数分别记下来，两个取较大值就是答案了
const int N=1e5+5;
int b[N],d[N],st[N],c[2],n;
int main(){
// freopen("testdata.in","r",stdin);
scanf("%d",&n);
fp(i,1,n)scanf("%d",&b[i]),d[i]=b[i];
sort(d+1,d+1+n);
fp(i,1,n)st[i]=lower_bound(d+1,d+1+n,b[i])-d,c[st[i]&1]+=((st[i]&1)^(i&1));
printf("%d\n",max(c[0],c[1]));
return 0;
}\(D\)
先把每个数所有的三次因子除掉，这样之后两个相等的数就在同一个等价类，除了\(1\)要特判之外，其它每个数对应的不能选的数是唯一的，在分解质因子的过程中能顺便把它给算出来，然后两边取较大值加入就可以了
分解质因子的时候如果枚举到\(10^5\)显然会炸，那么我们是枚举到\(3000\)次左右，那么剩下的数要么是一个质数要么是一个质数的平方，分类讨论一下即可
//quming
#include
#define R register
#define fi first
#define se second
#define fp(i,a,b) for(R int i=(a),I=(b)+1;iI;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
templateinline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
templateinline bool cmax(T&a,const T&b){return avis;int p[N],m;
void init(int n=3000){
fp(i,2,n){
if(!vis[i])p[++m]=i;
for(R int j=1;j<=m&&1ll*i*p[j]<=n;++j){
vis[i*p[j]]=1;
if(i%p[j]==0)break;
}
}
}
const int M=1e5+5;
ll a[M];int n,res;
mapmp;
typedef map::iterator IT;
int main(){
// freopen("testdata.in","r",stdin);
init();
scanf("%d",&n);
R ll tmp;
fp(i,1,n){
scanf("%lld",&a[i]);
for(R int j=1;j<=m&&1ll*p[j]*p[j]*p[j]<=a[i];++j){
tmp=1ll*p[j]*p[j]*p[j];
while(a[i]%tmp==0)a[i]/=tmp;
}
++mp[a[i]];
}
for(IT it=mp.begin();it!=mp.end();++it){
if(it->fi==1)continue;
R ll x=it->fi,y=1;
fp(j,1,m)if(x%p[j]==0){
R int c=0;
while(x%p[j]==0)x/=p[j],++c;
(c&1)?(y*=p[j]*p[j]):(y*=p[j]);
}
if(x!=1){
tmp=sqrt(x);
tmp*tmp==x?(y*=tmp):(y*=x*x);
}
if(!mp.count(y)||it->fise,mp.count(y)?mp[y]:0);
}
if(mp[1])++res;
printf("%d\n",res);
return 0;
} \(E\)
首先对于一个\(q_i\)，如果它后面有一个小于等于它的数那么它就没有用了，所以先用单调栈把\(q_i\)变成递增的（包括一开始的\(n\)）
然后考虑暴力，对于一个\(q_i\)到\(q_{i+1}\)，相当于是把\(q_i\)复制若干遍之后再加上\(q_i\)的一个前缀形成了\(q_{i+1}\)，那么我们从后往前做，记\(cnt_{i}\)表示\(q_i\)被重复的次数，以及一个栈\(tmp\)代表后面所有的多出来的前缀，那么对于\(i\)，它的\(cnt\)就等于原来的重复次数乘上\(cnt_{i+1}\)，以及对于之前的每一个多余的前缀\(tmp_{j}\)，加上一个\(tmp_{j}/q_{i}*tc_{j}\)（其中\(tc_{j}\)表示\(j\)这个前缀被重复的次数），然后\(tmp_j\)变成\(tmp_j\%q_i\)，这样就可以算出\(cnt_i\)了，而它多出来的前缀就是\(q_{i}\%q_{i-1}\)，且这个前缀的重复次数就是\(cnt_{i}\)
然而这样暴力的话是\(O(n^2)\)的，考虑优化，对于一个前缀，它会给前面的\(cnt_{i}\)造成贡献当且仅当\(q_i\leq tmp_j\)，也就是说取模之后\(tmp_j\)会变小。那么对于一个前缀，我们可以二分找到它左边第一个小于等于它的位置，然后给那个位置加上对应的贡献，之后一直找就行了。因为一个数有效的取模次数不超过\(O(\log n)\)，所以总复杂度为\(O(n\log n\log q_i)\)
//quming
#include
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;iI;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
templateinline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
templateinline bool cmax(T&a,const T&b){return a=st[1]){
k=lower_bound(st+1,st+1+pos,x+1)-st-1;
s[k]+=x/st[k]*p,x%=st[k],pos=k-1;
}
a[x]+=p;
}
int main(){
// freopen("testdata.in","r",stdin);
scanf("%d%d",&n,&m),top=0;
st[++top]=n;
fp(i,1,m){
scanf("%lld",&x);
while(top&&x<=st[top])--top;
st[++top]=x;
}
fp(i,1,top-1)cnt[i]=st[i+1]/st[i];
cnt[top]=cnt[top+1]=1;
fd(i,top,2)cnt[i]=cnt[i]*cnt[i+1]+s[i],ins(st[i]%st[i-1],cnt[i],i-1);
cnt[1]=cnt[1]*cnt[2]+s[1];
fd(i,n,1)a[i]+=a[i+1];
fp(i,1,n)printf("%lld\n",(i<=st[1]?cnt[1]+a[i]:0));
return 0;
} \(F\)
先判断这个网格左右拼接和上下拼接是否会导致联通块个数的减少，分别记为\(flag1\)和\(flag2\)，并且为了方便起见我们默认初始图形为给出的网格（也就是事实上的\(1\)阶分形）为\(0\)阶分形
如果两个都不成立，证明每次分形都不会减少联通块，记网格中总的黑点个数为\(sz\)，那么\(k\)次分形之后会使联通块个数变为\(sz^k\)
如果两个都成立，因为黑点四联通，所以每次分形之后联通块个数都不会减少，最后答案为\(1\)
剩下两种情况中，不失一般性，假设左右拼接会导致联通块个数减少而上下不会，记\((i,j)\)和\((i,j+1)\)同时为黑点的数量为\(p\)，以及\((i,1)\)和\((i,m)\)同时为黑点的数量为\(q\)
假设\(k\)次分形之后联通块个数为\(ans\)，那么第\(k+1\)次分形后，联通块个数会变为\(ans\times sz-p\times q^{k-1}\)（这个柿子可以画个图理解）
那么就好办了，一开始答案是\(1\)，把柿子全部展开变成形如\(((1\times sz-p\times q^{0})\times sz -p\times q^{1})...\)，变成\(sz^k-p\times \sum_{i=0}^{k-1}q^{i}sz^{k-1-i}\)，把后面那个当成一个等比数列求和就行了
//quming
#include
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;iI;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
templateinline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
templateinline bool cmax(T&a,const T&b){return a=P?x-=P:0;}
inline int add(R int x,R int y){return x+y>=P?x+y-P:x+y;}
inline int dec(R int x,R int y){return x-y<0?x-y+P:x-y;}
inline int mul(R int x,R int y){return 1ll*x*y-1ll*x*y/P*P;}
int ksm(R int x,R ll y){
R int res=1;
for(;y;y>>=1,x=mul(x,x))(y&1)?res=mul(res,x):0;
return res;
}
int kkk(R int x,R ll y){
R int res=1,d=1;
for(;y;y>>=1,d=mul(x+1,d),x=mul(x,x))(y&1)?res=add(mul(res,x),d):0;
return res;
}
const int N=1005;
char mp[N][N],t[N][N];int n,m,sz,p,ss,res;ll k;
inline int ck1(){R int res=0;fp(i,1,n)res+=(mp[i][1]=='#'&&mp[i][m]=='#');return res;}
inline int ck2(){R int res=0;fp(j,1,m)res+=(mp[1][j]=='#'&&mp[n][j]=='#');return res;}
int main(){
scanf("%d%d%lld",&n,&m,&k);
if(k<=1)return puts("1"),0;
--k;
fp(i,1,n)scanf("%s",mp[i]+1);
fp(i,1,n)fp(j,1,m)sz+=mp[i][j]=='#';
int sz1=ck1(),sz2=ck2();
if(sz1&&sz2)return puts("1"),0;
if(!sz1&&!sz2)return printf("%d\n",ksm(sz,k)),0;
if(sz2){
fp(i,1,n)fp(j,1,m)t[j][i]=mp[i][j];
swap(n,m);
fp(i,1,n)fp(j,1,m)mp[i][j]=t[i][j];
swap(sz1,sz2);
}
fp(i,1,n)fp(j,1,m-1)ss+=(mp[i][j]=='#'&&mp[i][j+1]=='#');
// printf("%d %d %d\n",sz,ss,sz1);
res=mul(ksm(sz,k-1),kkk(mul(sz1,ksm(sz,P-2)),k-1));
res=dec(ksm(sz,k),mul(ss,res));
printf("%d\n",res);
return 0;
}