学长FallDream所出的模拟赛，个人感觉题目难度还是比较适中的，难度在提高+左右，可能比较接近弱省省选，总体来讲试题考查范围较广，个人认为还是很不错的。
所有试题如无特殊声明，开启-O2优化，时限1s，内存上限为128MB
T1(seq)小Z爱序列
题意简析
给出一个1~n的全排列，问有多少对\((i,j)\)满足\(a_{i}<max( a_{[i+1,j-1]} ) < a_{j}\)
数据范围及约定
\(1<=n<=10^6\)
解题思路
通过观察，我们可以发现，答案在从右向左更新时，在某处的贡献为其右侧大于其的数的数量，故考虑使用单调栈维护右侧数单调性，每次先入队再计算贡献即可。
总复杂度为\(O(n) / O(n)\)
#include <stdio.h>
#define MN 1000005
#define r register
#define getchar() (S==TT&&(TT=(S=BB)+fread(BB,1,1<<15,stdin),TT==S)?EOF:*S++)
char BB[1<<15],*S=BB,*TT=BB;
inline int in(){
r int x; r bool f; r char c;
for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-');
for (x=c-'0'; (c=getchar())>='0'&&c<='9'; x=(x<<3)+(x<<1)+c-'0');
return f?-x:x;
}
int n,ma,x,pos=1,a[MN],t,que[MN];
long long ans;
int main(){
n=in();for (r int i=1; i<=n; ++i) a[i]=in();
for (r int i=n; i; --i){
while (a[i]>que[t]&&t) --t;
que[++t]=a[i];if (t>2) ans+=t-2ll;
}printf("%lld",ans);
}
T2(graph)小Z爱图论
题意简析
给定一张有向图，求有多少点对\((i,j)\)满足从\(i\)是可达\(j\)的.
数据范围及约定
\(1<=n<=2*10^3,1<=i,j<=n\)
解题思路
考虑使用floyd解决连通性问题，发现可以通过bitset优化效率，故可以通过此题.
总复杂度为$O(n^{3}/32) / O(n^2) $
#include <stdio.h>
#include <bitset>
#define MN 2005
#define r register
#define getchar() (S==TT&&(TT=(S=BB)+fread(BB,1,1<<15,stdin),S==TT)?EOF:*S++)
char BB[1<<15],*S=BB,*TT=BB;
using std::bitset;
inline int read(){
r int x; r bool f; r char c;
for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-');
for (x=c-'0'; (c=getchar())>='0'&&c<='9'; x=(x<<3)+(x<<1)+c-'0');
return f?-x:x;
}
bitset<MN> b[MN];int n,ans;
int main(){
n=read();for (r int i=1; i<=n; ++i)
for (r int j=1; j<=n; ++j)
b[i][j]=(read()|(i==j));
for (r int k=1; k<=n; ++k)
for (r int i=1; i<=n; ++i)
if (b[i][k]) b[i]|=b[k];
for (r int i=1; i<=n; ++i) ans+=b[i].count();
printf("%d",ans);
}
T3(boat)小Z爱划水
题意简析
有\(n\)个人，每个人可以选择划水或学习，有\(m\)对朋友关系，每个人有自己想做的事。
有2种情况会使得整个朋友圈的不满意度+1
1.一个人选择了自己不想做的事
2.一对朋友做了不同的事
求最小不满意度。
数据范围及约定
\(1<=n<=3*10^2,1<=m<=n*(n+1)/2\)
解题思路
容易发现，这是一个经典的网络流模型，对于选择了划水的人，我们将其割至源点，对于选择了学习的人，我们将其割至汇点，显然题意就是求最小割。
具体建图方式如下：
1)喜欢划水的，向源点连一条容量为1的边；
2)喜欢学习的，向汇点连一条容量为1的边；
3)在朋友关系间，互连一条容量为1的边；
对上图求最小割即为本体正解。
总复杂度为$O(Maxflow(n,n^2)) / O(n^2) $
#include <stdio.h>
#include <string.h>
#define r register
#define S 0
#define T 301
#define MN 305
#define ME 100005
#define inf 0x3f3f3f3f
#define min(a,b) ((a)<(b)?(a):(b))
#define getchar() (SS==TT&&(TT=(SS=BB)+fread(BB,1,1<<15,stdin),TT==SS)?EOF:*SS++)
char BB[1<<15],*SS=BB,*TT=BB;
inline int in(){
r int x; r bool f; r char c;
for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-');
for (x=c-'0'; (c=getchar())>='0'&&c<='9'; x=(x<<3)+(x<<1)+c-'0');
return f?-x:x;
}
struct node{int to,nxt,v;}edge[ME];
int head[MN],lev[MN],n,m,cnt=1,que[MN],iter[MN];
inline void ins(int x,int y,int f){edge[++cnt]=(node){y,head[x],f};head[x]=cnt;}
inline void insw(int x,int y,int f){ins(x,y,f);ins(y,x,0);}
inline bool bfs(){
memset(lev,-1,sizeof(lev));
r int h=0,t=1;que[1]=S;lev[S]=0;
while(h<t){
r int u=que[++h];
for (r int i=head[u]; i; i=edge[i].nxt)
if (lev[edge[i].to]==-1&&edge[i].v){
r int v=edge[i].to;lev[v]=lev[u]+1;
que[++t]=v;
}
}
memcpy(iter,head,sizeof(head));
return lev[T]!=-1;
}
int dfs(int u,int v,int f){
if (u==v) return f;
r int used=0;
for (r int &i=iter[u]; i; i=edge[i].nxt)
if (lev[edge[i].to]==lev[u]+1&&edge[i].v){
r int w=dfs(edge[i].to,v,min(f-used,edge[i].v));
used+=w;edge[i].v-=w;edge[i^1].v+=w;
if (used==f) return f;
}
if (!used) lev[u]=-1;return used;
}
int dinic(){
r int flow=0;
while(bfs()){
r int nf=dfs(S,T,inf);
while(nf) flow+=nf,nf=dfs(S,T,inf);
}return flow;
}
void init(){
n=in(),m=in();for (r int i=1; i<=n; ++i) in()?insw(S,i,1):insw(i,T,1);
for (r int i=1; i<=m; ++i){r int x=in(),y=in();ins(x,y,1);ins(y,x,1);}
}
int main(){init(); printf("%d",dinic()); return 0;}
T4(math)小Z爱数学
题意简析
定义函数\(f(n,k)\)表示\(n\)的所有因数\(p_{i}\)中满足\(n/p_{i}<=k\)的\(p_{i}\)的和。
求\(\Sigma_{i=1}^{n} f(i,k)\) 有多组询问。
数据范围及约定
\(询问数1<=m<=5*10^5,1<=n,k<=10^5\)
解题思路
显然，如果不考虑\(k\)的限制，对于一个正整数\(x\),\(x\)的贡献为全体\(x\)的倍数,并且我们容易发现\(f(n,k)\)在\(n\)一定时，随\(k\)单调递增，故考虑对询问按\(k\)排序。
接下来对于每次询问，统计所有在\(max(n)\)范围内的所有满足当前\(k\)限制的贡献后计算答案，显然使用线段树是可以较为方便的实现这一操作的。
考虑对\([1,n]\)开一棵线段树统计当前的\(f(i,k)\)然后维护即可。
根据调和级数，我们有$$1+\frac{1}{2}+\frac{1}{3}+...+\frac{1}{n} \approx \ln {n}$$
故时间复杂度为\(O(n\ln n \log_{2} n +m\log_{2}nm)\)空间复杂度为\(O(m+n)\).
#include <stdio.h>
#include <algorithm>
#define r register
#define ll long long
#define MN 500005
#define M (1<<17)
#define getchar() (S==TT&&(TT=(S=BB)+fread(BB,1,1<<15,stdin),TT==S)?EOF:*S++)
char BB[1<<15],*S=BB,*TT=BB;
inline int in(){
r int x; r bool f; r char c;
for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-');
for (x=c-'0'; (c=getchar())>='0'&&c<='9'; x=(x<<3)+(x<<1)+c-'0');
return f?-x:x;
}
struct node{
int n,k,id;
inline bool operator <(const node &b){
return k<b.k;
}
}q[MN];
ll T[M<<1],ans[MN];int n;
inline void A(int k,int v){for (k+=M; k; k>>=1) T[k]+=v;}
inline ll Q(int L,int R){
r ll res=0;
for (L+=M-1,R+=M+1; L^R^1; L>>=1,R>>=1){
if (~L&1) res+=T[L^1];
if (R&1) res+=T[R^1];
}return res;
}
inline void update(int k){for (r int i=M/k; i; --i) A(i*k,i);}
int main(){
n=in();
for (r int i=1; i<=n; ++i) q[i].n=in(),q[i].k=in(),q[i].id=i;
std::sort(q+1,q+n+1);for (r int i=1,j=0; i<=n; ++i){
while(j<q[i].k) update(++j);
ans[q[i].id]=Q(1,q[i].n);
}
for (r int i=1; i<=n; ++i) printf("%lld\n",ans[i]);
}