记录（OI 与数学） on Meze's Blog

关于省选和以后

Wed, 11 Mar 2026 20:31:13 +0800

关于省选

day1T1 不会
day1T2 不会
day1T3 不会
day2T1 场上想到稳定 $2n-4$ 做法，询问每一段前缀和后缀，可以确定一些位置上的数字，如果不能确定该位置的具体数字，就必然能确定这个位置上的数大于等于几，把剩下的数字合法地填到相应位置上即可。
day2T2 不会
day2T3 不会

我的 OI 结束了（可能还会参加 NOIP2026），如你所见，很菜。

其他

人总倾向于向后张望，大抵是因为当下的重力太过苛责。九年级至中考后的那段光景，是我生命里鲜有的轻盈时刻，被一层如雾般不知真伪的“爱”意轻柔包裹。每当思绪逆流触碰那片水域，景象便如同隔着水面般抽象而破碎。我无法将其具象化，一旦试图细究，记忆便在时光的冲刷下弥散成雾。然而，正是这种剥离了现实锋芒的朦胧，在一次次的自我放逐中重构出纯粹的愉悦，引人向更深处沉溺。可追忆终是一场借来的梦，思绪一旦停转，我便又急速坠回那粗糙的现实，留给这副疲惫躯壳的，再无半点欢愉。

这份粗糙的现实，大多源于高中岁月里那些晦涩的人际交织。说不清猜不透的前女友，容易起争执的同学，以及无孔不入的舆论，共同编织成了一张令人窒息的网。我深知自己的秉性——感知神经太过敏锐，却又缺乏圆融处世的情商。我不善言辞，那份笨拙的执拗让我在与人交锋时频频竖起倒刺，常常因为对某些事情的看法不同便与男生争吵；而在更柔软的社交维度里，我又退缩成一个彻底失语的局外人，几乎未曾与女生有过只言片语的交集。我当然也曾在心底渴求过同频的共鸣，但在现实的回音壁前，传回的往往只有失真的杂音。我只能将自己向内折叠，把仅有的希冀尽数倾注于网络，在那片由代码、算法与信息竞赛构筑的旷野里寻找庇护。可如今，随着最后一场比赛的落幕，这片我唯一能够活动的旷野，也随之轰然崩塌了。

别人大都是初中甚至小学便开始学习竞赛了，而我初中时虽对网络世界感兴趣，学了些许 Linux 和 Web 渗透的皮毛，却对信息学奥赛一无所知。在我所在的初中，这同样是一个无人知晓的盲区。直到高一，我才刚刚知道。看着周围那些比我多学好几年的 OIer，懊悔感时常不可抑制地涌上心头——若我能早些了解信息竞赛，或许此刻的我也能与他们并肩。NOIP2025 成为了压垮我的最后一根稻草，我自认为具备省一的实力，妄图写出第二题，最终却磕死在了第二题上。在 NOIP2025 之后，我本该接受退役的定局，但或许是出于对现实的极度不愿接受，我还是执拗地走向了省选的考场。

对于踏上信息竞赛这条路，我从未有过半分悔意，唯独遗憾于起步太晚，未能做好规划。至于以后，我或许会拾起最初的兴趣，将目光投向 CTF 赛事，去探寻那片我最初喜欢的领域。

也许就是这样，即使我现在输得一无所获，但至少我曾来过。

星图铺就的，未必是归途。
但有人循着它，便不算迷路。

—— [省选联考 2026] starmap

模板复习

Tue, 03 Mar 2026 17:06:21 +0800

图论

单源最短路

dijkstra

P4779 【模板】单源最短路径（标准版）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e5+5;
ll n,m,s;
ll dis[N],vis[N];
struct edge{
 ll v,w;
};
vector<edge> g[N];
struct node{
 ll dis,u;
 bool operator>(const node &b) const{
 return b.dis<dis;
 }
};
priority_queue<node,vector<node>,greater<node> > q;

void dijkstra(){
 memset(dis,0x3f,sizeof dis);
 memset(vis,0,sizeof vis);
 dis[s]=0;
 q.push((node){0,s});
 while (!q.empty()){
 ll u=q.top().u;
 q.pop();
 if (vis[u]) continue;
 vis[u]=1;
 for (edge ed:g[u]){
 ll v=ed.v,w=ed.w;
 if (dis[v]>dis[u]+w){
 dis[v]=dis[u]+w;
 q.push((node){dis[v],v});
 }
 }
 }
}

int main(){
 scanf("%lld%lld%lld",&n,&m,&s);
 for (int i=1;i<=m;i++){
 ll u,v,w;
 scanf("%lld%lld%lld",&u,&v,&w);
 g[u].push_back((edge){v,w});
 }
 dijkstra();
 for (int i=1;i<=n;i++) printf("%lld ",dis[i]);
 return 0;
}

spfa

P3371 【模板】单源最短路径（弱化版）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e4+5;
ll n,m,s;
ll inq[N],dis[N];
struct edge{
 ll v,w;
};
vector<edge> g[N];
queue<ll> q;

void spfa(){
 for (int i=1;i<=n;i++) dis[i]=INT_MAX;
 memset(inq,0,sizeof inq);
 q.push(s);
 dis[s]=0;
 inq[s]=1;
 while (!q.empty()){
 ll u=q.front();
 q.pop();
 inq[u]=0;
 for (edge ed:g[u]){
 ll v=ed.v,w=ed.w;
 if (dis[v]>dis[u]+w){
 dis[v]=dis[u]+w;
 if (!inq[v]) inq[v]=1,q.push(v);
 }
 }
 }
}

int main(){
 scanf("%lld%lld%lld",&n,&m,&s);
 for (int i=1;i<=m;i++){
 ll u,v,w;
 scanf("%lld%lld%lld",&u,&v,&w);
 g[u].push_back((edge){v,w});
 }
 spfa();
 for (int i=1;i<=n;i++) printf("%lld ",dis[i]);
 return 0;
}

最小生成树

P3366 【模板】最小生成树

Kruskal

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int M=2e5+5;
ll n,m,p[M],ans,cnt;
struct Edge{
 ll u,v,w;
 bool operator<(const Edge &b) const {
 return w<b.w;
 }
}g[M];

ll find(ll x){
 if (p[x]!=x) p[x]=find(p[x]);
 return p[x];
}

int main(){
 scanf("%lld%lld",&n,&m);
 for (int i=1;i<=m;i++){
 ll u,v,w;
 scanf("%lld%lld%lld",&u,&v,&w);
 g[i]=(Edge){u,v,w};
 }
 for (int i=1;i<=n;i++) p[i]=i;
 sort(g+1,g+1+m);
 for (int i=1;i<=m;i++){
 ll u=g[i].u,v=g[i].v,w=g[i].w;
 ll x=find(u),y=find(v);
 if (x!=y) p[x]=y,ans+=w,cnt++;
 }
 if (cnt==n-1) printf("%lld\n",ans);
 else printf("orz");
 return 0;
}

prim

强连通分量

[图论与代数结构 701] 强连通分量

tarjan

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e4+5;
ll n,m,cnt,sc;
vector<ll> g[N],ans[N];
ll dfn[N],ins[N],low[N],scc[N],vis[N];
stack<ll> s;

void tarjan(ll u){
 dfn[u]=low[u]=++cnt;
 s.push(u);
 ins[u]=1;
 for (ll v:g[u]){
 if (!dfn[v]){
 tarjan(v);
 low[u]=min(low[u],low[v]);
 }
 else if (ins[v]) low[u]=min(low[u],dfn[v]);
 }
 if (dfn[u]==low[u]){
 sc++;
 while (s.top()!=u){
 ll v=s.top();
 s.pop();
 scc[v]=sc;
 ins[v]=0;
 }
 scc[u]=sc;
 ins[u]=0;
 s.pop();
 }
}

int main(){
 scanf("%lld%lld",&n,&m);
 for (int i=1;i<=m;i++){
 ll u,v;
 scanf("%lld%lld",&u,&v);
 g[u].push_back(v);
 }
 for (int i=1;i<=n;i++){
 if (!dfn[i]) tarjan(i);
 }
 printf("%lld\n",sc);
 for (int i=1;i<=n;i++) ans[scc[i]].push_back(i);
 for (int i=1;i<=n;i++){
 if (vis[scc[i]]) continue;
 vis[scc[i]]=1;
 for (ll res:ans[scc[i]]) printf("%lld ",res);
 putchar('\n');
 }
 return 0;
}

网络流

【模板】网络最大流

网络最大流（EK）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=2e2+5;
const int M=5e3+5;
ll n,m,s,t,ans;
ll tot=1,h[N],dis[N],pre[N],vis[N];
struct node{
 ll v,w;
 ll nxt;
}e[M<<1];

void add(ll u,ll v,ll w){
 e[++tot]=(node){v,w,h[u]};
 h[u]=tot;
}

bool bfs(){
 memset(vis,0,sizeof vis);
 queue<ll> q;
 q.push(s);
 vis[s]=1;
 dis[s]=1e14;
 while (!q.empty()){
 ll u=q.front();
 q.pop();
 for (int i=h[u];i;i=e[i].nxt){
 ll v=e[i].v,w=e[i].w;
 if (vis[v]) continue;
 if (!w) continue;
 vis[v]=1;
 dis[v]=min(dis[u],w);
 pre[v]=i;
 q.push(v);
 if (v==t) return true;
 }
 }
 return false;
}

void update(){
 ll u=t;
 while (u!=s){
 ll v=pre[u];
 e[v].w-=dis[t];
 e[v^1].w+=dis[t];
 u=e[v^1].v;
 }
 ans+=dis[t];
}

int main(){
 scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
 for (int i=1;i<=m;i++){
 ll u,v,w;
 scanf("%lld%lld%lld",&u,&v,&w);
 add(u,v,w);
 add(v,u,0);
 }
 while (bfs()) update();
 printf("%lld\n",ans);
 return 0;
}

网络最大流（Dinic+当前弧优化）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=2e2+5;
const int M=5e3+5;
const ll INF=1e14;
ll n,m,s,t,ans;
ll tot=1,h[N],dis[N],cur[N];
struct node{
 ll v,w;
 ll nxt;
}e[M<<1];

void add(ll u,ll v,ll w){
 e[++tot]=(node){v,w,h[u]};
 h[u]=tot;
}

bool bfs(){
 for (int i=1;i<=n;i++) dis[i]=INF,cur[i]=h[i];
 queue<ll> q;
 q.push(s);
 dis[s]=0;
 while (!q.empty()){
 ll u=q.front();
 q.pop();
 for (int i=h[u];i;i=e[i].nxt){
 ll v=e[i].v,w=e[i].w;
 if (w&&dis[v]==INF){
 q.push(v);
 dis[v]=dis[u]+1;
 }
 }
 }
 return dis[t]!=INF;
}

ll dfs(ll u,ll sum){
 if (u==t) return sum;
 ll res=0;
 for (ll &i=cur[u];i&&sum;i=e[i].nxt){
 ll v=e[i].v,w=e[i].w;
 if (w&&dis[v]==dis[u]+1){
 ll k=dfs(v,min(sum,w));
 if (!k) dis[v]=INF;
 e[i].w-=k;
 e[i^1].w+=k;
 res+=k;
 sum-=k;
 }
 }
 return res;
}

int main(){
 scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
 for (int i=1;i<=m;i++){
 ll u,v,w;
 scanf("%lld%lld%lld",&u,&v,&w);
 add(u,v,w);
 add(v,u,0);
 }
 while (bfs()) ans+=dfs(s,INF);
 printf("%lld\n",ans);
 return 0;
}

数据结构

并查集

P3367 【模板】并查集

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=2e5+5;
ll n,m,p[N];

ll find(ll x){
 if (p[x]!=x) p[x]=find(p[x]);
 return p[x];
}

int main(){
 scanf("%lld%lld",&n,&m);
 for (int i=1;i<=n;i++) p[i]=i;
 for (int i=1;i<=m;i++) {
 ll z,x,y;
 scanf("%lld%lld%lld",&z,&x,&y);
 if (z==1) p[find(x)]=find(y);
 if (z==2){
 if (p[find(x)]==p[find(y)]) puts("Y");
 else puts("N");
 }
 }
 return 0;
}

数学

字符串

其他

洛谷 3 月月赛 I

Sun, 01 Mar 2026 17:51:34 +0800

比赛链接：

div1：https://www.luogu.com.cn/contest/309087
div2：https://www.luogu.com.cn/contest/309086

100+100+100+0+0+0

A.「Stoi2037」晴天

没什么好说的

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e6+5;
ll n,s,x,p,ans=-1;
ll a[N];

int main(){
 scanf("%lld%lld%lld",&n,&s,&x);
 for (int i=1;i<=n;i++){
 scanf("%lld",&a[i]);
 if (a[i]!=-1) p+=x-a[i];
 if (p>=s) {
 ans=i;
 break;
 }
 }
 printf("%lld\n",ans);
 return 0;
}

B.「Stoi2037」七里香

数学题和简单贪心，下文我们统一把 $a’_i$ 写作 $a_i$，观察原式子：

$$ ((j-1)k+a_j)-((i-1)k+a_i) $$

$$ =(j-i)k+(a_j-a_i) $$

注意到对于每一对 $(i,j)$ 会出现 $i(n-j+1)$ 次，总的计算得到：

$$ Ans=\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} i(n-j+1)[(j-i)k+(a_j-a_i)] $$

$$ =\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} i(n-j+1)(j-i)k+\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}i(n-j+1)(a_j-a_i) $$

第一部分是一个定值，因此只需最大化第二部分。我们考虑计算求和完之后 $a_i$ 的系数 $c_i$，不难计算得到：

$$ c_i=\sum_{m=1}^{i-1}m(n-i+1)-\sum_{m=i+1}^{n}i(n-m+1) $$

$$ =\frac{i(n-i+1)(2i-n-1)}{2} $$

因此答案转化为：

$$ Ans=k \sum_{i=1}^{n} i \cdot c_i+\sum_{i=1}^{n}c_i \cdot a_i $$

考虑怎么重排 $a_i$，只看第二部分，如果把 $c_i$ 从小到大排序，要想最大化此值，就让 $a_i$ 也从小到大排序去逐个相乘。最后的答案要使用 __int128。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e5+5;
ll n,k,a[N],c[N];

void print(__int128 x) {
 if (x<0) {
 putchar('-');
 x=-x;
 }
 if (x>9) print(x/10);
 putchar(x%10+'0');
}

int main(){
 scanf("%lld%lld",&n,&k);
 for (int i=1;i<=n;i++) scanf("%lld",&a[i]);
 sort(a+1,a+1+n);
 __int128 ans=0;
 for (int i=1;i<=n;i++){
 c[i]=i*(n-i+1)*(2*i-n-1)/2;
 ans+=(__int128)c[i]*i*k;
 } 
 sort(c+1,c+1+n);
 for (int i=1;i<=n;i++) ans+=(__int128)a[i]*c[i];
 print(ans);
 return 0;
}

C.「Stoi2037」白色风车

考虑什么样的图可以使得点 $x$ 和点 $y$ 达到永远，什么样的图不能。

若两点不在一个连通图上，显然不可能。
若两点所在的连通块内没有环（一棵树），也是不可能的。

现在的连通块内存在环，注意 Subtask 3 提到了二分图。如果这张图不是二分图，说明存在奇环，只需要让这两棋子走到环中，再对向走，一定有一个方向可以使得两棋子走到同一条边上，因为棋子 $x$ 可以回头，此时两棋子只需要再同向走就能达到永远。如果这个图是二分图，如果两棋子颜色一样（位于同一侧），两棋子无论怎么走颜色都一样，始终无法处于一条边上，因此无解；如果两棋子的颜色不一样，且二分图有环（没有环的情况已经被我们排除了），只需要让两棋子各自走到环中，然后对向走可以使得两棋子走到一条边上，棋子 $x$ 再往回走之后一起同向走便可实现永远。

若两点所在的连通块不是二分图且有环，说明可以。
若两点所在的连通块是二分图且有环，如果两点颜色一样，则无解。否则就可以。

这四个判断步骤走一遍就能涵盖所有情况。用 DFS 判断是否是二分图，同时判断图是否连通，再用连通块内点的个数和点的度数之和判断是不是树。复杂度是 $O(n+m)$。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e6+5;
ll Tid,T;
ll n,m,x,y;
vector<ll> g[N];
ll vis[N],notb,color[N],du[N],cnt;

void dfs(ll u){
 cnt++;
 vis[u]=1;
 for (ll v:g[u]){
 if (vis[v]) {
 if (color[v]==color[u]) notb=1;
 }
 else {
 color[v]=color[u]^1;
 dfs(v);
 }
 du[u]++;
 }
}

int main(){
 scanf("%lld%lld",&Tid,&T);
 while (T--){
 scanf("%lld%lld%lld%lld",&n,&m,&x,&y);
 for (int i=0;i<=n;i++) g[i].clear(),vis[i]=0,color[i]=0,du[i]=0;
 notb=0,cnt=0;
 for (int i=1;i<=m;i++){
 ll u,v;
 scanf("%lld%lld",&u,&v);
 g[u].push_back(v);
 g[v].push_back(u);
 }
 dfs(x);
 for (int i=1;i<=n;i++) du[0]+=du[i];
 if (!vis[y]) puts("No");
 else if (2*(cnt-1)==du[0]) puts("No");
 else if (notb) puts("Yes");
 else {
 if (color[x]==color[y]) puts("No");
 else puts("Yes");
 }
 }
 return 0;
}

计数题记录

Fri, 27 Feb 2026 14:18:15 +0800

这几天琢磨其他东西，差点忘了自己还有省选没有参加（虽然参不参加都进不了队），但还是想认真对待一下这次省选，就认真做几道题目吧。

P14636 [NOIP2025] 清仓甩卖

性质转化+计数
考虑什么时候不合法，我们可以把 $w_i=2$ 的物品看作两个定价为 $1$，原价为 $\frac{a_i}{2}$ 的物品，只不过这两个物品必须捆绑购买，这样我们所有的物品的定价就是 $1$ 元，我们只需要买原价前 $m$ 大的物品即可（注意到 $\frac{a_i}{2}$ 就是这个原物品的性价比，因此小 R 的排序方式与此等同），问题就在如果第 $m$ 个物品与第 $m+1$ 个物品是必须捆绑购买的，小 R 会放弃第 $m$ 个物品，向后寻找一个不被捆绑的物品（不妨设其为第 $k$ 个物品，$k$ 可能不存在）进行购买，如果此时第 $m-1$ 个物品是不被捆绑的，且 $v_{m-1}+v_{k} < v_m+v_{m+1}$（这里用 $v_i$ 表示按如上情景下第 $i$ 件物品的原价），小 R 的选法就不是最优的，形式化的如下：

小 R 在剩余最后 $2$ 元的时候，此时有 $a_i>\frac{a_j}{2}>a_k$ 且 $a_j>a_i+a_k$，小 R 的选择不是最优的

我们可以计算不合法的方案数，我们不妨枚举每一对 $(i,j)$，使得 $a_i>\frac{a_j}{2}$ 且 $a_j>a_i$，再去寻找「第一个」符合条件的 $k$（第一个满足 $a_k<a_j-a_i$ 的 $k$），找 $k$ 的过程使用双指针可以做到 $O(n^2)$，容易发现其位置满足

.....j....i...k...

我们需要计算一对 $(i,j)$ 能够造出多上个不合法的方案

$[1,j-1]$ 中的物品一定会被买。
$[j+1,i-1]$ 中定价为 $1$ 的物品一定会被买到，定价为 $2$ 的则不会。

在这两段，我们必须花掉 $m-2$ 元。

$[i+1,k-1]$ 中的物品不会被买到，且定价必须是 $2$。
$[k,n]$ 中的物品不会被买到，定价随意（注意这里 $w_k$ 的取值也是随意的）。

我们只需计算 $m-2$ 用于分配的方案数，第一段每个先给保底 $1$ 元，还剩 $m-2-(j-1)=m-j-1$ 元，接着这些钱要分配给第一段中 $w=2$ 的物品和第二段中 $w=1$ 的物品各 $1$ 元。方案数是 $\binom{i-2}{m-j-1}$。第三段不用考虑。因为 $w_k$ 的取值也是随意的，所以第四段的方案数是 $2^{n-k+1}$。对于一组 $(i,j)$，能构造出的不合法的情况的方案数：

$$ \binom{i-2}{m-j-1}\cdot 2^{n-k+1} $$

答案就是总的方案数减去不合法的方案数。

$$ Ans=2^n-\sum_{(i,j,k)}\binom{i-2}{m-j-1}\cdot 2^{n-k+1} $$

P10744 [SEERC 2020] Modulo Permutations

挖掘性质+排列DP+DP优化
首先注意到，当 $p_i<p_{i+1}$ 时，$p_i \mod p_{i+1}=p_{i+1}$，因此当 $p_i>2$ 时，接在它后面的数必须比它小，因此不难发现，合法的排列由两个结尾分别是 $1$ 和 $2$ 的递降的链构成。考虑 DP,考虑从大往小填充数字，令 $dp_{i,j}$ 表示以 $i$ 和 $j$ 结尾时的方案数，其中 $i<j$。则有如下 $O(n^2)$ 的转移，初始 $dp_{n-1,n}=1$。

$$ \left \{ \begin{matrix} dp_{i-1,i} \gets dp_{i,j},j \mod (i-1) \le 2\\ dp_{i-1,j} \gets dp_{i,j} \end{matrix}\right. $$

考虑优化 DP，注意到方程第二维只从原先更高的转移过来，因此我们把第二维单独摘出来，令 $dp_i$ 表示两个链的结尾最大是 $i$，从刚刚我所说的能看出来它的转移是不具有后效性的。有如下方程

$$ dp_i=1+\sum_{j \in [i+1,n],j \mod (i-1)\le 2} dp_j $$

这里有一个 $+1$，意思是还有一个方案没有被考虑，两个链分别是

n,n-1,n-2,...,i+1
i

我们找这个 $j$ 的复杂度是 $O(\frac{n}{i})$，从如下数字中找

$((i-1)+0) \cdot k$
$((i-1)+1) \cdot k$
$((i-1)+2) \cdot k$

这样总的复杂度就是调和级数，$O(n \ln n)$。因为是一个环，最后的答案就是 $n \cdot dp_2$.优化部分不是很好想，给出核心代码加以理解。

for (int m = n - 1; m >= 1; --m) {
 long long cur_sum = 1; 

 if (m >= 3) {
 for (int k = 1; k * m <= n; ++k) {
 int base = k * m;
 
 // j 必须大于 m + 1
 if (base > m + 1) cur_sum =(cur_sum + f[base]) % MOD;
 if (base + 1 <= n && base + 1 >m + 1) cur_sum = (cur_sum + [base + 1]) % MOD;
 if (base + 2 <= n && base + 2 >m + 1) cur_sum = (cur_sum + [base + 2]) % MOD;
 }
 } 

 else {
 // 当 m = 1 或 2 时，任何数 mod 它必然 <= 2，直接累加所有有效的 j
 for (int j = m + 2; j <= n; ++j) {
 cur_sum = (cur_sum + f[j]) %MOD;
 }
 }

 f[m + 1] = cur_sum;
}

P10741 [SEERC 2020] Fence Job

性质转化+计数DP
题目等同于让某一个数向周围比它大的扩散，问可以产生多少种排列。我们先预处理出来每个数可以覆盖的范围，对于 $h_i$，他可以覆盖 $[l_i,r_i]$ 下标内的所有数。我们在一个空的排列上依次填数即可，考虑 DP，设 $dp_{i,j}$ 表示处理到排列的第 $i$ 个位置，要填入 $h_j$ 的方案数。前提是保证 $l_j \le i \le r_j$，否则 $dp_{i,j}=0$。同时注意到产生的新排列的每个数在原排列中的下标是单调不降的。于是

$$ dp_{i,j}=\sum_{k=1}^{j}dp_{i-1,k} $$

这一步可以用前缀和实现，复杂度是 $O(n^2)$。答案就是

$$ Ans=\sum_{i=1}^{n}dp_{n,i} $$

AT_dp_t Permutation

排列计数DP+插入法技巧
因为给了相邻两项的大小关系，没有具体数值的要求，所以考虑插入法（https://www.luogu.com.cn/article/xt2szowt），就是对待填入数字在已知排列中的排名进行 DP，设 $dp_{i,j}$ 表示考虑到第 $i$ 个位置，第个位置上的数在前 $i$ 个数当中排名为 $j$。有如下转移

$$ \operatorname{if} s_i='<' \ , \ dp_{i,j}=\sum_{k=1}^{j-1} dp_{i-1,k} $$

$$ \operatorname{if} s_i='>' \ , \ dp_{i,j}=\sum_{k=j}^{i-1} dp_{i-1,k} $$

关于初始化，$dp_{1,1}=1$，这是因为我们只考虑相对大小，不对该位置上的具体数值进行讨论，因此只有一种情况，对方程进行一下前缀和优化就能做到 $O(n^2)$。

[ABC282G] Similar Permutation

排列计数DP+插入法技巧
这道题下相当于上一道的二维的加强版，令 $dp_{i,j,k,p}$ 表示处理到第 $i$ 个元素中，$A_i$ 排名为 $j$，$B_i$ 排名为 $k$，有 $p$ 处满足限制。初始时 $dp_{1,1,1,0}=1$，有 $O(n^5k)$ 转移。

$$ dp_{i,j,k,p} =\sum_{x=1}^{j-1} \sum_{y=1}^{k-1} dp_{i-1,x,y,p-1}+\sum_{x=j}^{i-1} \sum_{y=k}^{i-1} dp_{i-1,x,y,p-1}+\sum_{x=1}^{j-1} \sum_{y=k}^{i-1} dp_{i-1,x,y,p}+\sum_{x=j}^{i-1} \sum_{y=1}^{k-1} dp_{i-1,x,y,p} $$

这里用二维前缀和即可做到 $O(n^3k)$。

$$ sum_{i,j,k,p}=\sum_{x=1}^{j} \sum_{y=1}^{k} dp_{i,x,y,p} $$

P14568 【MX-S12-T3】排列

排列计数DP+插入法技巧
这道题我认为还是很难理解的。对于排列中的数字，不仅有前缀的限制，也有后缀的限制，传统的像前两道题的 DP 状态只能解决一个方向，我们干脆对“位置”进行放置，意思就是我们按照位置的顺序（第 $1$ 个数、第 $2$ 个数 $\dots$ 第 $n$ 个数），依次把它们放进一个“按照值从小到大排序的虚空序列”里。设 $dp_{i,j}$ 表示安排了前 $i$ 个位置，为后来的位置留下了 $j$ 个“合法”（不影响前 $i$ 个位置的合法性）的空隙。
对于 $op_i \in { 0,1 } $，我们放置的第 $i$ 个位置必须在所留下的空隙的最左面或最右面，放下的同时也会产生两个空隙，后来的位置可以随便插不会影响第 $i$ 个位置

$$ dp_{i,j}=dp_{i-1,j-1} $$

对于 $op_i \in { 2,3 } $，我们可以把第 $i$ 个位置插入到任意一个空隙中，但对后来的位置，其左边或右边的所有空隙不再合法。因此他会从 $dp_{i-1,\ge j}$ 的状态中转移过来。这里有一个上限是 $i$，因为 $i-1$ 个位置最多产生 $i$ 个空隙。

$$ dp_{i,j}=\sum_{k=j}^{i} dp_{i-1,k} $$

同时注意到当 $op_i=2/3$ 时，后面不能再出现 $op_j=0/1$。（注：$0$ 对应 $2$，$1$ 对应 $3$），这里只需特判一下。

// 逻辑矛盾预检：一旦出现后缀最值(2/3)，未来不可能出现前缀最值(0/1)
bool flag2 = false, flag3 = false;
for (int i = 1; i <= n; i++) {
 if (op[i] == 0 && flag2) { cout << 0 << endl; return 0; }
 if (op[i] == 1 && flag3) { cout << 0 << endl; return 0; }
 if (op[i] == 2) flag2 = true;
 if (op[i] == 3) flag3 = true;
}

最后的答案就是

$$ Ans=\sum_{j=1}^{n+1}dp_{n,j} $$

第二步转移使用后缀和即可。给出核心代码加以理解。

// 初始化第 1 个元素
if (op[1] == 0 || op[1] == 1) {
 dp[1][2] = 1; // 没有任何限制，左右两侧的2 个空隙均合法
} else {
 dp[1][1] = 1; // 封杀了一侧，只剩下 1 合法空隙
}

// 状态转移
for (int i = 2; i <= n; i++) {
 if (op[i] == 0 || op[i] == 1) {
 // 必然插在极值端，合法空隙增加 1 个(j 从 j-1 转移而来)
 // 上一步最多有 i 个空隙，所以这一步多产生 i+1 个空隙
 for (int j = 2; j <= i + 1; j++) {
 dp[i][j] = dp[i - 1][j - 1];
 }
 } 
 else {
 // 可以插在任意合法的空隙，但会封杀左或右侧
 // 导致合法空隙缩小为 j (需要上一层>= j 的状态累加)
 long long suffix_sum = 0;
 // 上一步最多只有 i 个空隙，直接从 i逆序求后缀和即可，清晰明了！
 for (int j = i; j >= 1; j--) {
 suffix_sum = (suffix_sum + dp[i- 1][j]) % MOD;
 dp[i][j] = suffix_sum;
 }
 }
}
// 最终答案统计
// n 个位置全部处理完毕后，不论剩下多少个合法隙，每一种终点状态都代表一种完美的排列方案
long long ans = 0;
for (int j = 1; j <= n + 1; j++) {
 ans = (ans + dp[n][j]) % MOD;
}

[AGC054B] Greedy Division

性质转化+排列计数DP+切换计数对象

考虑最终两人手上的排列都是什么情况，如果一人手中的数集是 $S$，另一人手中的数集则是 $S’$。则对于唯一的 $S$，可以构造出的排列数是 $|S|! \cdot (n-|S|)!$。

对于两个 $S$ 和 $S’$，对两数集进行排列，重新排列后的两数集按照题目中的规则可唯一合并为一个排列，即：
$$ \left \{ S_{一种排列} ,S'_{一种排列} \right \} \Leftrightarrow \left \{ W_{一种合法的排列} \right \} $$

可以发现对于一中选择 $S$，能产生的方案数只与大小有关。考虑 DP，设 $dp_{i,j,k}$ 表示对于前 $i$ 个数，选了 $j$ 个数，总和为 $k$ 的方案数。有如下转移：

$$ dp_{i,j,k}=dp_{i-1,j-1,k-w_i}+dp_{i-1,j,k} $$

最终答案就是：

$$ Ans=\sum_{i=1}^{n} dp_{n,i,\frac{sum}{2}} \cdot i! \cdot (n-i)! $$

注意当 $\frac{sum}{2}$ 为奇数时无解。时间复杂度在 $O(n^2 \cdot \sum w_i)$。

P14364 [CSP-S 2025] 员工招聘

排列计数DP+贡献延后计算

设 $dp_{i,j,k}$ 表示处理到第 $i$ 天，有 $j$ 个人不通过，⌈钦定⌋ 了 $k$ 个满足 $c \le j$ 的位置，此时的方案数。这个状态可能比较难以理解，我们只考虑钦定的这 $k$ 个位置造成的方案数，不考虑剩下 $i-k$ 个位置的具体内容。我们规定 $cnt_j$ 表示 $c=j$ 的人数，$sum_j$ 表是 $c \le j$ 的人数，我们考虑向后转移

如果 $s_{i+1}=1$，选择 $c>j$ 的人可以通过面试，有如下转移

$$ dp_{i+1,j,k} \gets dp_{i,j,k} $$

选择 $c \le j$ 的则不会通过，考虑怎么转移，此时有 $j+1$ 个人不能通过，枚举前 $i$ 个人当中有 $p$ 个 $c=j+1$，新状态就是 $dp_{i+1,j+1,k+1+p}$.我们需要在原来 $i-k$ 个位置中选出 $p$ 个位置来放置这 $p$ 个 $c=j+1$，即 $\binom{i-k}{p}$，还要从那些 $c=j+1$ 的人当中选出 $p$ 个来填充这些位置，这 $p$ 个人也可以随意排列，方案数是 $\binom{cnt_{j+1}}{p}p!$，再从所有未被钦定的 $c \le j$ 的当中选一个，即 $\binom{sum_j-k}{1}=(sum_{j}-k)$。有如下转移：

$$ dp_{i+1,j+1,k+1+p} \gets \binom{i-k}{p}\binom{cnt_{j+1}}{p}p!(sum_j-k)dp_{i,j,k} $$

如果 $s_{i+1}=0$，按照上面的情况讨论即可，如果选择 $c>j+1$，有如下转移：

$$ dp_{i+1,j+1,k+p} \gets \binom{i-k}{p} \binom{cnt_{j+1}}{p}p!dp_{i,j,k} $$

若选择 $c \le j+1$，有如下转移：

$$ dp_{i+1,j+1,k+p+1} \gets \binom{i-k}{p} \binom{cnt_{j+1}}{p}p!(sum_{j+1}-p-k)dp_{i,j,k} $$

最终答案就是枚举不通过人数到 $n-m$。

$$ Ans=\sum_{i=1}^{n-m} dp_{n,i,sum_i}(n-sum_{i})! $$

如果难以理解可以看代码

newdp[0][0]=1;
for(int i=0;i<n;i++){
	memcpy(olddp,newdp,sizeof(newdp));
	memset(newdp,0,sizeof(newdp));
	for(int j=0;j<=i;j++)
		for(int k=0;k<=min(sum[j],i);k++){
			if(!olddp[j][k]) continue;

			if(s[i+1]=='1'){
				(newdp[j][k] += olddp[j][k]) %= Mod;
				for(int p=0;p<=min(i-k,cnt[j+1]);p++)
					(newdp[j+1][k+p+1] += C[i-k][p]*C[cnt[j+1]][p]%Mod*jc[p]%Mod*(sum[j]-k)%Mod*olddp[j][k]) %= Mod;
			}
			else{
				for(int p=0;p<=min(i-k,cnt[j+1]);p++){
					//<=j+1
					(newdp[j+1][k+p+1] += C[i-k][p]*C[cnt[j+1]][p]%Mod*jc[p]%Mod*olddp[j][k]%Mod*(sum[j+1]-p-k)) %= Mod;
					//>j+1
					(newdp[j+1][k+p] += C[i-k][p]*C[cnt[j+1]][p]%Mod*jc[p]%Mod*olddp[j][k]) %= Mod;
				}
			}
		}
}

long long ans=0;
for(int i=0;i<=n-m;i++)
	(ans += newdp[i][sum[i]]*jc[n-sum[i]]) %= Mod;

这篇题解如何体现 ⌈贡献延后计算⌋？（Gemini 3.1 Pro 总结）
传统的排列 DP 是“走到哪，填到哪，算到哪”。但在本题中：

只占坑，不结账（延后）：当某天面试难度低（$s=1$）时且选择了能够通过的人，我们不急着决定今天具体录用谁，而是把这一天当成一个“空白名额”积攒下来，此时方案数直接继承（即不乘任何组合数，延后贡献计算）。

触碰底线，集中清算（兑现）：当不通过人数增加（$j \gets j+1$）时，那些忍耐度为 $c=j+1$ 的人到了必须被安排的生死线。此时我们才回溯，从之前积攒的“空白名额”中抽出几个，把这批人填进去。这时才一次性乘上对应的组合数与排列数，完成历史贡献的集中清算。

这就是贡献延后计算：先把空位留着，等特定元素的限制条件被触发时，再统一计算它们填入空位的排列方案。