TangZiFan's Blog

25年ICPC第一场网络赛题解

2025-09-08T00:00:00+00:00

主题介绍

介绍

比赛链接

Problem A. Who Can Win

题意：

有T个样例，每个样例有S个提交，每个提交由队伍名字、题目、提交时间、提交状态构成。

提交状态分为AC、RE、UN，如果RE，罚时加20min，如果AC，以提交时间为基础罚时，如果UN，可能AC或WA。

将最终可能夺得冠军的队伍按字典序输出。

题解：

按照提交时间进行排序，利用map存储队伍名字+题目、状态+时间。这样可以统计一支队伍在某道题目上的状态。

如果已经AC或UN，将跳过后面对于这道题目的所有提交。如果RE，罚时+20。

不考虑UN，只考虑AC和RE，最后得到冠军AC题目数量和罚时。

再将队伍进行字典序排序，将所有UN考虑变成AC，大于等于前面冠军的输出。

#include <bits/stdc++.h>
using namespace std;
const int N=2e5+10;
const int li=1e6;
int t,n,len;
struct sut{
	string sna;
	char ti;
	int shi;
	int zhuang;
	int unti,unshi;
}a[N],b[N];
bool cmp(sut x,sut y){
	if(x.shi!=y.shi) return x.shi<y.shi;
	if(x.zhuang!=y.zhuang){
		return x.zhuang>y.zhuang;
	}
	return x.sna<y.sna;
}
bool cmp1(sut x,sut y){
	return x.sna<y.sna;
}
map<string,int> mp1;
map<string,int> mp2;//哈希
void solve(){
	cin>>n;
	len=0;
	for(int i=1;i<=n;i++){
		b[i].shi=b[i].unshi=b[i].unti=b[i].zhuang=0;
		b[i].sna="";b[i].ti=0;
		a[i].shi=a[i].unshi=a[i].unti=a[i].zhuang=0;
		a[i].sna="";a[i].ti=0;
	}
	mp1.clear();mp2.clear();
	for(int i=1;i<=n;i++){
		cin>>a[i].sna>>a[i].ti>>a[i].shi;
		string s1;cin>>s1;
		if(s1=="Accepted") a[i].zhuang=1;
		else if(s1=="Rejected") a[i].zhuang=2;
		else a[i].zhuang=3;
	}
	sort(a+1,a+n+1,cmp);
	for(int i=1;i<=n;i++){
		int tmp1=a[i].zhuang,tmp2=a[i].shi;
		string s1=a[i].sna+a[i].ti;
		if(mp1[s1]==0){
			if(tmp1==2) mp1[s1]=tmp1*li+20;
			else mp1[s1]=tmp1*li+tmp2;
		}else{
			int tmp3=mp1[s1]/li;
			if(tmp3==1||tmp3==3) continue;
			else if(tmp3==2){
				if(tmp1==1){
					int zzz=mp1[s1];
					mp1[s1]=li+zzz%li+tmp2;
				}else if(tmp1==2) mp1[s1]+=20;
				else{
					int zzz=mp1[s1];
					mp1[s1]=3*li+zzz%li+tmp2;
				}
			}
		}
	}
	for(map<string,int>::iterator it=mp1.begin();it!=mp1.end();it++){
		string s1=(*it).first;
		int tmp1=(*it).second/li,tmp2=(*it).second%li;
		s1.erase(s1.size()-1,1);
		if(mp2[s1]==0) mp2[s1]=++len;
		b[mp2[s1]].sna=s1;
		if(tmp1==1){
			b[mp2[s1]].zhuang++;
			b[mp2[s1]].shi+=tmp2;
		}else if(tmp1==3){
			b[mp2[s1]].unti++;
			b[mp2[s1]].unshi+=tmp2;
		}
	}
	int ans1=0,ans2=1e9;
	for(int i=1;i<=len;i++){
		if(b[i].zhuang>ans1){
			ans1=b[i].zhuang;
			ans2=b[i].shi;
		}else if(b[i].zhuang==ans1){
			ans2=min(ans2,b[i].shi);
		}
	}
	sort(b+1,b+len+1,cmp1);
	for(int i=1;i<=len;i++){
		int a1=b[i].zhuang,a2=b[i].unti,a3=b[i].shi,a4=b[i].unshi;
		if((a1>ans1)||(a1==ans1&&a3<=ans2)||(a1+a2>ans1)||(a1+a2==ans1&&a3+a4<=ans2)){
			cout<<b[i].sna<<" ";
		}
	}
	cout<<"\n";
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>t;
	while(t--) solve();
	return 0;
}

Problem B. Creating Chaos

题意：

给定一个序列1~n，你删除k个数，使得剩下的数两两之间 $$gcd(

a_i-a_j

,n)$$ 之和最少，输出一组方案即可。

题解：

删除1~k即可。严格证明请看B题证明

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n,k;cin>>n>>k;
	for(int i=1;i<=k;i++) cout<<i<<" ";
	return 0;
}

Problem C. Canvas Painting

题意：

给定一个长度为n的数列1~n，接下来给定m个区间，可以任意顺序排列这些区间，然后依次对每个区间 $[l,r]$ 选定其中两个位置，让其中一个位置的数等于另一个位置的数，问数列不同数字的个数最终的最小值。

题解：

贪心。我们先对区间进行排序，以左端点从小到大，相同看右端点从小到大。

先排除掉长度为1的区间，不会发挥作用。

如果区间的左端点单调递增，那么我每次只需要选中最靠左的两个数，每次操作可以让颜色数-1，此时答案是n-m。

如果区间左端点相等不递增，可以先贪心用掉区间长度最短的那个（即右端点小的），把其他与左端点相等的区间左端点加一。

整个过程需要排除长度本来就为1的区间和在操作中长度变为1的区间，并动态维护顺序。可以用堆来实现。时间复杂度 $O(n\log n)$。

#include<bits/stdc++.h>
using namespace std;
const int N=2e6;
int n,m;
struct qu{
	int l,r;
	friend bool operator < (qu a,qu b){
		if(a.l!=b.l) return a.l<b.l;
		return a.r<b.r;
	}
}e[N];
priority_queue<int,vector<int>,greater<int> > pq;
void solve(){
	cin>>m>>n;
	for(int i=1;i<=m;i++){
		cin>>e[i].l>>e[i].r;
	}
	sort(e+1,e+m+1);
	int t=1,xl=0,k=0;//t第几区间,k删除数目
	while(t<=m){
		xl=e[t].l;
		do{
			while(t<=m&&e[t].l==xl){//将左端点相同的放入队列
				if(xl<e[t].r) pq.push(e[t].r);
				t++;
			}
			if(pq.empty()) break;//防止上一步没有导致下一步pop错误
			xl++,k++,pq.pop();//使用top这个区间
			while(!pq.empty()&&xl>=pq.top()) pq.pop();//留下所有右区间大于xl的
		}while(!pq.empty());
	}
	cout<<n-k<<"\n";
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int T;cin>>T;
	while(T--) solve();
	return 0;
}

Problem D. Min-Max Tree

树形DP，不会。ICPC2025 网络赛（一）简单习题详解（7/13）

Problem G. Sorting

题意：

给定m对二元组，如果左下标对应数字大于右下标对应数字，你就可以使用这些二元组交换两者为下标的位置。能否将所有排列经过任意次操作后变成从小到大的有序。

题解：

观察发现如果出现所有的 $[i,i+1]$，即可将所有排列变为有序。

个人推论。如果取消掉数字大于才能排序的规则，则联通即可。

#include<bits/stdc++.h>
using namespace std;
int n,m,a[200010];
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	while(m--){
		int l,r;cin>>l>>r;
		if(l+1==r) a[l]=1;
	}
	for(int i=1;i<n;i++)
		if(a[i]!=1){
			cout<<"No\n";return 0;
		}
	cout<<"Yes\n";
	return 0;
}

Problem I. Knapsack Problem

题意：

给一个具有n个顶点和m条边的无向图，每条边具有一个权值w，固定背包容量V。一开始带一个背包，经过相应权值的边就把权值放入背包，如果放不下就新开一个背包并且放进新背包。

给定节点T，问每个节点到T分别所需要消耗的最小背包数。

题解：

Dijkstra板子，维护每个点的（最小背包数，所用容量）即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF=0x3f3f3f3f;
const int N=1e5+10,M=5e5+10;
int n,m,T;
ll V;
struct num{
	ll v,c;//背包个数,背包所装容量
	num(ll vv=0,ll cc=0){v=vv,c=cc;}
	friend bool operator < (num a,num b){
		if(a.v==b.v) return a.c<b.c;
		return a.v<b.v;
	}
	num operator + (int w)const{
		if(c+w<=V) return num(v,c+w);
		return num(v+1,w);
	}
};
num dis[N];
struct edge{
	int v;//终点
	num w;
	bool operator <(edge b)const{
		return b.w<w;
	}
};
struct eg{
	ll v,w;
};
priority_queue<edge> pq;
vector<eg> E[N];
void add(int u,int v,ll w){
	E[u].push_back({v,w});
}
int main(){
	cin>>n>>m>>V>>T;
	for(int i=1;i<=n;i++) dis[i]=num(n+1,0);//等同初始最大
	dis[T]=num(0,0);//起点
	pq.push({T,dis[T]});//起点放入优先队列
	while(m--){//存边
		ll u,v,w;cin>>u>>v>>w;add(v,u,w);add(u,v,w);
	}
	while(!pq.empty()){
		int u=pq.top().v;pq.pop();
		for(int i=0;i<E[u].size();i++){
			eg z=E[u][i];
			if(dis[u]+z.w<dis[z.v])
				pq.push({z.v,dis[z.v]=dis[u]+z.w});
		}
		while(!pq.empty()&&dis[pq.top().v]<pq.top().w) pq.pop();
	}
	for(int i=1;i<=n;i++){
		if(dis[i].v<=n) cout<<dis[i].v+1<<" ";
		else cout<<"-1 ";
	}
}

Problem M. Teleporter

题意：

有n个城市，每个城市有n-1条道路连接，每条道路有w的权值花费。每个城市互相到达，形成一棵树。

有m条传送路径，连接某两座城市，无需任何代价即可到达。

想知道使用传送阵不超过k次，从1到各个城市的最小花费之和。

数据范围:1<=n<=5000,0<=m<=10000,1<=w<=10,0<=k<=n

题解：

分层图做这道题目超时是因为每一层中有很多重复的路径。

把每一层分开算，计算一下在走了 i-1 条附加边的基础上再走一条会给哪几个点的dist缩小。然后用这几个点跑最短路即可。

时间复杂度是 $O(n^2\log n+nm)$ 但是跑不满，还有 $O(n(n+m))$ 。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf=1e18;
int n,m;
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	vector<vector<pair<int,int> > > to(n+1);//存图
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		to[u].push_back({v,w});
		to[v].push_back({u,w});
	}
	vector<pair<int,int> > xl(m);//传送
	for(int i=0;i<m;i++) cin>>xl[i].first>>xl[i].second;
	vector<ll> dis(n+1,inf);
	priority_queue<pair<ll,int>,vector<pair<ll,int> >,greater<> > q;
	q.push({0,1});
	dis[0]=dis[1]=0;
	vector<int> in(n+1);
	auto dj=[&]{
		in.assign(n+1,0);
		while(!q.empty()){
			auto [t,now]=q.top();q.pop();
			if(in[now]) continue;
			in[now]=true;
			for(auto &[e,d1]:to[now]){
				if(d1+t<dis[e]){
					dis[e]=d1+t;
					q.push({dis[e],e});
				}
			}
		}
		return accumulate(dis.begin(),dis.end(),0ll);
	};
	cout<<dj()<<"\n";
	for(int k=1;k<=n;k++){
		vector<ll> nw(dis);
		for(auto &[a,b]:xl){
			nw[a]=min(nw[a],dis[b]);
			nw[b]=min(nw[b],dis[a]);
		}
		for(int i=1;i<=n;i++){
			if(nw[i]<dis[i]) q.push({nw[i],i}),dis[i]=nw[i];
		}
		cout<<dj()<<"\n";
	}
	return 0;
}

不定积分

2025-08-18T00:00:00+00:00

第四章不定积分

一、不定积分的概念与性质

微分：知道原函数求导数

积分：知道导数求原函数

原函数存在定理 ：函数如果在区间上连续，在区间上一定存在原函数。

不定积分 ：

函数在区间上所有原函数的一般表达式 $\int f(x) dx=F(x)+C$

基本积分表

1) $\int k~dx=kx +C$

2) $\int x^{\alpha }~dx=\frac{1}{\alpha +1}x^{\alpha +1} +C$

3) $$\int\frac{1}{x}~dx=\ln{

}+C$$

4) $\int a^x~dx=\frac{a^x}{\ln a} +C$

5) $\int e^x~dx=e^x +C$

6) $\int\sin x~ dx=-\cos x +C$

7) $\int \cos x ~dx=\sin x +C$

8) $\int \sec^2x~ dx=\tan x +C$

9) $\int \csc^2 x~dx=-\cot x +C$

10) $\int \sec x\tan x~dx=\sec x +C$

11) $\int \csc x\cot x~dx=-\csc x +C$

12) $\int \frac{1}{\sqrt{1-x^2}}~dx=\arcsin x +C$

13) $\int \frac{1}{1+x^2}~dx=\arctan x +C$

不定积分的性质

1) $\int [f(x)\pm g(x)]dx=\int f(x)dx\pm \int g(x)dx$

2) $\int kf(x)dx=k\int f(x)dx$

可用于分项积分法。

二、换元定积分法

三、分部积分法

四、有理函数的积分

25年睿抗国赛题解

2025-08-17T00:00:00+00:00

2025年(RAICOM)睿抗机器人开发者大赛CAIP国赛题解

RC-u1 谁拿冠军了？

很久没敲代码，第一题写法太唐了，花的时间也很多。

利用结构体和map，存储每一天的操作，使用数组也可以。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n,m,a1,a2,b1,b2,b3;
int ans1,ans2;
struct nod{
	int c1;
	int c2;
	int c3;
};
unordered_map<int,nod> mp;
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	cin>>a1>>a2>>b1>>b2>>b3;
	for(int i=1;i<=n;i++){
		int d,op;cin>>d>>op;
		if(op==1) mp[d].c1++;
		else if(op==2) mp[d].c2++;
		else mp[d].c3++;
	}
	for(int i=1;i<=m;i++){
		int t,op;cin>>t>>op;
		int tmp1=0,tmp2=0;
		if(op==1&&mp[t].c1!=0){
			tmp1=mp[t].c1*a1;
			tmp2=mp[t].c1*b1;
			tmp2/=2;
			ans1+=tmp1,ans2-=tmp2;
			mp[t].c1=0;
		}else if(op==2&&mp[t].c2!=0){
			tmp2=mp[t].c2*b2;
			tmp2/=2;
			ans2-=tmp2;
			mp[t].c2=0;
		}else if(op==3&&mp[t].c3!=0){
			tmp1=mp[t].c3*a2;
			tmp2=mp[t].c3*b3;
			tmp2/=2;
			ans1-=tmp1,ans2-=tmp2;
			mp[t].c3=0;
		}
	}
	unordered_map<int,nod>::iterator it=mp.begin();
	for(;it!=mp.end();it++){
		nod d=(*it).second;
		int tmp1,tmp2;
		if(d.c1!=0){
			tmp1=d.c1*a1;
			tmp2=d.c1*b1;
			ans1+=tmp1,ans2-=tmp2;
		}
		if(d.c2!=0){
			tmp2=d.c2*b2;
			ans2-=tmp2;
		}
		if(d.c3!=0){
			tmp1=d.c3*a2;
			tmp2=d.c3*b3;
			ans1-=tmp1,ans2-=tmp2;
		}
	}
	cout<<ans1<<" "<<ans2;
	return 0;
}

RC-u2 理包

一开始思路错了，等想到正确思路时，已经过去二十分钟了。

我使用一个c数组存储每次输入图形，再去除掉周围空白的，压缩到b数组中，再一个个点尝试放入a数组中。代码还可以更简单。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int N,M,n,m,q,sh,sl,zz,yy,ss,xx;
int a[55][55],b[55][55],c[55][55];
bool pan(int x,int y){
	for(int i=1;i<=xx-ss+1;i++){
		for(int j=1;j<=yy-zz+1;j++){
			if(x+i-1>N||y+j-1>M) return 0;
			if(b[i][j]==1&&a[x+i-1][y+j-1]==1) return 0;
		}
	}
	return 1;
}
void cha(int x,int y){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(b[i][j]) a[x+i-1][y+j-1]=1;
		}
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>N>>M>>q;
	while(q--){
		yy=xx=sh=sl=0;
		zz=ss=0x3f3f3f3f;
		cin>>n>>m;
		memset(b,0,sizeof(b));
		memset(c,0,sizeof(c));
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				char ch;cin>>ch;
				if(ch=='*'){
					c[i][j]=1;
					if(sh==0){sh=i,sl=j;}
					zz=min(zz,j),yy=max(yy,j),ss=min(ss,i),xx=max(xx,i);
				}
			}
		}
		for(int i=1;i<=xx-ss+1;i++)
			for(int j=1;j<=yy-zz+1;j++)
				b[i][j]=c[ss+i-1][zz+j-1];
		sh-=ss-1,sl-=zz-1;
		int f=0;
		for(int i=1;i<=N;i++){
			if(f) break;
			for(int j=1;j<=M;j++){
				if(f) break;
				if(pan(i,j)){
					cha(i,j);
					f=1;
					cout<<i+sh-1<<" "<<j+sl-1<<"\n";
				}
			}
		}
		if(!f) cout<<"-1 -1\n";
	}
	return 0;
}

RC-u3 删除屏蔽词

下面首先是我赛时愚蠢代码，再是AC代码。

赛时我没看到第一个字符串长度为2的条件，想骗点分赶快去写第4题，因此直接循环find，总共耗时几分钟就跳了。只拿到15分，亏麻了。

#include<bits/stdc++.h>
using namespace std;
string s,str;
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>s>>str;
	int tmp=str.find(s),ans=0;
	while(tmp!=-1){
		string s1=str.substr(0,tmp);
		string s2=str.substr(tmp+s.size());
		str=s1+s2;
		ans++;
		tmp=str.find(s);
	}
	cout<<ans<<" "<<str;
	return 0;
}

赛后队友刘神说AC了，于是乎发现题目比较简单。

#include<bits/stdc++.h>
using namespace std;
char s[2],str[1000001],x;
int len,ans;
int main(){
	cin>>s[0]>>s[1];
	str[0]=' ';
	while(cin>>x){
		if(x==s[1]&&str[len]==s[0]){
			ans++,len--;
		}else{
			str[++len]=x;
		}
	}
	str[len+1]='\0';
	cout<<ans<<str;
	return 0;
}

RC-u4 穷游

首先说明，我下面代码只拿到28分，有一个特例没拿到，没时间改bug，想AC的自己找找。

因为题目要求路径最贵城市的费用尽可能少，所以我们从费用低的城市到费用高的城市一个个找，当起点到终点出现路径时，此时这个路径的最贵城市费用最低。我们再利用比这个费用低的所有城市找出最短路径即可。

我首先利用结构体排序，得到费用从低到高，再利用并查集，一个个加入直至得到起点终点联通，再通过最短路板子得到最短路径即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e3+10,M=3e4+10;
struct edge{
	int v,w;
};
struct nod{
	int len,v;
	friend bool operator > (nod a,nod b){
		return a.len>b.len;
	}
};
vector<edge> vt[N];
int n,m,s,dis[N],vis[N],S,T,tmpz;
int f[N];
int bfind(int x){
	if(f[x]!=x) f[x]=bfind(f[x]);
	return f[x];
}
struct cs{
	int id,cc,gd;
}c[N];
bool cmp(cs a,cs b){
	if(a.cc!=b.cc) return a.cc<b.cc;
	return a.id<b.id;
}
unordered_map<int,int> ump;
priority_queue<nod,vector<nod>,greater<nod> > q;
void dijkstra(){
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[S]=0;
	q.push({0,S});
	while(!q.empty()){
		int u=q.top().v;q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		for(int i=0;i<vt[u].size();i++){
			int v=vt[u][i].v,z=vt[u][i].w;
			if(v>tmpz) continue;
			if(dis[v]>dis[u]+z){
				dis[v]=dis[u]+z;
				q.push({dis[v],v});
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>c[i].cc;
		c[i].id=i;
		f[i]=i;
	}
	sort(c+1,c+n+1,cmp);
	for(int i=1;i<=n;i++) ump[c[i].id]=i;
	for(int i=1;i<=m;i++){
		int v3,v4,t;cin>>v3>>v4>>t;
		int v1=ump[v3],v2=ump[v4];
		vt[v1].push_back({v2,t});
		vt[v2].push_back({v1,t});
	}
	cin>>S>>T;
	S=ump[S],T=ump[T];
	//1.从小到大扩展并查集，直到st出现路径
	for(int i=1;i<=n;i++){
		for(int j=0;j<vt[i].size();j++){
			if(vt[i][j].v<=i){
				int fi=bfind(i),fj=bfind(vt[i][j].v);
				if(f[fi]!=f[fj]) f[fj]=f[fi];
			}
		}
		if(bfind(S)==bfind(T)){
			tmpz=i;
			break;
		}
	}
	//2.st的连通块中找出最短路
	dijkstra();
	cout<<c[tmpz].cc<<" ";
	cout<<dis[T]<<"\n";
	return 0;
}

RC-u5 工序优化

最后时间不够了，这题花了10min不到，写了个贪心拿到14分也差不多了。按照往年最后一题，这题正解应该是DP。（~~向天再借20min我应该能写个DP出来分更高~~）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e3+10;
int n,k,tmp;
ll t[N],p[N],c[N],ans1,ans2;
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>t[i]>>p[i]>>c[i];
	}
	ans1=t[1]*p[1];
	for(int i=2;i<=n;i++){
		ll tmp1=t[i-1]*p[i],tmp2=t[i]*p[i];
		if(tmp1<tmp2&&k){
			ans1+=tmp1;
			ans2+=c[i];
			k--;
			t[i]=t[i-1];
		}else ans1+=tmp2;
	}
	cout<<ans1<<" "<<ans2<<"\n";
	return 0;
}

第三章微分中值定理与导数应用

2025-08-04T00:00:00+00:00

第三章微分中值定理与导数应用

一、微分中值定理

费马引理：若 $f(x)$ 在 $x_0$ 处取得极值，且在这点可导，则 $f^{'}(x_0)=0$ 。

1.罗尔定理

如果函数 $f(x)$ 在闭区间 $[a,b]$ 上连续，在开区间 $(a,b)$ 可导，

并且端点函数值 $f(a)=f(b)$ 相等，那么在区间 $(a,b)$ 内至少有一点 $c$ 使得 $f^{'}(c)=0$ 。

即若函数可导，已知两点函数值相等，则两点之间必定存在极值点。

2.拉格朗日中值定理

如果函数 $f(x)$ 在闭区间 $[a,b]$ 上连续，在开区间 $(a,b)$ 可导，

那么在区间 $(a,b)$ 内至少有一点 $c$ 使得 $f(b)-f(a)=f^{'}(c)(b-a)$ 。

即在任意两点的区间内，必定存在一点的切线平行于两端点的直线，即 $\frac {f(b)-f(a)}{b-a}=f^{'}(c)$ 。

推导：若某函数在区间内恒等于一个常数，则导数恒等于 0 。

3.柯西中值定理

如果函数 $f(x)$ 和 $F(x)$ 在闭区间 $[a,b]$ 上连续，在开区间 $(a,b)$ 可导，

并且 $y=f(x)$ 和 $x=F(x)$ ，且 $F^{'}(x) \neq 0$ ，则在区间内至少有一点 $c$ 使得 $\frac {f(b)-f(a)}{F(b)-F(a)}=\frac {f^{'}(c)}{F^{'}(c)}$ 。

最常用的方法，构造辅助函数，应用微分中值定理。

微分中值定理的应用

证明恒等式
证明不等式
证明有关中值问题的结论

二、洛必达法则

若下面条件满足

\[\lim\limits_{x \to x_0} f(x)=\lim\limits_{x \to x_0} g(x)=0\]
都可导且 $g^{'}(x) \neq 0$
$\lim\limits_{x \to x_0} \frac {f^{'}(x)}{g^{'}(x)}$ 存在或无穷

则

\[\lim\limits_{x \to x_0} \frac{f(x)}{g(x)}=\lim\limits_{x \to x_0} \frac{f^{'}(x)}{g^{'}(x)}\]

可以通过柯西中值定理推导出来。

三、泰勒公式

第一个泰勒公式

\[\begin{aligned} &P_n(x)=\sum_{k=0}^{n} \frac {f^{(k)}(x_0)}{k!}(x-x_0)^k\\ &=f(x_0)+f^{'}(x_0)(x-x_0)+\frac {f^{''}(x_0)}{2!}(x-x_0)^2+...+\frac {f^{(n)}(x_0)}{n!}(x-x_0)^n ,(1)\\ &R_n(x)=o((x-x_0)^n) ,(2)\\ &f(x)=p_n(x)+R_n(x),(3) \end{aligned}\]

多项式 (1) 称为函数 $f(x)$ 在 $x_0$ 处的 n 次泰勒多项式

公式 (2) 称为佩亚诺余项

公式 (3) 称为 $f(x)$ 在 $x_0$ 处的带有佩亚诺余项的 n 阶泰勒公式

如果取 $x_0=0$ ，那么公式为带有佩亚诺余项的麦克劳林公式

\[f(x)=f(0)+f^{'}(0)x+...+\frac{f^{(n)}(0)}{n!}x^n+o(x^n)\]

第二个泰勒公式

\[\begin{aligned} &P_n(x)=\sum_{k=0}^{n} \frac {f^{(k)}(x_0)}{k!}(x-x_0)^k\\ &=f(x_0)+f^{'}(x_0)(x-x_0)+\frac {f^{''}(x_0)}{2!}(x-x_0)^2+...+\frac {f^{(n)}(x_0)}{n!}(x-x_0)^n ,(1)\\ &R_n(x)=\frac{f^{(n+1)}(\xi)}{(n+1)!}(x-x_0)^{n+1} ,\xi \in(x_0,x),(2)\\ &f(x)=p_n(x)+R_n(x),(3) \end{aligned}\]

公式 (2) 称为拉格朗日余项

公式 (3) 称为 $f(x)$ 在 $x_0$ 处带有拉格朗日余项的 n 阶泰勒公式

如果取 $x_0=0$ ，那么公式为带有拉格朗日余项的麦克劳林公式

\[f(x)=f(0)+f^{'}(0)x+\frac{f^{''}(0)}{2!}x^2+...+\frac{f^{(n)}(0)}{n!}x^n+\frac{f^{(n+1)}(\Theta x)}{(n+1)!}x^{n+1},(0<\Theta<1)\]

四、函数单调性与曲线凹凸性

判断函数单调性

函数 $f(x)$ 在区间 $[a,b]$ 上连续，在 $(a,b)$ 内可导，则

（1）如果在 $(a,b)$ 内 $f^{'}(x)≥0$ ，且等号只在有限个点上成立，则 $f(x)$ 在 $[a,b]$ 上单调增加

（2）如果在 $(a,b)$ 内 $f^{'}(x)≤0$ ，且等号只在有限个点上成立，则 $f(x)$ 在 $[a,b]$ 上单调减少

判断凹凸性

如果函数是凹的，则在区间任意两点恒有

\[f(\frac{x_1+x_2}{2})<\frac{f(x_1)+f(x_2)}{2}\]

如果函数是凸的，则在区间任意两点恒有

\[f(\frac{x_1+x_2}{2})>\frac{f(x_1)+f(x_2)}{2}\]

函数 $f(x)$ 在区间 $[a,b]$ 上连续，在 $(a,b)$ 内具有一阶导数和二阶导数，则

（1）如果在 $(a,b)$ 内 $f^{''}(x)>0$ ，则 $f(x)$ 在 $[a,b]$ 上的图形是凹的

（2）如果在 $(a,b)$ 内 $f^{''}(x)<0$ ，则 $f(x)$ 在 $[a,b]$ 上的图形是凸的

如果曲线在经历某点时，凹凸性改变了，那么就称这点 $(x,f(x))$ 为曲线的拐点。

求拐点步骤：

(1) 求 $f^{''}(x)$ ；
(2) 令 $f^{''}(x)=0$ ，解出实根，并求出 $f^{''} (x)$ 不存在的点；
(3) 对第二步求出的点进行判断，如果点两侧 $f^{''}(x)$ 的符号不相同，则是拐点。

五、函数的极值与最值

1.极值

在 $x_0$ 的某个去心邻域内任意 $f(x)<f(x_0)$，则称 $f(x_0)$ 是函数 $f(x)$ 的一个极大值。

在 $x_0$ 的某个去心邻域内任意 $f(x)>f(x_0)$，则称 $f(x_0)$ 是函数 $f(x)$ 的一个极小值。

极值点的导数必定为 0，但是导数为 0 的点不一定是极值点。

若邻域左边导数大于0，右边导数小于0，则在这点的函数值为极大值。

若邻域左边导数小于0，右边导数大于0，则在这点的函数值为极小值。

若函数在 $x_0$ 处具有二阶导数且 $f^{'}(x_0)=0$，$f^{''}(x_0) ≠ 0$，则

当 $f^{''}(x_0)<0$ 时，函数 $f(x)$ 在 $x_0$ 处取得极大值；
当 $f^{''}(x_0)>0$ 时，函数 $f(x)$ 在 $x_0$ 处取得极小值。

2.最值

求连续函数 $f(x)$ 在 $[a,b]$ 上的最值：

求出 $f(x)$ 在 $(a,b)$ 内的驻点和不可导的点
求出第一步点的所有函数值和两个边界函数值
比较以上各点函数值

六、函数图像描绘

利用导数描绘图形的步骤：

确定函数的定义域和函数特性（奇偶性和周期性）
求一阶导数和二阶导数，并求出两个导数为0和不存在的点
列表，判别增减及凹凸区间，求出极值和拐点
求水平渐近线和垂直渐近线
确定某些特殊点，描绘函数图形

七、曲率

曲率：描述一个点在函数图形上弯曲程度的一个量

弧微分公式： $ds=\sqrt{1+y^{'2}} dx$

曲率公式：$$K=

\frac{d~\alpha }{ds}

=\frac{

y^{‘’}

}{(1+y^{‘2})^{\frac{3}{2}}}$$

曲率半径：$R=\frac{1}{K}$

图论学习

2025-08-04T00:00:00+00:00

图论

1.图的存储
2.拓扑排序
3.欧拉路
4.无向图的连通性
5.有向图的连通性
6.基环树
7.2-SAT
8.最短路径
9.最小生成树
10.最大流
11.二分图
12.最小割
13.费用流

1.图的存储

邻接矩阵和邻接表

链式前向星

链式前向星没有空间浪费，编程简单。

一个静态数组 $head[u]$ 存储以 $u$ 为起点，到相邻点的某一条边。

一个结构体数组 $edge$ 存储这条边的信息，包括终点、边权等。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5,M=2e6+5;
int head[N],cnt;
struct{
	int from,to,next;//起点,终点,起点的其他邻接点
	int w;//边权
}edge[M];
void addedge(int u,int v,int w){
	edge[cnt].from=u;
	edge[cnt].to=v;
	edge[cnt].w=w;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}
int main(){
	int n,m;cin>>n>>m;
	for(int i=0;i<m;i++){
		int u,v,w;cin>>u>>v>>w;
		addedge(u,v,w);
	}
	for(int i=0;i<=n;i++)
		printf("h[%d]=%d,",i,head[i]);
	printf("\n");
	for(int i=head[2];i!=-1;i=edge[i].next)
		printf("%d-%d\n",edge[i].from,edge[i].to);
	return 0;
}

2.拓扑排序

在图中求一个有先后关系的排序，这就是拓扑排序。

拓扑排序可以找到图中的环。

基于BFS的拓扑排序

a. 无前驱的顶点优先

就是先输出入度为0的点。

步骤如下：

找到所有入度为0的点，放入队列作为起点，找不到说明图不是DAG，不存在拓扑排序
队首弹出，所有邻居点入度减1，入度为0的邻居点入队
重复操作，直到队列为空
队列已空还有点未入队，说明图上存在环

b.无后继的顶点优先

就是先输出出度为0的点。

时间复杂度都为 $O(n+m)$ 。

如果要输出字典序最小的拓扑排序，可以将队列改为优先队列。

基于DFS的拓扑排序

从入度为0的点开始DFS，递归返回的就是拓扑排序。

多个入度为0的点都执行DFS。

时间复杂度 $O(n+m)$。

1270 – Following Orders

我的评价是poj好烂，只允许国外访问，并且语言版本太老了

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=30,M=2e6+5;
int n,a[N],dir[N][N];//dir[i][j]=1表示ij是先后关系
int topo[N],vis[N],indegree[30];//topo拓扑排序,indegree入度,vis是否访问
void dfs(int z,int cnt){
	topo[cnt]=z;//记录拓扑排序
	if(cnt==n-1){//所有点都取完了
		for(int i=0;i<n;i++)
			printf("%c",topo[i]+'a');
		printf("\n");
	}
	vis[z]=1;//标记为已访问
	for(int i=0;i<n;i++)
		if(!vis[a[i]]&&dir[z][a[i]])
			indegree[a[i]]--;//把所有下属的入度-1
	for(int i=0;i<n;i++)
		if(!indegree[a[i]]&&!vis[a[i]])//入度为0的点继续取
			dfs(a[i],cnt+1);
	for(int i=0;i<n;i++)//把下属的入度复原
		if(!vis[a[i]]&&dir[z][a[i]])
			indegree[a[i]]++;
	vis[z]=0;//恢复
}
int main(){
	char s[100];
	int len;
	while(gets(s)!=NULL){
		memset(dir,0,sizeof(dir));
		memset(vis,0,sizeof(vis));
		memset(indegree,0,sizeof(indegree));
		len=strlen(s);
		n=0;
		for(int i=0;i<len;i++)
			if(s[i]<='z'&&s[i]>='a')
				a[n++]=s[i]-'a';
		sort(a,a+n);
		gets(s);
		len=strlen(s);
		int first=1;//表示当前字母是起点
		for(int i=0;i<len;i++){//处理先后关系
			int st,ed;
			if(first&&s[i]<='z'&&s[i]>='a'){//起点
				first=0;
				st=s[i]-'a';//把字母转换为数字
				continue;
			}
			if(!first&&s[i]<='z'&&s[i]>='a'){//终点
				first=1;
				ed=s[i]-'a';
				dir[st][ed]=1;//记录先后关系
				indegree[ed]++;//终点入度+1
				continue;
			}
		}
		for(int i=0;i<n;i++)
			if(!indegree[a[i]])//所有入度为0的点开始
				dfs(a[i],0);
		printf("\n");
	}
	return 0;
}

1094 – Sorting It All Out

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=30;
int ANS[N],TMP[N],IN[N],MAP[N][N];
int n,m,ans,sz,f;
char S[10];
queue<int> q;
int topo(){
	sz=0,f=0;
	while(!q.empty()) q.pop();//清空q队列
	for(int i=1;i<=n;i++)
		if(TMP[i]==0){//入度为0，放入队列
			q.push(i);
			TMP[i]--;//入度变为-1
		}
	while(!q.empty()){
		if(q.size()>1) f=-1;//如果q队列包含多个入度为0的，方案不唯一
		int i=q.front();
		q.pop();
		ANS[++sz]=i;
		for(int j=1;j<=n;j++){
			if(MAP[i][j]) TMP[j]--;//邻接点，入度都--
			if(TMP[j]==0){//为空则放入队列
				q.push(j);
				TMP[j]--;
			}
		}
	}
	for(int i=1;i<=n;i++)
		if(TMP[i]!=-1)//存在点未取到
			return -1;
	if(f==-1) return 0;//q数组不为空
	return 1;
}
int main(){
	while(scanf("%d%d",&n,&m)&&n&&m){
		memset(IN,0,sizeof(IN));
		memset(MAP,0,sizeof(MAP));
		ans=0;//三种状态
		for(int i=1;i<=m;i++){
			scanf("%s",S);
			if(ans!=0) continue;//状态确定，只输入
			int a=S[0]-'A'+1,b=S[2]-'A'+1;
			if(!MAP[b][a]) IN[a]++;//a的入度++
			MAP[b][a]=1;//从b到a有关联
			for(int j=1;j<=n;j++) TMP[j]=IN[j];//将入度复制，只修改TMP
			ans=topo();
			if(ans==1){
				printf("Sorted sequence determined after %d relations: ", i);
				for(int j=n;j>=1;j--)//从后往前输出
					printf("%c",ANS[j]+'A'-1);
				printf(".\n");
			}
			if(ans==-1) printf("Inconsistency found after %d relations.\n", i);
			
		}
		if(ans==0) printf("Sorted sequence cannot be determined.\n");
	}
	return 0;
}

P1113 杂务 - 洛谷

#include<bits/stdc++.h>
using namespace std;
const int N=10010;
int n;
int a[N],f[N];//a单独每个事情时间,f完成这个事情最少时间
vector<int> edge[N];
int dfs(int x){
	if(f[x]) return f[x];
	for(int i=0;i<edge[x].size();i++){
		f[x]=max(f[x],dfs(edge[x][i]));//第x件事最少时间
	}
	f[x]+=a[x];
	return f[x];
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		int x,y;
		cin>>x>>a[i]>>y;
		while(y!=0){
			edge[y].push_back(x);cin>>y;
		}
	}
	int ans=0;
	for(int i=1;i<=n;i++) ans=max(ans,dfs(i));
	cout<<ans<<"\n";
	return 0;
}

P1347 排序 - 洛谷

//与上面poj 1094题意相同

P1685 游览 - 洛谷

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e4+10;
const ll mod=10000;
int n,m,s,t,ti,tot,h[N],in[N];//h,in入度
//h数组链式前向星
ll cnt[N],dis[N];//cnt次数,dis距离
struct nod{
	int nex,to,dis;
}edge[N<<1];
void add(int u,int v,int w){
	edge[++tot].nex=h[u];//记录兄弟
	edge[tot].to=v;//终点
	edge[tot].dis=w;//权值
	h[u]=tot;//更新链式前向星数组
	in[v]++;//入度
}
void dfs(int x){
	for(int i=h[x];i!=0;i=edge[i].nex){//遍历x的所有邻接点
		int xx=edge[i].to;//子节点
		dis[xx]=(dis[xx]+dis[x]+cnt[x]*edge[i].dis)%mod;//更新子节点的距离
		cnt[xx]=(cnt[xx]+cnt[x])%mod;
		--in[xx];//拓扑排序
		if(in[xx]==0) dfs(xx);
	}
}
int main(){
	cin>>n>>m>>s>>t>>ti;
	for(int i=1,u,v,w;i<=m;i++){
		cin>>u>>v>>w;
		if(u!=v) add(u,v,w);
	}
	cnt[s]=1;
	dfs(s);
	cout<<((dis[t]+(cnt[t]-1)*ti)%mod);
	return 0;
}

P3243 [HNOI2015] 菜肴制作 - 洛谷

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int t,n,m,x,y,cnt;
int in[N],ans[N];
vector<int> vec[N];
priority_queue<int> que;
void solve(){
	cin>>n>>m;
	cnt=0;
	for(int i=1;i<=n;i++) ans[i]=in[i]=0;//初始化
	for(int i=1;i<=n;i++) vec[i].clear();
	for(int i=1;i<=m;i++){
		cin>>x>>y;
		in[x]++;
		vec[y].push_back(x);//反向建边
	}
	for(int i=1;i<=n;i++)
		if(in[i]==0) que.push(i);//入度为0
	while(!que.empty()){
		int u=que.top();
		que.pop();
		for(int i=0;i<vec[u].size();i++){
			int x=vec[u][i];
			in[x]--;
			if(in[x]==0) que.push(x);
		}
		ans[++cnt]=u;
	}
	if(cnt<n) cout<<"Impossible! ";
	else
		for(int i=cnt;i>=1;i--) cout<<ans[i]<<" ";
	cout<<"\n";
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0);
	int t;cin>>t;
	while(t--) solve();
	return 0;
}

P4017 最大食物链计数 - 洛谷

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e3+10;
const int M=5e5+10;
const ll mod=80112002;
int n,m,f[N],cnt,in[N];
ll ans,dp[N];
struct nod{
	int nex,to;
}edge[M];
queue<int> q;
int main(){
	ios::sync_with_stdio(0),cin.tie(0);
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int x,y;cin>>x>>y;
		edge[++cnt].to=y;
		edge[cnt].nex=f[x];
		f[x]=cnt;
		in[y]++;
	}
	for(int i=1;i<=n;i++)
		if(!in[i]){
			q.push(i);
			in[i]--;
			dp[i]=1;
		}
	while(!q.empty()){
		int x=q.front();q.pop();
		if(f[x]==0){
			ans=(ans+dp[x])%mod;
			in[x]--;
			continue;
		}
		for(int i=f[x];i!=0;i=edge[i].nex){
			int y=edge[i].to;
			dp[y]=(dp[y]+dp[x])%mod;
			in[y]--;
			if(!in[y]){
				q.push(y);
				in[y]--;
			}
		}
	}
	cout<<ans<<"\n";
	return 0;
}

3.欧拉路

欧拉路：一笔画

欧拉回路：一笔画并且起点终点相同

无向图判断条件：

必须是联通图
所有点度数都为偶，则存在欧拉回路
只有两个度数为奇，则存在欧拉路

有向图判断条件：

必须是连通图
出度记为1，入度记为-1，度数为相加
所有点度数为0，则存在欧拉回路
只有一个度数为1和一个度数为-1，则存在欧拉路

The Necklace - UVA 10054 - Virtual Judge

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=60;
int n,m,in[N],G[N][N];
void euler(int u){//输出欧拉回路
	for(int v=1;v<=50;v++){
		if(G[u][v]){
			G[u][v]--;
			G[v][u]--;
			euler(v);
			cout<<v<<" "<<u<<"\n";
		}
	}
}
void solve(){
	memset(in,0,sizeof(in));
	memset(G,0,sizeof(G));
	cin>>n;
	for(int i=0;i<n;i++){
		int u,v;cin>>u>>v;
		m=u;
		in[u]++,in[v]++;
		G[u][v]++,G[v][u]++;
	}
	for(int i=1;i<=50;i++)
		if(in[i]%2){
		cout<<"some beads may be lost\n";
		return;
	}
	euler(m);//从任意点开始
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0);
	int t;cin>>t;
	for(int i=1;i<=t;i++){
		cout<<"Case #"<<i<<"\n";
		solve();
		cout<<"\n";
	}
	return 0;
}

1780 – Code

#include<stdio.h>
const int N=60;
int num[N];//num[v]为点v后加的数字
int st_edge[10*N],top_s;//栈,用于存边,top_s栈顶
char st_ans[10*N];int top_a;//存序列结果,top_a栈顶
int m;
void nodfs(int v){//模拟递归,搜索v的10条边
	int edge;
	while(num[v]<10){
		edge=10*v+num[v];
		num[v]++;
		st_edge[top_s++]=edge;
		v=edge%m;
	}
}
int main(){
	int n,edge;
	while(scanf("%d",&n)&&n!=0){
		top_s=top_a=edge=0;
		m=1;
		for(int i=0;i<n-1;i++) m*=10;//m是点的数量
		for(int i=0;i<m;i++) num[i]=0;
		nodfs(0);//从起点0开始,递归点0的10条边
		while(top_s){//继续走
			edge=st_edge[--top_s];
			st_ans[top_a++]=edge%10+'0';
			nodfs(edge/10);
		}
		for(int i=1;i<n;i++) printf("0");
		while(top_a) printf("%c",st_ans[--top_a]);
		printf("\n");
	}
	return 0;
}

P1341 无序字母对 - 洛谷

#include<bits/stdc++.h>
using namespace std;
const int N=257;
int G[N][N],depth[N],n,cnt,hen,f[N],sum[N];
char tmp[N],rb[N*N];
void dfs(int x){
	for(int i=0;i<N;i++)
		if(G[x][i]) G[x][i]=G[i][x]=0,dfs(i);
	rb[n--]=x;
}
int find(int x){
	if(f[x]!=x) f[x]=find(f[x]);
	return f[x];
}
int main(){
	cin>>n;
	for(int i=0;i<N;i++) f[i]=i;
	for(int i=1;i<=n;i++){
		cin>>tmp;int a=tmp[0],b=tmp[1];
		G[a][b]=G[b][a]=1;
		int fx=find(a),fy=find(b);
		f[fx]=fy;//并查集
		depth[a]++,depth[b]++;//度数
	}
	int ans=0;
	for(int i=0;i<N;i++)
		if(f[i]==i&&depth[i]) ans++;
	if(ans!=1){//不是整个连通块
		cout<<"No Solution";return 0;
	}
	for(int i=0;i<N;i++)
		if(depth[i]%2!=0){//奇数
			cnt++;
			if(!hen) hen=i;
		}
	if(hen==0)//任意点为起点，欧拉回路
		for(int i=0;i<N;i++)
			if(depth[i]){
			hen=i;break;//记录第一个字母
		}
	if(cnt&&cnt!=2){//度数为奇的点大于两个
		cout<<"No Solution";return 0;
	}
	dfs(hen);
	cout<<rb;
	return 0;
}

P1333 瑞瑞的木棍 - 洛谷

8.最短路径

最短路问题答案是可加的，网络流问题答案是不可加的，如权值最小的边等。

使用DFS查找所有路径，共有 $n!$ 个排列。

没有边权的图可以使边权等于一。

算法	问题	边权要求	时间复杂度
BFS	一个起点到所有点	无边权或为1	$<O(m+n)$
Dijkstra(优先队列)	一个起点到所有点	非负数	$<O((m+n)\log_2n)$
SPFA	一个起点到所有点	允许有负数	$<O(mn)$
Floyd-Warshall	所有点到所有点	允许有负数	$<O(n^3)$

Dijkstra(优先队列)

边权必须非负。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n,m,s,inf=0x3f3f3f3f;
struct edge{//边
	int v,w;
};
struct node{//点
	int len,u;//len=起点到u的距离
	friend bool operator >(node a,node b){
		return a.len>b.len;
	}
};
vector<edge> vt[N];//邻接表
int dis[N],vis[N];//距离，是否访问
priority_queue<node,vector<node>,greater<node> > q;
void dijkstra(){
	memset(dis,inf,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[s]=0;//起点
	q.push({0,s});//放入起点
	while(!q.empty()){
		int u=q.top().u;q.pop();//取出顶点
		if(vis[u]) continue;//如果已访问
		vis[u]=1;//设置访问
		for(int i=0;i<vt[u].size();i++){//遍历u的所有子节点
			int v=vt[u][i].v,w=vt[u][i].w;
			if(dis[v]>dis[u]+w){//更新子节点
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m>>s;
	int ansinf=(1<<31)-1;
	while(m--){
		int u,v,w;cin>>u>>v>>w;
		vt[u].push_back({v,w});
	}
	dijkstra();
	for(int i=1;i<=n;i++){
		if(dis[i]==inf) cout<<ansinf<<" ";
		else cout<<dis[i]<<" ";
	}
	return 0;
}

第二章导数与微分

2025-08-03T00:00:00+00:00

第二章导数与微分

一、基本函数求导法则

(1) 常数

\[(C)^{'}=0\]

(2) 幂函数

\[(x^{u})^{'}=ux^{u-1}\]

(3) 指数函数

\[(a^{x})^{'}=a^{x} \ln a\]

(4) 对数函数

\[(\log_a x)^{'}=\frac {1}{x\ln a}\]

(5)三角函数

\[(\sin x)^{'}=\cos x \\(\cos x)^{'}=- \sin x \\(\tan x)^{'}=\sec^2 x \\(\sec x)^{'}=\sec x \tan x \\(\csc x)^{'}=- \csc x \cot x \\(\arcsin x)^{'}=\frac {1}{\sqrt{1-x^{2}}} \\(\arccos x)^{'}=- \frac {1}{\sqrt{1-x^{2}}} \\(\arctan x)^{'}=\frac {1}{1+x^{2}} \\(\mathrm{arccot}~ x)^{'}=- \frac {1}{1+x^{2}}\]

二、和差积商的求导法则

(1) 和差

\[[u \pm v]^{'}=u^{'} \pm v^{'}\]

(2) 积

\[[uv]^{'}=u^{'}v+ uv^{'}\]

(3) 商

\[[\frac {u}{v}]^{'}=\frac {u^{'}v - uv^{'}}{v^{2}}\]

三、反函数的求导法则

反函数的导数等于函数导数的倒数

\[[f^{-1}(x)]^{'}=\frac{1}{f^{'}(y)}\]

四、复合函数的求导法则（链式法则）

\[\frac{dy}{dx}=f^{'}(u) \cdot g^{'}(x)\]

五、高阶导数

(1) 归纳法

求一阶二阶三阶等归纳总结出高阶导数公式

(2) 公式法

a.加法

\[(u \pm v)^{(n)}=u^{(n)}+v^{(n)}\]

b.乘法（莱布尼茨公式）

\[(uv)^{(n)}=\sum_{k=0}^n C^k_nu^{(n-k)}v^{(k)}\]

六、隐函数和参数方程函数的导数

显函数：$y=由x构成的式子$

隐函数：由y和x的构成的式子，如 $x-\sqrt y=1$

隐函数求导：两边同时对x进行求导，并且将y看作一个x构成的表达式

\[y^5+2y-x=0的导数\\ \Rightarrow 5y^4y^{'}+2y^{'}-1=0\\ \Rightarrow y^{'}=\frac {1}{5y^4+2}\]

对数求导法：有些无法直接求导的表达式，可以先取对数，然后进行隐函数求导

参数方程：多个方程组构成

\[\left\{ \begin{array}{ll} x = g(t), \\ y = h(t) \end{array} \right.\]

参数方程一阶求导：

\[\frac {dy}{dx}=\frac {dy}{dt} \frac {dt}{dx}=h^{'}(t) g^{-1}(x)=\frac {h^{'}(t)}{g^{'}(t)}\]

二阶求导：注意分母为三次方

\[\frac {d^2y}{dx^2}=\frac {d}{dt} (\frac{h^{'}(t)}{g^{'}(t)}) \cdot \frac {dt}{dx} =\frac {h^{''}(t)g^{'}(t)-h^{'}(t)g^{''}(t)}{g^{'3}(t)}\]

相关变化率：知道一个变化率，求另一个依赖的变化率

建立两个相关变化量的关系式，求导

七、函数的微分

可以理解为

\[若y=f(x)，\\则dy=f^{'}(x) dx\]

也可理解为

\[因为 \frac {dy}{dx}=f^{'}(x)\\ 所以 dy=f^{'}(x) dx\]

网站logo修改及添加博客图片

2025-06-25T00:00:00+00:00

图片改进

网站logo由

修改为

并且网站主页背景图片也进行了修改。

重大改进

之前博客插入图片，采用绝对路径或者相对路径，采用md的插入方法或者html的插入方法，都无法在网站中显示出来，在github和typora都显示正常。

在路径中使用 “\” 或者 “/” 都可正常显示，区别不大。

正常显示语法可以采用html的图片插入格式，但路径需为绝对路径，且为根地址。

<img src="/_posts/assets/2025-04-06_17-35-54.png" style="zoom:50%;" />

但是这能在网站上正常显示，本地却显示不了，因此后续我博客中图片将使用两次插入，以实现本地与网站皆能显示，直到我完善网站功能后。

如下代码所示：

<img src="/_posts/assets/2025-04-06_17-35-54.png" style="zoom:50%;" />
<img src="assets/2025-04-06_17-35-54.png" style="zoom:50%;" />

为了方便调用，后续我图片也会按照日期时间保存在 _posts/assets 目录下。

顺手推荐一个网站，用来转换图片格式和图片压缩等操作，免费好用。

免费在线图片压缩工具

关于图片加载缓慢问题，后面完善网站可采用CDN加速。

算法竞赛（高级数据结构）

2025-06-04T00:00:00+00:00

《算法竞赛》第 4 章高级数据结构

1. 并查集

并查集的基本操作

DSU用于处理一些不相交结合的合并问题。

初始化：表示 s[i] 是元素 i 所属的并查集。

s[i]=i;

查询：查找元素属于哪个并查集。（路径压缩）

int find_set(int x){
    if(x!=s[x]) s[x]=find_set(s[x]);
    return s[x];
}

合并：将两个元素并查集合并一起。

void join(int x,int y){
    int fx=find_set(x),fy=find_set(y);
    if(fx!=fy) s[fx]=s[fy];
}

统计：s[i]=i 的数量就是并查集的数量。

带权并查集

额外定义一个权值数组 d[] ，把节点 i 到父节点的权值记为 d[i] 。

带权路径压缩查询

int find_set(int x){
	if(x!=s[x]){
		int t=s[x];//记录父节点
		s[x]=find_set(s[x]);//路径压缩
		d[x]+=d[t];//更新x到祖宗节点的权值
	}
	return s[x];
}

带权合并：根据具体题意修改

例题

Problem - 3038

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
int n,m,s[N],d[N],ans;
int find_set(int x){
	if(x!=s[x]){
		int t=s[x];//记录父节点
		s[x]=find_set(s[x]);//路径压缩
		d[x]+=d[t];//更新x到祖宗节点的权值
	}
	return s[x];
}
void join(int x,int y,int z){//合并
	int fx=find_set(x),fy=find_set(y);
	if(fx==fy){
		if(d[x]-d[y]!=z) ans++;
	}else{
		s[fx]=fy;
		d[fx]=d[y]-d[x]+z;
	}
}
void solve(){
	for(int i=0;i<N;i++) s[i]=i,d[i]=0;
	ans=0;
	for(int i=1;i<=m;i++){
		int x,y,z;cin>>x>>y>>z;
		join(x-1,y,z);
	}
	cout<<ans<<"\n";
}
int main(){
	while(cin>>n>>m) solve();
	return 0;
}

P2024 食物链 - 洛谷

int n,m,k,s[N],d[N],ans;
int find_set(int x){
	if(x!=s[x]){
		int t=s[x];//记录父节点
		s[x]=find_set(s[x]);//路径压缩
		d[x]=(d[t]+d[x])%3;//更新x到祖宗节点的权值
	}
	return s[x];
}
void join(int x,int y,int z){//合并
	int fx=find_set(x),fy=find_set(y);
	if(fx==fy){
		if((z-1)!=((d[x]-d[y]+3)%3)) ans++;
	}else{
		s[fx]=fy;
		d[fx]=(d[y]-d[x]+z-1)%3;
	}
}
void solve(){
	cin>>n>>m;
	for(int i=0;i<N;i++) s[i]=i,d[i]=0;
	ans=0;
	while(m--){
		int x,y,z;cin>>z>>x>>y;
		if(x>n||y>n||(z==2&&x==y)) ans++;
		else join(x,y,z);
	}
	cout<<ans<<"\n";
}

2.树状数组

树状数组可以 $O(log_2n)$ 的时间查询和维护前缀和，前缀和可以用来区间修改或者区间查询。

需要借助一个神奇的函数 #define lowbit(x) ((x)&-(x))。

如果当前节点为 x ，父节点为 x+lowbit(x)。

在树状数组中，每个元素 $tree[]$ 中存储的是区间 $[x-lowbit(x)+1,x]$ 中每个数之和。

单点修改+区间查询

#define lowbit(x) ((x)&-(x))
int tree[N];
void update(int x,int d){//单点修改
	while(x<=N){
		tree[x]+=d;
		x+=lowbit(x);
	}
}
int sum(int x){//查询前缀和
	int ans=0;
	while(x>0){
		ans+=tree[x];
		x-=lowbit(x);
	}
	return ans;
}
void solve(){
	for(int i=1,x;i<=10;i++) update(i,x);//初始计算tree[]数组
	cout<<"[5,8]="<<sum(8)-sum(4)<<"\n";
}

区间修改+单点查询

Problem - 1556

#define lowbit(x) ((x)&-(x))
int tree[N],n;
void update(int x,int d){//单点修改
	while(x<N){
		tree[x]+=d;
		x+=lowbit(x);
	}
}
int sum(int x){//查询前缀和
	int ans=0;
	while(x>0){
		ans+=tree[x];
		x-=lowbit(x);
	}
	return ans;
}
void solve(){
	memset(tree,0,sizeof(tree));
	for(int i=1;i<=n;i++){
		int l,r;cin>>l>>r;
		update(l,1);
		update(r+1,-1);
	}
	for(int i=1;i<=n;i++){
		if(i!=n) cout<<sum(i)<<" ";
		else cout<<sum(i)<<"\n";
	}
}

区间修改+区间查询

P3372 【模板】线段树 1 - 洛谷

ll tree1[N],tree2[N],n,m;
void update1(ll x,ll d){while(x<N){tree1[x]+=d;x+=lowbit(x);}}
void update2(ll x,ll d){while(x<N){tree2[x]+=d;x+=lowbit(x);}}
ll sum1(ll x){ll ans=0;while(x>0){ans+=tree1[x];x-=lowbit(x);} return ans;}
ll sum2(ll x){ll ans=0;while(x>0){ans+=tree2[x];x-=lowbit(x);} return ans;}
void solve(){
	cin>>n>>m;
	ll old=0,x;
	for(int i=1;i<=n;i++){
		cin>>x;
		update1(i,x-old);//差分数组初始化
		update2(i,(i-1)*(x-old));
		old=x;
	}
	while(m--){
		ll q,l,r,d;cin>>q;
		if(q==1){
			cin>>l>>r>>d;
			update1(l,d);
			update1(r+1,-d);
			update2(l,d*(l-1));
			update2(r+1,-d*r);
		}else{
			cin>>l>>r;
			cout<<(r*sum1(r)-sum2(r)-(l-1)*sum1(l-1)+sum2(l-1))<<"\n";
		}
	}
}

二维区间修改+区间查询

P4514 上帝造题的七分钟 - 洛谷

采用CDQ分治更好。

int t1[N][N],t2[N][N],t3[N][N],t4[N][N],n,m;
void update(int x,int y,int d){
	for(int i=x;i<=n;i+=lowbit(i))
		for(int j=y;j<=m;j+=lowbit(j)){
			t1[i][j]+=d;t2[i][j]+=x*d;
			t3[i][j]+=y*d;t4[i][j]+=x*y*d;
		}
}
int sum(int x,int y){
	int ans=0;
	for(int i=x;i>0;i-=lowbit(i))
		for(int j=y;j>0;j-=lowbit(j))
			ans+=(x+1)*(y+1)*t1[i][j]-(y+1)*t2[i][j]-(x+1)*t3[i][j]+t4[i][j];
	return ans;
}
void solve(){
	char ch;cin>>ch;
	cin>>n>>m;
	while(cin>>ch){
		int a,b,c,d,del;cin>>a>>b>>c>>d;
		if(ch=='L'){
			cin>>del;
			update(a,b,del);update(c+1,d+1,del);
			update(a,d+1,-del);update(c+1,b,-del);
		}
		else cout<<sum(c,d)+sum(a-1,b-1)-sum(a-1,d)-sum(c,b-1)<<"\n";
	}
}

3.线段树

线段树与树状数组都是用于解决区间问题的数据结构，时间复杂度一样，但是线段树更清晰易懂，代码长度更长，功能更强大。

P3372 【模板】线段树 1 - 洛谷

线段树模板

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
ll tree[N*4],tag[N*4];
ll ls(int p){return p<<1;}//左儿子,p*2
ll rs(int p){return p<<1|1;}//右儿子,p*2+1
ll a[N];
int n,m;
void push_up(int p){//从下往上传递区间值
	tree[p]=tree[ls(p)]+tree[rs(p)];//求区间和
}
void build(int p,int pl,int pr){//建树
	tag[p]=0;
	if(pl==pr){tree[p]=a[pl];return;}//叶子节点
	int mid=(pl+pr)>>1;
	build(ls(p),pl,mid);//递归左儿子
	build(rs(p),mid+1,pr);//递归右儿子
	push_up(p);//往上传递区间值
}
void addtag(int p,int pl,int pr,ll d){//标记tag,更新tree
	tag[p]+=d;
	tree[p]+=d*(pr-pl+1);
}
void push_down(int p,int pl,int pr){//tag传给子树
	if(tag[p]){
		int mid=(pl+pr)>>1;
		addtag(ls(p),pl,mid,tag[p]);
		addtag(rs(p),mid+1,pr,tag[p]);
		tag[p]=0;
	}
}
void update(int l,int r,int p,int pl,int pr,ll d){//区间修改,[l,r]+d
	if(l<=pl&&pr<=r){
		addtag(p,pl,pr,d);return ;
	}
	push_down(p,pl,pr);
	ll mid=(pl+pr)>>1;
	if(l<=mid) update(l,r,ls(p),pl,mid,d);
	if(r>mid) update(l,r,rs(p),mid+1,pr,d);
	push_up(p);
}
//调用方式：query(l,r,1,1,n);
ll query(int l,int r,int p,int pl,int pr){//查询区间[l,r]的和
	if(l<=pl&&pr<=r) return tree[p];
	push_down(p,pl,pr);
	ll res=0;
	int mid=(pl+pr)>>1;
	if(l<=mid) res+=query(l,r,ls(p),pl,mid);
	if(r>mid) res+=query(l,r,rs(p),mid+1,pr);
	return res;
}
void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	build(1,1,n);
	while(m--){
		int flag,x,y;cin>>flag>>x>>y;
		if(flag==1){
			ll k;cin>>k;
			update(x,y,1,1,n,k);
		}else cout<<query(x,y,1,1,n)<<"\n";
	}
}
int main(){
//	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
		solve();
	return 0;
}

区间最值

Problem - 5306

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+10;
ll sum[N*4],ma[N*4],se[N*4],num[N*4];//区间和,最大值,次大值,最大值个数
ll ls(int p){return p<<1;}//左儿子,p*2
ll rs(int p){return p<<1|1;}//右儿子,p*2+1
//ll a[N];
int n,m;
void push_up(int p){//从下往上传递区间值
	sum[p]=sum[ls(p)]+sum[rs(p)];
	ma[p]=max(ma[ls(p)],ma[rs(p)]);
	if(ma[ls(p)]==ma[rs(p)]){
		se[p]=max(se[ls(p)],se[rs(p)]);
		num[p]=num[ls(p)]+num[rs(p)];
	}else{
		se[p]=max(se[ls(p)],se[rs(p)]);
		se[p]=max(se[p],min(ma[ls(p)],ma[rs(p)]));
		num[p]=ma[ls(p)]>ma[rs(p)]?num[ls(p)]:num[rs(p)];
	}
}
void build(int p,int pl,int pr){//建树
	if(pl==pr){
		cin>>sum[p];
		ma[p]=sum[p];se[p]=-1;num[p]=1;
		return;
	}
	int mid=(pl+pr)>>1;
	build(ls(p),pl,mid);
	build(rs(p),mid+1,pr);
	push_up(p);
}
void addtag(int p,int x){
	if(x>=ma[p]) return;
	sum[p]-=num[p]*(ma[p]-x);
	ma[p]=x;
}
void pushdown(int p){
	addtag(ls(p),ma[p]);
	addtag(rs(p),ma[p]);
}
void update(int l,int r,int p,int pl,int pr,int x){
	if(x>=ma[p]) return;
	if(l<=pl&&pr<=r&&se[p]<x){addtag(p,x);return ;}
	pushdown(p);
	ll mid=(pl+pr)>>1;
	if(l<=mid) update(l,r,ls(p),pl,mid,x);
	if(r>mid) update(l,r,rs(p),mid+1,pr,x);
	push_up(p);
}
//调用方式：query(l,r,1,1,n);
int queryMax(int l,int r,int p,int pl,int pr){//查询区间[l,r]的和
	if(l<=pl&&pr<=r) return ma[p];
	pushdown(p);
	int res=0;
	ll mid=(pl+pr)>>1;
	if(l<=mid) res=queryMax(l,r,ls(p),pl,mid);
	if(r>mid) res=max(res,queryMax(l,r,rs(p),mid+1,pr));
	return res;
}
ll querySum(int l,int r,int p,int pl,int pr){
	if(l<=pl&&r>=pr) return sum[p];
	pushdown(p);
	ll res=0;
	ll mid=(pl+pr)>>1;
	if(l<=mid) res+=querySum(l,r,ls(p),pl,mid);
	if(r>mid) res+=querySum(l,r,rs(p),mid+1,pr);
	return res;
}
void solve(){
	cin>>n>>m;
	build(1,1,n);
	while(m--){
		int q,l,r,x;cin>>q>>l>>r;
		if(q==0){cin>>x;update(l,r,1,1,n,x);}
		if(q==1){cout<<queryMax(l,r,1,1,n)<<"\n";}
		if(q==2){cout<<querySum(l,r,1,1,n)<<"\n";}
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int T;cin>>T;
	while(T--)
		solve();
	return 0;
}

区间合并

Problem - 1540

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e4+10;
ll tree[N*4],pre[N*4],suf[N*4];
ll ls(int p){return p<<1;}//左儿子,p*2
ll rs(int p){return p<<1|1;}//右儿子,p*2+1
int history[N];//记录村庄被毁历史
int n,m;
void push_up(int p,int len){
	pre[p]=pre[ls(p)];//父节点接收子节点的前缀信息
	suf[p]=suf[rs(p)];
	if(pre[ls(p)]==(len-(len>>1))) pre[p]=pre[ls(p)]+pre[rs(p)];//左儿子都是1
	if(suf[rs(p)]==(len>>1)) suf[p]=suf[ls(p)]+suf[rs(p)];//右儿子都是1
}
void build(int p,int pl,int pr){//建树
	if(pl==pr){
		tree[p]=pre[p]=suf[p]=1;
		return;
	}
	int mid=(pl+pr)>>1;
	build(ls(p),pl,mid);
	build(rs(p),mid+1,pr);
	push_up(p,pr-pl+1);
}
void update(int x,int c,int p,int pl,int pr){
	if(pl==pr){tree[p]=suf[p]=pre[p]=c;return ;}//更新叶子节点
	int mid=(pl+pr)>>1;
	if(x<=mid) update(x,c,ls(p),pl,mid);
	else update(x,c,rs(p),mid+1,pr);
	push_up(p,pr-pl+1);
}
int query(int x,int p,int pl,int pr){//查询区间[l,r]的和
	if(pl==pr) return tree[p];
	ll mid=(pl+pr)>>1;
	if(x<=mid){
		if(x+suf[ls(p)]>mid) return suf[ls(p)]+pre[rs(p)];
		else return query(x,ls(p),pl,mid);
	}else{
		if(mid+pre[rs(p)]>=x) return pre[rs(p)]+suf[ls(p)];
		else return query(x,rs(p),mid+1,pr);
	}
}
void solve(){
	int tot=0,x;
	build(1,1,n);
	while(m--){
		char op;cin>>op;
		if(op=='Q'){
			cin>>x;
			cout<<query(x,1,1,n)<<"\n";
		}else if(op=='D'){
			cin>>x;history[++tot]=x;
			update(x,0,1,1,n);
		}else{
			x=history[tot--];
			update(x,1,1,1,n);
		}
	}
}
int main(){
	while(cin>>n>>m)
		solve();
	return 0;
}

扫描线

扫描线是线段树的一种经典运用，能解决矩形面积并、矩形周长并、多边形面积等几何问题。

二维线段树（树套树）

4. 可持久化线段树（主席树）

P3834 【模板】可持久化线段树 2 - 洛谷

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
int n,m,cnt,a[N],b[N],root[N];//a为原数组,b为离散化数组,root为第i颗树根节点编号
struct nod{
	int L,R,sum;//L左儿子,R右儿子,sum为节点i的权值
}tree[N<<5];//32*N差不多够用
int build(int pl,int pr){//初始化一颗空树，可以省略
	int rt=++cnt;//当前节点编号
	tree[rt].sum=0;
	int mid=(pl+pr)>>1;
	if(pl<pr){
		tree[rt].L=build(pl,mid);
		tree[rt].R=build(mid+1,pr);
	}
	return rt;//返回当前节点的编号
}
int update(int pre,int pl,int pr,int x){//建立新线段树
	int rt=++cnt;;
	tree[rt].L=tree[pre].L;
	tree[rt].R=tree[pre].R;
	tree[rt].sum=tree[pre].sum+1;//新加的数
	int mid=(pl+pr)>>1;
	if(pl<pr){//从根节点向下建log2 n个节点
		if(x<=mid)//x出现在左子树，修改左子树
			tree[rt].L=update(tree[pre].L,pl,mid,x);
		else //x出现在右子树，修改右子树
			tree[rt].R=update(tree[pre].R,mid+1,pr,x);
	}
	return rt;
}
int query(int u,int v,int pl,int pr,int k){//查询区间(u,v]中的第k小数
	if(pl==pr) return pl;//到达叶子节点，找到第k小数
	int x=tree[tree[v].L].sum-tree[tree[u].L].sum;//线段树相减
	int mid=(pl+pr)>>1;
	if(x>=k)//左儿子数字>=k,说明第k小数在左子树
		return query(tree[u].L,tree[v].L,pl,mid,k);
	else return query(tree[u].R,tree[v].R,mid+1,pr,k-x);
}
void solve(){
	int n,m;cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];b[i]=a[i];
	}
	sort(b+1,b+n+1);//对b排序，离散化
	int size=unique(b+1,b+n+1)-b-1;//size等于b中不重复元素个数
	//root[0]=build(1,size);
	for(int i=1;i<=n;i++){
		int x=lower_bound(b+1,b+size+1,a[i])-b;
		root[i]=update(root[i-1],1,size,x);
	}
	while(m--){
		int x,y,k;cin>>x>>y>>k;
		int t=query(root[x-1],root[y],1,size,k);
		cout<<b[t]<<"\n";
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	solve();
	return 0;
}

5. 分块与莫队算法

分块就是将数列分成很多块，对涉及的块做整体性的维护操作。类似与一个多分线段树。

代码比树状数组和线段树简单，效率比暴力高的，时间复杂度 $O(m \sqrt{n})$。

块的大小（块的长度），block=sqrt(n)
块的数量，t
块的左右边界，st[] 和 ed[]
每个元素所属块，pos[i]=(i-1)/block+1

分块定义，初始化

int block=sqrt(n);
int t=n/block;
if(n%block) t++;
for(int i=1;i<=t;i++){
    st[i]=(i-1)*block+1;
    ed[i]=i*block;
}
ed[t]=n;
for(int i=1;i<=n;i++) pos[i]=(i-1)/block+1;

P2801 教主的魔法 - 洛谷

ll n,m,a[N],b[N],add[N];
ll t,st[N],ed[N],pos[N];
void change(int L,int R,ll d){//对[L,R]区间操作
	int p=pos[L],q=pos[R];//左右区间端点对应块
	if(p==q){//同一块，碎片
		for(int i=L;i<=R;i++) b[i]+=d;//暴力操作区间
		for(int i=st[p];i<=ed[p];i++) a[i]=b[i];//维护a数组
		sort(a+st[p],a+ed[p]+1);
	}else{
		for(int i=p+1;i<=q-1;i++) add[i]+=d;//整块操作
		for(int i=L;i<=ed[p];i++) b[i]+=d;//左碎片操作
		for(int i=st[p];i<=ed[p];i++) a[i]=b[i];
		sort(a+st[p],a+ed[p]+1);
		for(int i=st[q];i<=R;i++) b[i]+=d;//右碎片操作
		for(int i=st[q];i<=ed[q];i++) a[i]=b[i];
		sort(a+st[q],a+ed[q]+1);
	}
}
ll query(int L,int R,ll c){//在[L,R]中查询
	int p=pos[L],q=pos[R];//区间端点对应块
	ll ans=0;
	if(p==q){
		for(int i=L;i<=R;i++)//暴力操作碎片
			if(b[i]+add[p]>=c) ans++;
	}else{
		for(int i=p+1;i<=q-1;i++){//整块操作
			int x=lower_bound(a+st[i],a+ed[i]+1,c-add[i])-a;
			ans+=(ed[i]-x+1);
		}
		for(int i=L;i<=ed[p];i++)//左碎片暴力查询
			if(b[i]+add[p]>=c) ans++;
		for(int i=st[q];i<=R;i++)//右碎片暴力查询
			if(b[i]+add[q]>=c) ans++;
	}
	return ans;
}
void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){cin>>a[i];b[i]=a[i];};//复制数组
	int block=sqrt(n);//块大小
	t=(n+block-1)/block;//块数量
	for(int i=1;i<=t;i++){
		st[i]=(i-1)*block+1;//块的左端点
		ed[i]=i*block;//块的右端点
	}
	ed[t]=n;//防止最后一块越界
	for(int i=1;i<=n;i++) pos[i]=(i-1)/block+1;//元素对应块
	for(int i=1;i<=n;i++) sort(a+st[i],a+ed[i]+1);//块内排序
	while(m--){
		char c;cin>>c;
		ll l,r,w;cin>>l>>r>>w;
		if(c=='M') change(l,r,w);//区间操作
		else cout<<query(l,r,w)<<"\n";//区间查询
	}
	
}

基础莫队算法

莫队算法=离线+暴力+分块

基础莫队算法用于不修改只查询的一类区间问题，复杂度为 $O(n\sqrt{n})$ 。

一次性存储所有询问，按照查询区间 左端点所在块序号排序，块相同再按 右端点排序。

ll n,m,a[N],tmp;
struct nod{//记录查询,用来排序
	int L,R,k;
}q[N];
ll t,sum[N],ans[N],pos[N];
bool cmp(nod a,nod b){//莫队排序
	if(pos[a.L]!=pos[b.L]) return pos[a.L]<pos[b.L];
	if(pos[a.L]&1) return a.R>b.R;//奇偶性优化
	return a.R<b.R;
}
void add(int x){sum[a[x]]++;if(sum[a[x]]==1) tmp++;}
void del(int x){sum[a[x]]--;if(sum[a[x]]==0) tmp--;}
void solve(){
	cin>>n;
	int block=sqrt(n);
	for(int i=1;i<=n;i++){
		cin>>a[i];pos[i]=(i-1)/block+1;//记录对应块
	}
	cin>>m;
	for(int i=1;i<=m;i++){//记录查询
		cin>>q[i].L>>q[i].R;q[i].k=i;
	}
	sort(q+1,q+m+1,cmp);//查询排序
	int L=1,R=0;
	for(int i=1;i<=m;i++){//查询处理
		while(L<q[i].L) del(L++);
		while(R>q[i].R) del(R--);
		while(L>q[i].L) add(--L);
		while(R<q[i].R) add(++R);
		ans[q[i].k]=tmp;
	}
	for(int i=1;i<=m;i++) cout<<ans[i]<<"\n";
}

带修改的莫队算法

如果只是简单的单点修改，也能使用莫队算法，但是复杂度为 $O(mn^{2/3})$

树上莫队

SP10707 COT2 - Count on a tree II - 洛谷

将树转换成欧拉序变为一维数组。

6. 块状链表

块状链表=分块+链表

7. 简单树上问题

判断一个图是否为树：

找根节点：只有出边没有入边的点，只有一个，无向图任何点都可以
判断环：从根DFS遍历图，每个节点只被访问一次
检查联通性：判断环后，检查所有点是否都访问到
时间复杂度为 $(n+m)$

树的重心

删除重心这个节点后，得到的最大子树的节点数最少。

8. LCA

9. 树上的分治

10. 树链剖分

11. 二叉查找树

12. 替罪羊树

13. Treap树

14. FHQ Treap树

15. 笛卡尔树

16. Splay树

17. K-D树

18. 动态树与LCT

24年CCPC郑州邀请赛VP

2025-06-01T00:00:00+00:00

24年CCPC郑州邀请赛暨第六届CCPC河南省赛

A. Once In My Life

题意：一个数的数位包含 1~9 并且至少两个数位是 d 的十进制正整数都是幸运数。给出 d 和一个正整数 n，输出一个 k 使得 n*k 是幸运数。

题解：我们需要先构造出乘积。1234567890 满足包含1~9的条件，再加上 d 满足幸运数。但是这个数不一定是 n 的倍数，无法通过乘积获得。为了不影响这个数幸运数的性质，我们可以在这个数后面添加几位使得这个数变成 n 的倍数。

我们先在 123456789d 后面添加 n 位数个 0，因为我们必定可以通过更改后面的 0 使得这个数变为 n 的倍数，即取模同余的性质。这个数不能减去与n的余数，因为这可能改变幸运数的性质，所以加上 $n-c%n$ 也是同理。（也可后面加9，然后减去余数，也不会影响前面数位而变成倍数）。

这个数除以 n 即可得到 k。

void solve(){
	ll n,d;cin>>n>>d;
	ll len=to_string(n).size();//求n的位数
	ll c=1234567890ll+d;//构造幸运数
	c=c*pow(10,len);//后面添0
	c+=(n-c%n);//使这个数变成n的倍数
	ll ans=c/n;
	cout<<ans<<"\n";
}

B. 扫雷 1

签到，排序+贪心。

C. 中二病也要打比赛

题意：给定一个序列A，元素范围在 1~n 内。使用某个映射将序列A变为一个单调不降的序列。这个映射的代价为 $f(x)≠x$ 的数量。求最小代价。

题解：

如果序列中数字没有相同的话，就是一个LIS。

若 $l<r$ 且 $a_l=a_r$ 则 $\forall l<i<r$ 有 $a_i=a_r$。即如果某两个数值相等，则这两数之间所有的数也全部相等，考虑这一段数字变成一个联通块，必须使这一个连通块都变为一个数字。。

可以仅保留某个数的第一次出现和最后一次出现（如果只出现一次，可以认为它在这个点出现了两次）。

问题就转化为每一段取一个数，求 LIS ，此处由于每一段中包含的数互不相同，认为是严格上升的。

将每一段中的数降序排列，求出最长严格上升子序列后即得。这是由于段内是降序排列的，不会被选取两次。

然后用数组总长度减去LIS长度就是答案。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
int n,m,ans,num,tot=0;
int a[N],rd[N],sum[N];
int bk[N],fst[N],lst[N];
int dp[N];
void solve(){
	cin>>n;
	ans=0,num=1,tot=0;
	for(int i=1;i<=n;i++) fst[i]=2*n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		fst[a[i]]=min(fst[a[i]],i);//求a[i]最左出现位置
		lst[a[i]]=i;//a[i]最右出现位置
	}
	for(int i=1;i<=n;i++){
		sum[i]=sum[i-1];
		if(i==fst[a[i]]) ++sum[i];
		if(i==lst[a[i]]) --sum[i];
		if(sum[i]==0) bk[++tot]=i;//记录段内区间
	}
	for(int i=1;i<=tot;i++)
		sort(a+bk[i-1]+1,a+bk[i]+1,greater<int>());//段内降序排序
	int maxx=0;
	for(int i=1;i<=n;i++){
		int pos=lower_bound(dp+1,dp+maxx+1,a[i])-dp;
		dp[pos]=a[i];
		maxx=max(maxx,pos);
	}
	for(int i=1;i<=n;i++)//记录
		if(lst[i]) --maxx;
	cout<<-maxx<<"\n";
}
int main(){
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	solve();
	return 0;
}

K.树上问题

题意：有一颗 n 个节点组成的无根树，编号从 1 到 n ，每个节点有正整数点权。一个节点是美丽节点的充要条件为以这个节点做根所有节点的点权不小于其父亲节点的一半。有多少个美丽节点？

题解：先以任意结点做根，构成一棵树。然后对于每个节点，搜索其子树，记录以点 i 为根节点的子树的不合法边的数量，采用递归从下往上记录。

对于相连的结点如 u 和 v ，以 u 和 v 为根时，红蓝区域的边方向都没变，对答案贡献相同，只有 u，v 这条边的方向发生变化。因此我们给 $ans_u$ 减去 $v->u$ 的恭喜，加上 $u->v$ 的贡献，就得到了 $ans_v$。

邻接表写法

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,a[N];
vector<int> vt[N];
int cnt[N];//以u为根的子树不合法边的个数
void dfs1(int u,int fa){//当前节点，父节点
	int sum=0;
	for(int i=0;i<vt[u].size();i++){//遍历子节点
		int v=vt[u][i];//相连的点
		if(v==fa) continue;
		dfs1(v,u);//往下搜
		sum+=cnt[v]+(a[v]*2<a[u]);
	}
	cnt[u]=sum;
}
int ans[N];//记录每个节点为总根不合法边数量
void dfs2(int u,int fa){
	for(int i=0;i<vt[u].size();i++){
		int v=vt[u][i];
		if(v==fa) continue;
		ans[v]=ans[u]-(a[v]*2<a[u])+(a[u]*2<a[v]);
		dfs2(v,u);
	}
}
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++) vt[i].clear();
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<n;i++){
		int u,v;cin>>u>>v;
		vt[u].push_back(v);//加双向边
		vt[v].push_back(u);
	}
	dfs1(1,-1);
	ans[1]=cnt[1];
	dfs2(1,-1);
	int sum=0;
	for(int i=1;i<=n;i++) sum+=(ans[i]==0);//统计合法的数量
	cout<<sum<<"\n";
}
int main(){
	int T;cin>>T;
	while(T--) solve();
	return 0;
}

链式前向星写法

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,a[N],head[N],ent;//head数组和ent用来辅助链式前向星
struct edge{
	int v,nxt;//目的节点，上一个指向
}e[N<<1];
void add(int u,int v){//链式前向星加边
	e[++ent]={v,head[u]};
	head[u]=ent;
}
int cnt[N];//以u为根的子树不合法边的个数
void dfs1(int u,int fa){//当前节点，父节点
	int sum=0;
	for(int i=head[u];i;i=e[i].nxt){//遍历子节点
		int v=e[i].v;//相连的点
		if(v==fa) continue;
		dfs1(v,u);//往下搜
		sum+=cnt[v]+(a[v]*2<a[u]);
	}
	cnt[u]=sum;
}
int ans[N];//记录每个节点为总根不合法边数量
void dfs2(int u,int fa){
	for(int i=head[u];i;i=e[i].nxt){
		int v=e[i].v;
		if(v==fa) continue;
		ans[v]=ans[u]-(a[v]*2<a[u])+(a[u]*2<a[v]);
		dfs2(v,u);
	}
}
void solve(){
	cin>>n;
	ent=0;
	memset(head,0,sizeof(head));
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<n;i++){
		int u,v;cin>>u>>v;
		add(u,v),add(v,u);//加双向边
	}
	dfs1(1,-1);
	ans[1]=cnt[1];
	dfs2(1,-1);
	int sum=0;
	for(int i=1;i<=n;i++) sum+=(ans[i]==0);//统计合法的数量
	cout<<sum<<"\n";
}
int main(){
	int T;cin>>T;
	while(T--) solve();
	return 0;
}

L. Toxel 与 PCPC II

题意：有 n 行代码和 m 行出现bug，给定出bug的具体行数可以修复。可以选择一个 i，从第一行执行到 i 行，需要 i 秒，并且修复这 i 行内的所有bug，但是需要额外的时间，即再加上bug数量的4次方。问最少时间修复所有bug。

题解：简单DP。

状态：$dp[i]$ 表示修复前 i 个bug所需的最少时间。

转移方程： $dp[i]=min_{1≤j≤i}(dp[j]+a_i+(i-j)^4)$ 时间复杂度为 $O(m^2)$，会TLE。

如果我们多运行一次代码，最大花费为 2e5，但是 $38^4-37^4>2e5$，这意味着选了38个bug不如先选一个bug，再选37个bug。

所以枚举 j 时，不必枚举所有bug，只需要向下枚举四五十行即可。时间复杂度可为 $O(40m)$。

typedef long long ll;
const int N=2e5+10;
int n,m;
ll a[N],dp[N];
void solve(){
	cin>>n>>m;
	for(int i=1;i<=m;i++) cin>>a[i],dp[i]=1e18;//初始化
	dp[1]=1+a[1];//初始化
	for(int i=1;i<=m;i++){//枚举m
		for(int j=max(0,i-40);j<=i;j++){//枚举1~i并且优化
			dp[i]=min(dp[i],dp[j]+a[i]+(ll)pow(i-j,4));
		}
	}
	cout<<dp[m]<<"\n";
}

优先队列重载

2025-05-31T00:00:00+00:00

优先队列重载

STL中对优先队列进行封装，我们可以直接定义使用。

插入与取出的时间复杂度为 $O(log_2n)$。

普通定义：

priority_queue<int> pq;

调用系统排序定义：

priority_queue<int,vector<int>,greater<int> > pq;
priority_queue<int,vector<int>,less<int> > pq;

自定义结构体定义：

struct nod{
	int num;
	friend bool operator < (nod a,nod b){
		return a.num>b.num;
	}
};
priority_queue<nod> pq;

2024年ICPC贵州省赛题解

2025-05-30T00:00:00+00:00

2024贵州省赛题解

A.破解住宿信息

简单判断。输入字符串含空格，整行输入。

string s;
getline(cin,s);
int sum=0,x;
x=s.find("GZU");
while(x!=-1){
    sum++;
    x=s.find("GZU",x+1);
}
if(sum==0) cout<<"yezhulin";
else if(sum%2) cout<<"heshangpo";
else cout<<"qingrenpo";

B.小帅的车费

确实是分层图最短路模板题。

直接建立 $k+ 1$层图，层与层间依次用打折后的边权相连。

跑一遍Dijkstra即可。

需要注意数组大小及数据大小。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> PII;
const int N = 4300010,M=1200010;
const ll INF = 1e18;
int n,m,k,s,t;
ll e[N],ne[N],w[N],h[M],p[11],idx;
ll dis[M];
bool vis[M];
priority_queue<PII,vector<PII>,greater<PII> > q;
void add(int a,int b,ll c){    //加边函数
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = c;
	h[a] = idx++;
}
void dijkstra(int s){   //dijkstra模板
	fill(dis,dis+M,INF);
	dis[s] = 0;
	q.push({0,s});
	while(!q.empty()){
		int u = q.top().second;
		q.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for(int i = h[u]; ~i;i = ne[i]){
			int v = e[i];
			if(dis[v] > dis[u]+w[i]){
				dis[v] = dis[u]+w[i];
				q.push({dis[v],v});
			}
		}
	}
}
int main(){
	int a,b;ll c;
	cin >> n >> m >> k;
	for(int i=1;i<=k;i++) cin>>p[i];
	cin>>s>>t;
	memset(h,-1,sizeof h);
	for(int i = 0;i < m;i++){
		cin>>a>> b>>c;
		add(a,b,c); //关键的建图，各层内部正常建边
		add(b,a,c);
		for(int j = 1;j <= k;j++){   //从0到k层建k+1张图
			add(j*n+a,j*n+b,c); //每层内部正常建图
			add(j*n+b,j*n+a,c);
			add((j-1)*n+a,j*n+b,(c*p[j])/100);  //各层之间从上到下建边花费为每次打折价格
			add((j-1)*n+b,j*n+a,(c*p[j])/100);
		}
	}
	for(int i = 0;i < k;i++)
		add(i*n+t,(i+1)*n+t,0); //为防止使用小于k次权力就到达终点，在每层的终点间建花费为0的边连起来
	dijkstra(s);    //从起点s出发
	if(dis[n*k+t]!=INF) cout << dis[n*k+t] <<"\n";  //到k层的终点为答案
	else cout<<"Impossible\n";
	return 0;
}

C.细胞的合并

题目数据为 $2000^2=4e6$，不会超时。

暴力枚举细胞是否相连，相连就并查集加入。

ll n,t;
vector<pair<ll,ll> > vt;
int fa[2010];
int find(int x){
	if(x==fa[x]) return x;
	return fa[x]=find(fa[x]);
}
void join(int x1,int x2){fa[find(x1)]=find(x2);}
void solve(){
	vt.clear();
	cin>>n>>t;
	for(int i=0;i<n;i++){
		ll x,y;cin>>x>>y;
		vt.push_back({x,y});
		fa[i]=i;
	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			ll x1=vt[i].first,y1=vt[i].second,x2=vt[j].first,y2=vt[j].second;
			if(abs(x1-x2)+abs(y1-y2)<=2*t){
				join(i,j);
			}
		}
	}
	int ans=0;
	for(int i=0;i<n;i++) if(fa[i]==i) ans++;
	if(ans!=1) cout<<"NO\n";
	else cout<<"YES\n";
}

D.还在排队的人

双端队列的模拟。只要会 deque直接秒。不会可以使用数组模拟。

int n,x=1;cin>>n;
deque<int> dq;
while(n--){
    char a,b;cin>>a>>b;
    if(a=='A'&&b=='S') dq.push_front(x++);
    else if(a=='A'&&b=='E') dq.push_back(x++);
    else if(a=='D'&&b=='S'){
        int m;cin>>m;
        while(m--) dq.pop_front();
    }else{
        int m;cin>>m;
        while(m--) dq.pop_back();
    }
}
while(!dq.empty()){
    cout<<dq.front()<<" ";dq.pop_front();
}

E.打怪兽

根据题目我们可以知道几个重要条件：

直线分布，第 $i$ 只怪兽在 $i$ 处。
每次魔法只对编号大于等于 $i$ 的怪兽生效，所以第 $i$ 处怪兽所受伤害只能来源于前面及此处的位置。
魔法的溅射伤害为 $max(0,damage-dis*dis)$ ，所以对于第 $i$ 处怪兽，能造成伤害的位置范围为 $[i-\sqrt{damage},i]$。
伤害最大为 1e18，需要开longlong，而且不会爆ll，不用开int128。

所以首先我们可以写一个二分代码，二分 $damage$ 。

在 solve 函数中，计算此时 $damage$ 所需最少次数。

如果次数大于 k，l 增加；次数小于等于 k 的都可以，修改 r，最终答案为 r。

solve 函数如何快速判断。根据上述题意，运行到第 $i$ 处时，判断之前对第 $i$ 处造成的伤害，如果可以使此处怪兽血量小于 0，则继续判断 $i+1$。若不能，则此处必须施展魔法，魔法次数直接往上取整。

对于第 $i$ 处如何快速判断能够受到的伤害呢？双指针，也叫尺取法。维护一段数组，存放造成伤害的下标。若某造成伤害下标对第 $i$ 处造成不了伤害（不在对 i 造成伤害下标范围内），也就对 $i+1,....$造成不了伤害，左指针前移。

我使用预处理 $f[]$ 数组存放 $i$ 的平方，减少乘法使用，不知道能不能加快。使用pair 数组存放施展魔法的下标和次数。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,k,a[100010];
ll f[100010];
pair<int,ll> b[100010];
bool check(ll x){
	if(x==0) return 1;
	queue<int> q;
	ll kk=0,y=sqrt(x);
	int r=0,l=0;
	for(int i=1;i<=n;i++){
		int tmpr=r;
		ll sum=0,z=0;
		for(int j=l;j<tmpr;j++){
			if(b[j].first+y>=i)
				sum+=(x-f[i-b[j].first])*b[j].second;
			else l++;
		}
		z=(max(a[i]-sum,0ll)+x-1)/x;
		kk+=z;
		if(z!=0) b[r++]={i,z};
	}
	return kk>k;
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		f[i]=i*i;
	}
	ll l=0,r=1e18,ans;
	while(l<r){
		ll mid=(l+r)>>1;
		if(check(mid)) l=mid+1;
		else r=mid;
	}
	cout<<r<<"\n";
	return 0;
}

F.关灯

暴力枚举最大长度 len。

每次操作是使 $[i,i+k-1]$ 内的数都减一，所以利用差分数组，在数组中 $a[i]-1,a[i+k]+1$ 即可实现这个操作。

需要考虑为负数之后的影响，即 +P 取模。

还需要考虑数组范围，虽然 n 是5e3，但是差分数组不能开这么小。

接下来请看我的垃圾代码

#include<bits/stdc++.h>
using namespace std;
int n,p,ans;
int level[10010];
int a[10010];
int main(){
	cin>>n>>p;
	for(int i=0;i<n;i++) cin>>level[i];
	for(int i=n;i>=1;i--){
		int d=0,f=1;
		memset(a,0,sizeof(a));
		for(int j=0;j<=n-i;j++){
			d+=a[j];
			int x=(level[j]-d+p)%p;
			if(x!=0){
				a[j]+=x;d+=x;
				a[j+i]-=x;
			}
		}
		for(int j=n-i+1;j<n;j++){
			d+=a[j];
			if((level[j]-d+p)%p!=0){f=0;break;}
		}
		if(f){
			cout<<i<<"\n";
			return 0;
		}
	}
	return 0;
}

G.小帅的骰子

模拟两次投出来的结果。

然后判断满足条件的可能结果有多少种。

求最大公因数约分即可。

我看不懂这个编译器啊，关闭同步取消刷新缓冲区就29s？否则TLE？2e4次输入。

int x,y;
vector<int> v;
void init(){
	for(int i=1;i<7;i++)
		for(int j=1;j<7;j++)
			v.push_back(i+j);
	sort(v.begin(),v.end());
}
void solve(){
	cin>>x>>y;
	if(x>y||y<2||x>12){ cout<<"0\n";return ;}
	int fm=v.size();
	int fz=upper_bound(v.begin(),v.end(),y)-lower_bound(v.begin(),v.end(),x);
	int tmp=__gcd(fm,fz);
	cout<<fz/tmp<<"/"<<fm/tmp<<"\n";
}

H.粉刷匠小帅

线段树，me not can。

I.寻找宝藏数

数位DP。

先利用质数筛预处理出所有4位合数。

for(int i=1000;i<=9999;i++)
    if(!prime(i))
        b[i]=1;

设 $dp[N][i][j][k]$ 表示最高位为 i ,次高位为 j ，第三位为 k 的 N 位宝藏数的个数。

依次枚举四位初始化 $dp[4][i][j][k]$ 为对应4位合数个数。

//在筛出所有合数时顺手初始化DP数组
dp[4][i/1000][i/100%10][i/10%10]++;

之后继续依次从低到高枚举高四位数字 i,j,k,p, 则状态转移方程为：

$dp[N][i][j][k] += dp[N-1][j][k][p]$;

最后继续枚举高三位求和即可。

时间复杂度为$O(n*10*10*10*10)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7,N=1010;
ll n,ans;
ll dp[N][10][10][10];
int b[10000];
bool prime(int x){
	for(int i=2;i*i<=x;i++)
		if(x%i==0) return 0;
	return 1;
}
void init(){
	for(int i=1000;i<=9999;i++){
		if(!prime(i)){
			b[i]=1;
			dp[4][i/1000][i/100%10][i/10%10]++;
		}
	}
}
int main(){
	cin>>n;
	init();
	for(int len=5;len<=n;len++){
		for(int i=1;i<=9;i++){
			for(int j=1;j<=9;j++){
				for(int k=0;k<=9;k++){
					for(int p=0;p<=9;p++){
						int x=i*1000+j*100+k*10+p;
						if(b[x]){
							dp[len][i][j][k]=(dp[len][i][j][k]+dp[len-1][j][k][p])%mod;
						}
					}
				}
			}
		}
	}
	for(int i=1;i<=9;i++){
		for(int j=0;j<=9;j++){
			for(int k=0;k<=9;k++){
				ans=(ans+dp[n][i][j][k])%mod;
			}
		}
	}
	cout<<ans;
	return 0;
}

J.数字游戏

设删掉一个数字及其生成的所有数字所需要的次数的奇偶性为 $f[x]$ ,则 $f[x]=f[1]\verb

f[2]\verb

…f[x-1]\verb

$。

$ans=f[a_1]\verb

[a_2]\verb

f[a_n]$，若为奇数则Alice获胜，否则Bob获胜。

但因为x很大，不能直接dp（~~我都不知道如何dp~~）。我们可以打表观察到：$f[1]=1,f[2]=0,f[3]=0$，

则当x>1时，$f[x]=f[1]\verb

f[2]\verb

…f[x-1]\verb

1=0$。

所以只需要统计数字1的个数的奇偶性即可。

使用异或来判断操作次数奇偶性，奇偶性又可以反应获胜者。

int n,sum=0;cin>>n;
while(n--){
    int x;cin>>x;
    if(x==1) sum++;
}
if(sum%2) cout<<"Alice\n";
else cout<<"Bob\n";

K.最好的好朋友活动

需要注意，题目中只说了 a 数组和 b 数组是整数，自然也有可能是负数。想要乘积最大，若 $a[i]$ 是负数，则在 b 数组中找一个最小的负数，负负得正则乘积最大；反之正数，自然在 b 数组中找一个最大的正数。

时间复杂度为 $O(max(n,m))$。

void solve(){
	ll mi=1e18,mx=-1e18,sum=0;
	cin>>n>>m>>s;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int j=1;j<=m;j++){
		ll x;cin>>x;
		mi=min(mi,x);
		mx=max(mx,x);
	}
	for(int i=1;i<=n;i++){
		if(a[i]<0) sum+=a[i]*mi;
		else sum+=a[i]*mx;
	}
	if(sum>=s) cout<<"YES\n";
	else cout<<"NO\n";
	for(int i=1;i<=n;i++){
		if(a[i]<0) cout<<a[i]*mi<<" ";
		else cout<<a[i]*mx<<" ";
	}
	cout<<"\n";
}

L.GZU的建筑

字典树我都没学，更别说树上启发式合并（dsu on tree）。

后续更新。

M.递增的鸭鸭

此题题解及DP状态设计与官方题解不一致。

DP状态：$dp[j] = 前 j 只鸭子的合法方案数$

输入，使用vector存储，数组或许更美观。

vector<ll> l(n+1),r(n+1),vt(2*n);
for(int i=1;i<=n;i++) cin>>l[i]>>r[i];

题目中 l 和 r 的取值范围较大，为1e9，使用离散化可以缩小到 1e3。

for(int i=1;i<=n;i++){// 离散化边界
    vt.push_back(l[i]);
    vt.push_back(r[i] + 1);
}
sort(vt.begin(), vt.end());
vt.erase(unique(vt.begin(), vt.end()),vt.end());
// 每只鸭子可用的段区间 [L[i], R[i]]
vector<int> L(n+1),R(n+1);
for(int i = 1; i <= n; i++){//离散化后对应的数字
    int Li = lower_bound(vt.begin(), vt.end(), l[i]) - vt.begin();
    int Ri = lower_bound(vt.begin(), vt.end(), r[i] + 1) - vt.begin() - 1;
    L[i] = Li; R[i] = Ri;
}

预处理逆元，用于后续排列组合计算。~~我只会小费马定理~~。

下面逆元数组转移公式的AI推导如下：

vector<ll> inv(n+2);
inv[1] = 1;
for(int i = 2; i <= n+1; i++)
    inv[i] = (MOD - (MOD/i) * inv[MOD % i] % MOD) % MOD;

定义dp数组和初始化

vector<ll> dp(n+1, 0), dpnext;
dp[0] = 1;

组合数学内容。假设这n个数的范围相等，都是[l,r]，那么方案数可以直接用隔板法求出，为C(n+r-l,n)。

DP状态转移如下：

for(int s = 0; s < m; s++){
    // 预计算该段上取 t 个值的组合数 f[t] = C(len[s] + t - 1, t)
    vector<ll> f(n+1, 0);
    f[0] = 1;
    if(n >= 1) f[1] = len[s] % MOD;
    for(int t = 2; t <= n; t++){
        ll mul = (len[s] + t - 1) % MOD;
        f[t] = f[t-1] * mul % MOD * inv[t] % MOD;
    }
    // dpnext 初始为 dp（不选取该段）
    dpnext = dp;
    // 尝试在该段上添加更多鸭子（末尾连续 t 只鸭子）
    for(int j = 0; j <= n; j++){
        if(dp[j] == 0) continue;
        if(j == n) continue;
        // 查看第 j+1 只鸭子是否允许落在该段
        if(!(L[j+1] <= s && s <= R[j+1])) continue;
        // 从 j+1 开始尝试连续放鸭子
        for(int t = 1; j + t <= n; t++){
            int duckPos = j + t;
            if(!(L[duckPos] <= s && s <= R[duckPos])) break;
            dpnext[j+t] = (dpnext[j+t] + dp[j] * f[t]) % MOD;
        }
    }
    dp.swap(dpnext);
}

完整代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
int main(){
	int n;cin>>n;
	vector<ll> l(n+1),r(n+1),vt;
	for(int i=1;i<=n;i++) cin>>l[i]>>r[i];
	vt.reserve(2*n);
	for(int i=1;i<=n;i++){
		vt.push_back(l[i]);
		vt.push_back(r[i] + 1);
	}
	sort(vt.begin(), vt.end());
	vt.erase(unique(vt.begin(), vt.end()), vt.end());
	int m = vt.size() - 1;
	vector<ll> len(m);
	for(int j = 0; j < m; j++)
		len[j] = vt[j+1] - vt[j];
	vector<int> L(n+1),R(n+1);
	for(int i = 1; i <= n; i++){
		int Li = lower_bound(vt.begin(), vt.end(), l[i]) - vt.begin();
		int Ri = lower_bound(vt.begin(), vt.end(), r[i] + 1) - vt.begin() - 1;
		L[i] = Li; R[i] = Ri;
	}
	vector<ll> inv(n+2);
	inv[1] = 1;
	for(int i = 2; i <= n+1; i++)
		inv[i] = (MOD - (MOD/i) * inv[MOD % i] % MOD) % MOD;
	vector<ll> dp(n+1, 0), dpnext;
	dp[0] = 1;
	for(int s = 0; s < m; s++){
		vector<ll> f(n+1, 0);
		f[0] = 1;
		if(n >= 1) f[1] = len[s] % MOD;
		for(int t = 2; t <= n; t++){
			ll mul = (len[s] + t - 1) % MOD;
			f[t] = f[t-1] * mul % MOD * inv[t] % MOD;
		}
		dpnext = dp;
		for(int j = 0; j <= n; j++){
			if(dp[j] == 0) continue;
			if(j == n) continue;
			if(!(L[j+1] <= s && s <= R[j+1])) continue;
			for(int t = 1; j + t <= n; t++){
				int duckPos = j + t;
				if(!(L[duckPos] <= s && s <= R[duckPos])) break;
				dpnext[j+t] = (dpnext[j+t] + dp[j] * f[t]) % MOD;
			}
		}
		dp.swap(dpnext);
	}
	cout << dp[n] % MOD << "\n";
	return 0;
}

N.乐乐爱购物

莫比乌斯反演。

让数学手过来！

近期DP题目

2025-05-26T00:00:00+00:00

几道DP题目

牛客练习赛139C，25武汉邀请赛FG等

C-大卫的密码_牛客练习赛139

题意：

给定一个 $n\times m$ 的网格图，我们使用 $(i,j)$ 表示网格中从上往下数第 $i$ 行和从左往右数第 $j$ 列的单元格。左上角为 $(1,1)$ ，右下角为 $(n,m)$ ，每个格子包含一个整数价值，使用 $a_{i,j}$ 表示。一个光标在上面移动，从 $(s,1)$ 出发，每次可以向右或者向下移动，每个格子至多经过一次。当光标移动到 $(n,i) \left(1\le i\le m \right)$ 格子，也就是最后一行的某个格子时，继续向下移动则会到达 $(1,i)$ 格子。大卫需要移动光标到达 $(t,m)$ ，求最终大卫能获取的最大价值和。

题解：

题解

二维DP+限制。定义状态 $dp[i][j]$ 表示在 $(i,j)$ 位置时的最大价值和。

因为纵向是可以走到底然后从上面走下来的，所以我们考虑转移的时候从左往右一列一列的转移。

设 $s_n=\sum_{i=1}^n a[i][j]$，则转移方程为 $dp_{i,j} \leftarrow \max_{k} \left( dp_{k,j-1} + \begin{cases} s_i - s_{k-1} & \text{if } ~k < i \\ s_n - (s_{k-1} - s_i) & \text{if } ~k > i \end{cases} \right)$ 观察上面式子，如果在 $k>i$ 的情况下，

因为这里面只有 $s_{k-1}$ 是不固定的，我们找到最小的 $k$ 进行转移就行了;两种对于从下转移和从上转移不同情况，对应 $l$ 数组和 $r$ 数组，分别使用DP求出对于 $i$ 的最大值。

DP数组可以滚动。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=5e3+10,M=1e6+10,inf=1e18+10;
ll Tt=1,n,m,s,t;
ll dp[2][N],a[N][N],l[N],r[N],sum[N];
void solve(){
	cin>>n>>m>>s>>t;
	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) cin>>a[i][j];
	for(int i=1;i<=n;i++) dp[0][i]=-inf;
	dp[0][s]=0;
	for(int j=1;j<=m;j++){
		int now=j&1,pre=(j-1)&1;
		for(int i=0;i<=n+1;i++){
			l[i]=r[i]=-inf,sum[i]=0;
			dp[now][i]=dp[pre][i],dp[now][i]=0;
		}
		for(int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i][j];
		for(int i=1;i<=n;i++) l[i]=max(l[i-1],dp[pre][i]-sum[i-1]);
		for(int i=n;i>=1;i--) r[i]=max(r[i+1],dp[pre][i]+sum[n]-sum[i-1]);
		for(int i=1;i<=n;i++) dp[now][i]=max(l[i],r[i+1])+sum[i];
	}                                                         
	cout<<dp[m&1][t]<<"\n";
}
int main(){
	while(Tt--) solve();
	return 0;
}

P12593 沉石鱼惊旋 - 洛谷

题意：

有一张 $n$ 个点 $m$ 条边的简单无向带权连通图 $G$。可以进行 $n$ 次操作，每次操作如下：

选择一个仍未被删除的点 $u$，然后删除点 $u$ 和当前与 $u$ 相连的所有边（即其中一个端点是 $u$ 的边）。假设本次删除的边的边权分别是 $w_1, w_2,\dots w_k$，则本次操作的代价是 $k\times (w_1+w_2+\dots+w_k)$ 。

你的总代价是这 $n$ 次操作的代价和。将图中所有点和边都删除（即把图删空）的最小总代价是多少。

题解：

题解

状压DP。定义状态为 $f[s]$ 为已经删过点的集合为 $s$ 时所能取得的最小代价，那么容易得出状态转移方程

$f_S = \min_{\substack{1 \leq j \leq n \& j \notin S}} \left\{ f_{S \cup j} + \sum_{l \notin S} [(l,j)\in E] \sum_{l \notin S \& (l,j) \in E}{w_{l,j}} \right\}$ 边界条件是当 $S={1,2,...,n}$ 时，$f_S=0$ ，因为删完了就不需要再付出代价了。答案即为 $f_\empty$，因为最开始的时候一个点也没删。

时间复杂度为 $O(2^nn^2)$，可以通过 $n ≤ 16$ 的范围。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf=1e18;
ll n,m,g[10][10],dp[1<<10];
bool vis[1<<10];
ll f(ll x){
	if(vis[x]) return dp[x];//记忆化搜索
	if(x==(1<<n)-1) return 0;//全未删
	ll ans=1e18;
	for(int j=1;j<=n;j++){
		if(!(x&(1<<(j-1)))){//第j个点已经删除了
			ll k=0,v=0;
			for(int l=1;l<=n;l++){//枚举所有与j点相连的边
				if(!(x&(1<<(l-1)))&&g[j][l]>0){//第l个点也删了,且j和l有边
					k++,v+=g[j][l];//删的边数++，值+
				}
			}
			ans=min(ans,f(x|(1<<(j-1)))+k*v);
		}
	}
	vis[x]=1,dp[x]=ans;
	return ans;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v,w;cin>>u>>v>>w;
		g[u][v]=g[v][u]=w;
	}
	cout<<f(0);
	return 0;
}

P12597 穿睡衣军训 - 洛谷

题意：

给定两个字符串 $s,t$，扶苏想让你求出一个字符串 $x$，满足：

$x$ 是 $s$ 的子串。
$x$ 是 $t$ 的子序列。
在所有满足前述两条的字符串中，$x$ 的长度最长。
在所有满足前述三条的字符串中，$x$ 的字典序最小。

请你帮她求出这样的字符串 $x$。

题解：

此题我使用枚举子串+DP判断子序列超时，时间复杂度太大。

可以 $O(n^2)$ 枚举子串。写出 $O(nlog m)$ 的判断子序列。

考虑优化，注意到判断子序列其实是可以继承于上一段的结果，于是我们少一个判断子序列花费的 n，此时复杂度来到 $O(Tn^2logm)$ 。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
	string s,t;cin>>s>>t;
	int n=s.size(),m=t.size();
	s=" "+s,t=" "+t;
	vector<int> ve[35];
	for(int i=1;i<=m;i++) ve[t[i]-'a'].push_back(i);
	string ans;
	for(int i=1;i<=n&&n-i+1>=ans.size();i++){
		string flc;
		for(int j=i,x=-1;j<=n;j++){
			auto tmp=upper_bound(ve[s[j]-'a'].begin(),ve[s[j]-'a'].end(),x);
			if(tmp==ve[s[j]-'a'].end()) break;
			x=ve[s[j]-'a'][tmp-ve[s[j]-'a'].begin()];
			flc+=s[j];
		}
		if(flc.size()>ans.size()||flc.size()==ans.size()&&flc<ans) ans=flc;
	}
	cout<<ans<<'\n';
}
int main(){
	int T;cin>>T;
	while(T--) solve();
	return 0;
}

2025武汉邀请赛-F 背包

题意：

有 $n$ 组物品，第 $i$ 组物品有 $a_i$ 个，每个物品的重量为 $2^{b^i}$。

有 $m$ 个背包，每个背包的承重为 $k$。求最小的 $k$，使得所有 $\sum_{i=1}^n a_i$ 个物品都能被放入背包中，每个背包物品总重量不超过 $k$。同一组不同物品可放不同背包。

题解：

2025ICPC武汉邀请赛-F 题解

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=6e6+10,INF=4e18,p=998244353;
ll n,m;
vector<pair<ll,ll> > v(N);
ll fpow(ll a,ll b){
	ll res=1;
	while(b){
		if(b&1) res=(res*a)%p;
		a=(a*a)%p;
		b>>=1;
	}
	return res;
}
void solve(){
	map<ll,ll> mp;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		ll a,b;cin>>a>>b;
		mp[b]+=a;
	}
	ll idx=0;
	for(auto i:mp){
		if(i.second>m){
			ll sub=i.second-m;
			mp[i.first]-=sub;
			if(sub&1) sub++,mp[i.first]--;
			mp[i.first+1]+=sub/2;
		}
		if(mp[i.first]) v[++idx]={i.first,mp[i.first]};
	}
	ll pre=-1,res=0,fu=0;
	for(ll i=idx;i>=1;i--){
		if(pre==-1){
			res+=fpow(2,v[i].first);
			fu=m-v[i].second;
		}else{
			if(fu&&pre-v[i].first>40){
				cout<<res<<"\n";
				return ;
			}else{
				if(fu){
					for(ll j=pre;j>v[i].first;j--){//2^j
						fu*=2;
						if(fu>2*m){cout<<res<<"\n";return;}
					}
				}
				if(fu>=v[i].second) fu-=v[i].second;
				else{
					v[i].second-=fu;
					res=res+fpow(2,v[i].first);
					res%=p;
					fu=m-v[i].second;
				}
			}
		}
		pre=v[i].first;
	}
	cout<<res<<"\n";
}
int main(){
	int T;cin>>T;
	while(T--) solve();
	return 0;
}

2025武汉邀请赛-G 路径求和问题

题意：

有一个 $n\times m$ 的网格，每个格子写一个整数，第 $i$ 行第 $j$ 列的格子里写着整数 $a_{i,j}$。

从 $(1,1)$ 走到 $(n,m)$ ，只能往下走或者往右走。

一条路径的价值定义为路径上不同整数的数量。对于所有可能路径，求价值之和。

题解：

25 ICPC 邀请赛武汉站 G 题题解

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> PII; 
const int mod = 998244353;
const int N = 1e6 + 10;
ll fact[N], infact[N];
int n, m;
ll qmi(ll a, ll b){
	ll res = 1;
	while (b) {
		if (b & 1) res = res * a % mod;
		a = a * a % mod;
		b >>= 1;
	}
	return res;
}
void init(){
	fact[0] = infact[0] = 1;
	for (int i = 1; i < N; i ++) fact[i] = fact[i - 1] * i % mod;
	infact[N - 1] = qmi(fact[N - 1], mod - 2);
	for (int i = N - 2; i; i --) infact[i] = infact[i + 1] * (i + 1) % mod;
}
ll C(int a, int b){
	if (b < 0 || a - b < 0) return 0;
	return fact[a] * infact[b] % mod * infact[a - b] % mod;
}
bool cmp(PII a, PII b){
	if (a.first == b.first) return a.second < b.second;
	return a.first < b.first;
}
ll func1(vector<PII>& a, int len){
	vector<ll> f(len, 0);
	ll res = 0;
	for (int i = 0; i < len; i ++) {
		f[i] = C(a[i].first + a[i].second - 2, a[i].first - 1);
		for (int j = 0; j < i; j ++) {
			if (a[j].first <= a[i].first && a[j].second <= a[i].second) {
				f[i] = (f[i] - f[j] * C(a[i].first - a[j].first + a[i].second - a[j].second, a[i].first - a[j].first) % mod + mod) % mod;
			}
		}
		ll num = f[i] * C(n - a[i].first + m - a[i].second, n - a[i].first) % mod;
		res = (res + num) % mod;
	}
	return res;
}
ll func2(vector<vector<ll>>& g, ll tol, int c){
	vector<vector<ll>> dp(n + 1, vector<ll>(m + 1, 0));
	dp[1][1] = 1;
	ll res = 0;
	if (g[1][1] == c) dp[1][1] = 0;
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= m; j ++) {
		if (i == 1 && j == 1) continue;
		if (g[i][j] == c) continue;
		dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % mod;
	}
	res = (tol - dp[n][m] + mod) % mod;
	return res;
}
void solve(){
	cin >> n >> m;
	vector<vector<ll>> g(n + 1, vector<ll>(m + 1));
	set<int> v;
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= m; j ++) {
			cin >> g[i][j];
			v.insert(g[i][j]);
		}
	map<int, vector<PII>> c;
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= m; j ++)
			c[g[i][j]].emplace_back(i, j);
	for (auto it : v) sort(c[it].begin(), c[it].end(), cmp);
	int mid = sqrt(n * m);
	ll tol = C(n + m - 2, n - 1);
	ll ans = 0;
	for (int it : v) {
		auto a = c[it];
		int len = a.size();
		ll x;
		if (len <= mid) x = func1(a, len);
		else x = func2(g, tol, it);
		ans = (ans + x) % mod;
	}
	cout << ans << '\n';
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0), cout.tie(0);
	init();
	int t;cin >> t;
	while (t --) solve();
	return 0;
}

算法竞赛DP

2025-05-22T00:00:00+00:00

《算法竞赛》第 5 章动态规划

1. DP概念和编程方法

1.1 DP的概念

DP是求解多阶段决策问题最优化的一种算法思想。

解决的问题具有两个特征。

重叠子问题：子问题会重叠，即多个不同问题会用到相同子问题

最优子结构：大问题的最优解由小问题最优解得来，但小问题最优解求解过程与大问题无关。

1.2 DP的两种编程方法

自顶向下（先大问题，再小问题），即递归记忆化搜索。

自底向上（先小问题，再大问题），即递推。

自底向上的优点是编码更直接。

1.3 DP的设计和实现

刷题。

1.4 滚动数组

滚动数组可以减少空间复杂度，但也会损失DP数组存储的信息。

如 01 背包使用滚动数组优化后，无法输出具体方案。

有的DP状态已经是最小空间复杂度，无法再使用滚动数组优化。

两种实现滚动数组的方式。

交替滚动：用 $dp[0][]$ 和 $dp[1][]$ 交替滚动

例如01背包

int now=0,old=1;
for(int i=1;i<=n;i++){
    swap(now,old);//交替滚动
    for(int j=0;j<=c;j++){
        if(v[i]>j) dp[now][j]=dp[old][j];
        else dp[now][j]=max(dp[old][j],dp[old][j-v[i]]+w[i]);
    }
}

自我滚动：自我覆盖

例如01背包

for(int i=1;i<=n;i++){
    for(int j=c;j>=v[i];j--){
        dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
    }
}

2. 线性DP

一些经典线性DP问题。

1. 分组背包

有一些物品，分为 n 组，第 i 组第 k 个物品体积为 $c[i][k]$，价值为 $w[i][k]$。每组最多选一个，给定容量为 C 的背包，如何选使总价值最大。

P1757 通天之分组背包 - 洛谷

状态：$dp[i][j]$，前 i 组物品装容量 j 的背包获得最大价值。

状态转移方程：$dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i][k]]+w[i][k])$

对于 $dp[i][j]$ 只使用到 $dp[i-1][]$，所以可使用滚动数组优化。

即状态转移方程：$dp[j]=max(dp[j],dp[j-c[i][k]]+w[i][k])$

for(int i=1;i<=zu;i++)//组数
    for(int j=m;j>=0;j--)//体积
        for(int k=1;k<=a[i];k++)//第i组物品数
            if(j>=v[i][k])
                dp[j]=max(dp[j],dp[j-v[i][k]]+w[i][k]);

2. 多重背包

给定 n 种物品和一个背包，第 i 种物品的体积为 $c_i$，价值为 $w_i$，并且有 $m_i$ 个，背包总容量为 C。使背包总价值最大。

P1776 宝物筛选 - 洛谷

4 种解法。

第一种，转换为01背包，把每种的背包都看作单独物品。

时间复杂度为$O(C\sum _{i=1}^n m_i)$。

cin>>n>>C;
for(int i=1;i<=n;i++){
    int a,b,c;cin>>a>>b>>c;
    while(c--) w.push_back(a),v.push_back(b);
}
for(int i=0;i<w.size();i++){
    for(int j=C;j>=v[i];j--){
        dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
    }
}
cout<<dp[C]<<"\n";

第二种，转换为分组背包，时间复杂度也为$O(C\sum _{i=1}^n m_i)$。

cin>>n>>C;
for(int i=1;i<=n;i++) cin>>w[i]>>c[i]>>m[i];
for(int i=1;i<=n;i++){
    for(int j=C;j>=0;j--){
        for(int k=1;k<=m[i];k++){
            if(k*c[i]>j) break;
            dp[j]=max(dp[j],dp[j-k*c[i]]+k*w[i]);
        }
    }
}
cout<<dp[C];

第三种，二进制拆分优化

若第 i 种物品有 m 个，放进背包的方案有 m+1 种，组合出这 m+1 种并不需要m个物品。根据二进制的原理，任何一个十进制数 X 都可以使用 2 的不同幂次方相加得到，这些幂次方个数只有 $log_2 X$ 个。所以第 i 种物品的 m 个物品，可以使用 $log_2 m$ 个表示。复杂度从 $O(C \sum_{i=1}^n m_i)$ 优化到 $O(C \sum_{i=1}^n log_2 ~ m_i)$ 。

注意拆分的具体实现，不能全部拆成 2 的倍数，而是先按 2 的幂次方从小到大拆，最后一个小于或等于最大倍数的余数。这样能保证拆出的数相加在 $[1,m_i]$ 范围内，不会大于 $m_i$ 。

例如，$m_i=25$，把它拆成 $1+2+4+8+10$，最后余数 10，可保证这拆分数组合不会超过 25。

int n,C,dp[N];
int w[N],c[N],m[N];
int new_n;//二进制拆分后的新物品总数量
int new_w[N],new_c[N],new_m[N];//二进制拆分后的新物品
void solve(){
	cin>>n>>C;
	for(int i=1;i<=n;i++) cin>>w[i]>>c[i]>>m[i];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m[i];j<<=1){//二进制枚举
			m[i]-=j;//减去已拆分的
			new_c[++new_n]=j*c[i];//新物品
			new_w[new_n]=j*w[i];
		}
		if(m[i]){
			new_c[++new_n]=m[i]*c[i];
			new_w[new_n]=m[i]*w[i];
		}
	}
	//下面是滚动数组的 01背包
	for(int i=1;i<=new_n;i++)
		for(int j=C;j>=new_c[i];j--)
			dp[j]=max(dp[j],dp[j-new_c[i]]+new_w[i]);
	cout<<dp[C]<<"\n";
}

二进制拆分可以看作多重背包问题的标准解法，下面是最优解法。

第四种，单调队列优化

原理后续DP优化再补。时间复杂度为 $O(nC)$ ，是最优的解法。

int n,C,dp[N],ans,tmp;
int f[N],que[N],num[N];
void solve(){
	cin>>n>>C;
	for(int i=1;i<=n;i++){
		int v,w,m;
		cin>>w>>v>>m;
		if(v==0){ans+=m*w;continue;}//体积为0，避免除数为0的情况
		int can_use=min(m,C/v);//can_use表示最大可用数量
		for(int j=0;j<v;j++){//枚举每一个余数
			//注意这要保证转移到所有可以转移点
			int all=(C-j)/v,head=1,tail=0;//找到区间内这个余数下有机会转移到的所有点
			//每次重置队列
			for(int k=0;k<=all;k++){//转移数量从0到all不等
				int push_in=f[j+k*v]-k*w;
				while(head<=tail&&push_in>=que[tail]) tail--;//维护队列取最大
				tail++;
				que[tail]=push_in;
				num[tail]=k;
				while(head<=tail&&num[head]+can_use<k) head++;//无法实现转移的话
				f[j+k*v]=max(f[j+k*v],que[head]+k*w);
				tmp=max(tmp,f[j+k*v]);
			}
		}
	}
	cout<<tmp+ans<<"\n";
}

3. 最长公共子序列（LCS）

给定两个序列 X 和 Y ，找出 X 和 Y 的一个最长公共子序列。

状态：$dp[i][j]=序列X在第i位置序列Y在第j位置的最长公共子序列$

状态转移方程： $dp[i][j]=dp[i-1][j-1]+1,~~X[i]==Y[i];\\ dp[i][j]=max(dp[i-1][j],dp[i][j-1]),~X[i]!=Y[j];$ 时空复杂度都为 $O(n^2)$。

P1439 最长公共子序列 - 洛谷

P1439这题序列长度为1e5，正常复杂度过不了，但是多了排列的限制条件，就可以将此题转化为LIS。

int a[N],b[N];
void solve(){
	int n,len=0;cin>>n;
	map<int,int> mp;
	for(int i=1;i<=n;i++){
		int x;cin>>x;
		mp[x]=i;
	}
	for(int i=1;i<=n;i++){
		int x;cin>>x;
		a[i]=mp[x];
	}
	for(int i=1;i<=n;i++){
		if(b[len]<=a[i]) b[++len]=a[i];
		else{
			int x=upper_bound(b+1,b+len+1,a[i])-b;
			b[x]=a[i];
		}
	}
	cout<<len<<"\n";
}

Problem - 1159

基础的LCS

int dp[N][N];
void solve(){
	string s1,s2;cin>>s1>>s2;
	int n=s1.size(),m=s2.size();
	s1=" "+s1,s2=" "+s2;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1]+1;
			else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
		}
	}
	cout<<dp[n][m]<<"\n";
}

4. 最长递增子序列（LIS）

给定一个长度为 n 的数组，找出一个最长的单调递增子序列。

状态：$dp[i]$ 在以第 $i$ 个数为结尾的最长上升子序列的最大长度

转移方程：$dp[i]=max(dp[j]+1),0<j<i,A_j<A_i$

DP不是LIS问题的最优解，使用树状数组或者贪心二分复杂度更低。

使用DP求解是 $O(n^2)$ 的，采用树状数组或者贪心+二分是 $Olog_2n$ 的。

B3637 最长上升子序列 - 洛谷

int dp[N],a[N];//DP
void solve(){
	int n,ans=0;cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=n;i++){
		dp[i]=1;
		for(int j=1;j<i;j++)
			if(a[i]>a[j]) dp[i]=max(dp[i],dp[j]+1);
		ans=max(ans,dp[i]);
	}
	cout<<ans<<"\n";
}

int a[N],b[N];//贪心+二分
void solve(){
	int n,len=0;cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	b[++len]=a[1];
	for(int i=2;i<=n;i++){
		if(a[i]>b[len]) b[++len]=a[i];
		else{
			int x=lower_bound(b+1,b+len+1,a[i])-b;
			b[x]=a[i];
		}
	}
	cout<<len<<"\n";
}

Problem - 1257

上面这题也是一道LIS的模板。

5. 编辑距离

给定两个单词，计算将第一个单词转换为第二个单词所需的最小操作数。单词允许插入一个字符、删除一个字符、替换一个字符。

状态：$dp[i][j]$ 表示从 s1 的前 $i$ 个字符转换到 s2 的前 $j$ 个字符所需最小操作数。

如果 $s1[i]==s2[j]$ ，则 $dp[i][j]=dp[i-1][j-1]$，因为不需要操作。

如果不等，有三种情况

删除 s1 的最后字符（相当于 s1 最后插入），$dp[i-1][j]+1$
在 s2 插入 s1 的最后字符（相当于 s2 最后删除），$dp[i][j-1]+1$
将某个单词最后字符替换，$dp[i-1][j-1]+1$

即如果 $s1[i]!=s2[j]$，则 $dp[i][j]=min{dp[i-1][j-1],dp[i-1][j],dp[i][j-1]}+1$

注意初始化，需要将 $dp[i][0]和dp[0][i]$ 赋值为 $i$，因为某串无字符时，需要删加长度字符。

算法复杂度为 $O(mn)$。

P2758 编辑距离 - 洛谷

int dp[N][N];
void solve(){
	string s1,s2;cin>>s1>>s2;
	int n=s1.size(),m=s2.size();
	s1=" "+s1,s2=" "+s2;
	for(int i=0;i<=n;i++) dp[i][0]=i;
	for(int i=0;i<=m;i++) dp[0][i]=i;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1];
			else dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
		}
	}
	cout<<dp[n][m];
}

6. 最小划分

给出一个正整数数组，把它分成 $S_1$ 和 $S_2$ 两部分，使 $S_1$ 的数字和与 $S_2$ 的数字和的差绝对值最小。

转化为求最大容量为 $sum/2$ 的背包问题。

724 · 最小划分 - LintCode

P3010 Dividing the Gold S - 洛谷

这题不仅需要求最小差，还需要求方案数量。

可以使状态 $dp[i]$ 为总和为 $i$ 的方案数。

初始化为 $dp[0]=1$，转移方程为 $dp[i]+=dp[i-a[i]]$。

但是需要从后往前求出最接近 $sum/2$ 的值，但是取模可能会破坏。

所以我们使用一个变量存储。

int a[N],ans,dp[N];
void solve(){
	int n,sum=0;cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];sum+=a[i];
	}
	dp[0]=1;
	for(int i=1;i<=n;i++){
		for(int j=sum/2;j>=a[i];j--){
			dp[j]+=dp[j-a[i]];
			if(dp[j]) ans=max(ans,j);
			dp[j]%=mod;
		}
	}
	cout<<sum-ans*2<<"\n"<<dp[ans]%mod;
}

7. 行走问题

给定一个整数 $n$ ，表示距离的步骤，一个人每次能走 $1\sim 3$ 步，问走到 $n$ 的方案数。

状态：$dp[i]$ 为走到 $i$ 的方案数转移方程：$dp[i]=dp[i-1]+dp[i-2]+dp[i-3],i>2$，初始化需判断大小

我觉得可以归结于计数类DP。

8. 矩阵最长递增路径

给定一个矩阵，找最长一条路径，要求路径上的数字递增。矩阵的每个点可以向四个方向移动。

第一种方法，记忆化搜索。

第二种方法，DP。

为了满足DP的无后效性，我们需要先从低的点算起，后面高的点对低的没有影响。

从低的点算起可以使用优先队列。

状态：$dp[i][j]$ 表示以坐标 $(i,j)$ 为终点的最长路径长度

转移方程：$dp[i][j]=max(dp[i-1][j],dp[i+1][j],dp[i][j-1],dp[i][j+1])+1,a[i][j]>a[next][next]$

struct nod{
	int i,j,num;
	friend bool operator < (nod a,nod b){
		return a.num>b.num;
	}
};
priority_queue<nod> q;
int bu[4][2]={1,0,0,1,-1,0,0,-1};
int n,m,dp[N][N],a[N][N],ans;
void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			dp[i][j]=1;
			cin>>a[i][j];
			nod x;x.i=i,x.j=j,x.num=a[i][j];
			q.push(x);
		}
	}
	while(!q.empty()){
		nod x=q.top();q.pop();
		int i=x.i,j=x.j,num=x.num;
		for(int k=0;k<4;k++){
			int xx=bu[k][0],yy=bu[k][1];
			if(a[i+xx][j+yy]<num) dp[i][j]=max(dp[i][j],dp[i+xx][j+yy]+1);
		}
		ans=max(ans,dp[i][j]);
	}
	cout<<ans;
}

P1434 滑雪 - 洛谷

9. 子集和问题

题意：给定一个非负整数的集合 S，一个值 M，问 S 中是否有一个子集，其子集和为 M。

题解：

暴力的时间复杂度为 $O(2^n)$。

状态：$dp[i][j]=1$ 表示 S 的前 i 个元素存在一个子集和等于 j 。

转移方程：

若 $s[i]>j$，则不能放入，$dp[i][j]=dp[i-1][j]$。
若 $s[i]<=j$，可以放或者不放，$$dp[i][j]=dp[i-1][j]~ ~dp[i-1][j-s[i]]$$

10. 最优游戏策略

题意：有 n 堆硬币排成一行，价值为 $v_i$，n为偶数；两人交替拿硬币，每次只能拿走第一堆或者最后一堆，先手拿的最大价值是多少？

状态：$dp[i][j]$ 表示从第 i 堆到第 j 堆区间内，先手能拿到的最大值。

在区间 $[i,j]$ ，先手有两个选择：

拿 i ，接着对手也可以选择拿 i+1 剩下$[i+2,j]$，或者拿 j 剩下 $[i+1,j-1]$
拿 j ，接着对手也可以选择拿 i 剩下 $[i+1,j-1]$，或者拿 j-1 剩下 $[i,j-2]$。

于是得到状态转移方程：

如果 $i=j$，$dp[i][j]=v[i]$
如果 $i+1=j$，$dp[i][j]=max(v[i],v[j])$
否则，后手必然对先手不利的拿法，$dp[i][j]=max(v[i]+min(dp[i+2][j],dp[i+1][j-1]),v[j]+min(dp[i+1][j-1],dp[i][j-2]))$

其实也就变化成了区间DP。

11. 矩阵链乘法

题意：给出一个数组 p，其中 $p[i-1]*p[i]$ 表示矩阵 $A_i$ 的尺寸，输出最少乘法次数。

还是一个区间DP。

状态：$dp[i][j]$，表示区间 $[i,j]$ 的最少乘法次数

转移方程：

若 $i=j$，$dp[i][j]=0$。
\[dp[i][j]=min(dp[i][k]+dp[k+1][j]+p_{i-1}p_kp_i),i≤k<j\]

12. 布尔括号问题

题意：布尔变量有真假两种取值，3 种逻辑操作与、或、异或。现在输入 n 个取值和 n-1 个逻辑操作，要使结果为真，有多少种括号方案？

状态：

$dp[i][j][1]$ 表示子表达式 $[i,j]$ 结果为true的方式数
$dp[i][j][0]$ 表示子表达式 $[i,j]$ 结果为false的方式数

#include <bits/stdc++.h>
using namespace std;
bool evaluate(int b1, int b2, char op){
	if (op == '&') return b1 & b2;
	if (op == '|') return b1 | b2;
	return b1 ^ b2;
}
int countWays(string s){
	int n = s.length();
	vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>(2, 0)));
	for (int i = 0; i < n; i += 2){
		dp[i][i][1] = (s[i] == 'T');
		dp[i][i][0] = (s[i] == 'F');
	}
	for (int len = 2; len < n; len += 2){    
		for (int i = 0; i < n - len; i += 2){
			int j = i + len;
			dp[i][j][0] = dp[i][j][1] = 0; 
			for (int k = i + 1; k < j; k += 2){
				char op = s[k];
				int leftTrue = dp[i][k - 1][1], leftFalse = dp[i][k - 1][0];
				int rightTrue = dp[k + 1][j][1], rightFalse = dp[k + 1][j][0];
				if (evaluate(1, 1, op))
					dp[i][j][1] += leftTrue * rightTrue;
				if (evaluate(1, 0, op))
					dp[i][j][1] += leftTrue * rightFalse;
				if (evaluate(0, 1, op))
					dp[i][j][1] += leftFalse * rightTrue;
				if (evaluate(0, 0, op))
					dp[i][j][1] += leftFalse * rightFalse;
				if (!evaluate(1, 1, op))
					dp[i][j][0] += leftTrue * rightTrue;
				if (!evaluate(1, 0, op))
					dp[i][j][0] += leftTrue * rightFalse;
				if (!evaluate(0, 1, op))
					dp[i][j][0] += leftFalse * rightTrue;
				if (!evaluate(0, 0, op))
					dp[i][j][0] += leftFalse * rightFalse;
			}
		}
	}
	return dp[0][n - 1][1]; 
}

int main(){
	string s = "T|T&F^T";
	cout << countWays(s) << endl;
	return 0;
}

13. 最短公共超序列

题意：给定两个字符串，求一个最短的字符串使两个字符串都是它的子序列。

找到两个字符串的LCS，然后将非LCS字符按照原始顺序插入到LCS中。

只求长度的话，$最短超序列长度=两字符串长度和-LCS长度$。

3. 数位统计DP

3.1 数位DP的递推实现

3.2 数位DP的记忆化搜索实现

P2602 数字计数 - 洛谷

题意：在 $[a,b]$ 中，$0\sim 9$出现了多少次。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=15;
ll dp[N][N][2][2];//位数,前面几个符合条件,前导0,某位上限
int num[N],now;
ll dfs(int pos,int sum,bool lead,bool limit){
	ll ans=0;
	if(pos==0) return sum;//递归到0位数，结束返回
	if(dp[pos][sum][lead][limit]!=-1) return dp[pos][sum][lead][limit];
	int up=(limit?num[pos]:9);
	for(int i=0;i<=up;i++){
		//计算000~099
		if(i==0&&lead) ans+=dfs(pos-1,sum,1,limit&&i==up);
		//计算200~299
		else if(i==now) ans+=dfs(pos-1,sum+1,0,limit&&i==up);
		//计算100~199
		else if(i!=now) ans+=dfs(pos-1,sum,0,limit&&i==up);
	}
	dp[pos][sum][lead][limit]=ans;
	return ans;
}
ll solve(ll x){
	int len=0;
	while(x){
		num[++len]=x%10;
		x/=10;
	}
	memset(dp,-1,sizeof(dp));
	return dfs(len,0,1,1);
}
int main(){
	ll a,b;cin>>a>>b;
	for(int i=0;i<=9;i++){
		now=i;
		cout<<solve(b)-solve(a-1)<<" ";
	}
	return 0;
}

3.3 数位DP例题

P2657 windy 数 - 洛谷

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=15;
ll dp[N][N][2][2];//位数,前面几个符合条件,前导0,某位上限
int num[N],now;
ll dfs(int pos,int pre,bool lead,bool limit){
	if(pos==0) return 1;
	if(dp[pos][pre][lead][limit]!=-1) return dp[pos][pre][lead][limit];
	ll ans=0;
	int up=limit?num[pos]:9;
	for(int i=0;i<=up;i++){
		if(abs(i-pre)<2) continue;
		if(i==0&&lead) ans+=dfs(pos-1,-2,1,limit&&i==up);
		else ans+=dfs(pos-1,i,0,limit&&i==up);
	}
	dp[pos][pre][lead][limit]=ans;
	return ans;
}
ll solve(ll x){
	int len=0;//cout<<"x=="<<x<<"\n";
	while(x){
		num[++len]=x%10;
		x/=10;
	}
	memset(dp,-1,sizeof(dp));
	return dfs(len,-2,1,1);
}
int main(){
	int T=1;//cin>>T;
	while(T--){
		ll a,x;cin>>a>>x;
//		cout<<solve(a)<<"\n";
		cout<<solve(x)-solve(a-1)<<"\n";
	}
	return 0;
}

P4124 手机号码 - 洛谷

ll dp[N][N][N][2][2][2];//位数,上上位，上一位，是否有4，是否有8
int num[N],now;
ll dfs(int pos,int pre1,int pre2,bool n3,bool n4,bool n8,bool limit){
	if(n4&&n8) return 0;
	if(pos==0) return n3;
	if(!limit&&dp[pos][pre1][pre2][n3][n4][n8]!=-1) return dp[pos][pre1][pre2][n3][n4][n8];
	ll ans=0;
	int up=limit?num[pos]:9;
	for(int i=0;i<=up;i++)
		ans+=dfs(pos-1,pre2,i,(i==pre1&&i==pre2)||n3,i==4||n4,i==8||n8,limit&&(i==up));
	if(!limit) dp[pos][pre1][pre2][n3][n4][n8]=ans;
	return ans;
}
ll solve(ll x){
	int len=0;
	while(x){num[++len]=x%10;x/=10;}
	if(len!=11) return 0;
	memset(dp,-1,sizeof(dp));
	ll ans=0;
	for(int i=1;i<=num[len];i++)
		ans+=dfs(len-1,-1,i,0,i==4,i==8,i==num[len]);
	return ans;
}

4. 状态压缩DP

4.1 Hamilton问题

用 $dp[S][j]$ 表示集合 S 内的最短Hamilton路径。

转移方程： $dp[S][j]=min\{dp[S-j][k]+dist(k,j)\},k \in S-j$

int n,dp[1<<20][21];
int dist[21][21];
int solve(){
	memset(dp,0x3f,sizeof(dp));
	cin>>n;
	for(int i=0;i<n;i++)//邻接矩阵
		for(int j=0;j<n;j++)
			cin>>dist[i][j];
	dp[1][0]=0;
	for(int S=1;S<(1<<n);S++)//从小集合扩展到大集合
		for(int j=0;j<n;j++)//枚举点j
			if((S>>j)&1)//S中含有点j
				for(int k=0;k<n;k++)
					if((S^(1<<j))>>k&1)//k属于S-j集合中
						dp[S][j]=min(dp[S][j],dp[S^(1<<j)][k]+dist[k][j]);
	return dp[(1<<n)-1][n-1];
}

4.2 状压DP原理

4.3 状压DP例题

4.4 三进制状压DP

HDU 3001

状态：$dp[j][i]$ 表示从城市 j 出发，按路径 i 访问 i 中所有城市的最小费用。

转移方程： $dp[j][i]=min(dp[j][i],dp[k][l]+graph[k][j]) ,k \in (i-j)$ 其中，$l=i-bit[j]$ ，表示从路径 i 中去掉城市 j。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=6e4,inf=0x3f3f3f3f;
int n,m;
int bit[12]={0,1,3,9,27,81,243,729,2187,6561,19683,59049};
int tri[N][11];
int dp[11][N];
int graph[11][11];//存图
void init(){//初始化,求所有可能路径
	for(int i=0;i<59050;i++){
		int t=i;
		for(int j=1;j<=10;j++){
			tri[i][j]=t%3;
			t/=3;
		}
	}
}
int com_dp(){
	int ans=inf;
	memset(dp,inf,sizeof(dp));
	for(int j=0;j<=n;j++)
		dp[j][bit[j]]=0;//初始化，从第j城市出发，只访问j，费用0
	for(int i=0;i<bit[n+1];i++){//遍历所有路径，每个i是一条路径
		int flag=1;//所有城市都遍历过一次以上
		for(int j=1;j<=n;j++){//遍历城市，以j为起点
			if(tri[i][j]==0){//是否有一个城市访问次数为0
				flag=0;//还没经过所有点
				continue;
			}
			for(int k=1;k<=n;k++){//遍历路径i-j的所有城市
				int l=i-bit[j];//从路径i中去掉第j个城市
				dp[j][i]=min(dp[j][i],dp[k][l]+graph[k][j]);
			}
		}
		if(flag)//找最小费用
			for(int j=1;j<=n;j++)
				ans=min(ans,dp[j][i]);//路径i上最下费用
	}
	return ans;
}
int main(){
	init();
	while(cin>>n>>m){
		memset(graph,inf,sizeof(graph));
		while(m--){
			int a,b,c;cin>>a>>b>>c;
			if(c<graph[a][b]) graph[a][b]=graph[b][a]=c;
		}
		int ans=com_dp();
		if(ans==inf) cout<<"-1\n";
		else cout<<ans<<"\n";
	}
	return 0;
}

5. 区间DP

5.1 石子合并问题

P1775 石子合并（弱化版） - 洛谷

int n,a[N],b[N];
int dp[N][N];
void solve(){
	cin>>n;
	memset(dp,0x3f,sizeof(dp));
	for(int i=1;i<=n;i++){
		cin>>a[i];b[i]=b[i-1]+a[i];
		dp[i][i]=0;
	}
	for(int len=1;len<n;len++)
		for(int i=1;i<=n-len;i++){
			int j=i+len;
			for(int k=i;k<j;k++){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+b[j]-b[i-1]);
			}
		}
	cout<<dp[1][n]<<"\n";
}

5.2 模板代码

int n,a[N],b[N];
int dp[N][N];
void solve(){
	//初始化
    
	for(int len=1;len<n;len++)//区间长度
		for(int i=1;i<=n-len;i++){//区间左端点
			int j=i+len;//区间右端点
			for(int k=i;k<j;k++){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);
			}
		}
	return dp[1][n];
}

5.3 区间DP例题

5.4 二维区间DP

Problem - F - Codeforces

题意：有一个 n*n 的方格图，某些方块为黑色，其余为白色。一次操作可以选定一个 h*w 的矩形，把其中所有方格涂成白色，代价是 $max(h,w)$，求最小代价涂所有方格。

时间复杂度 $O(n^5)$。

int n;
char a[N][N];
int dp[N][N][N][N];
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++) cin>>a[i][j];
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(a[i][j]=='.') dp[i][j][i][j]=0;
			else dp[i][j][i][j]=1;//黑格涂成白色需一次
	for(int lenx=1;lenx<=n;lenx++)
		for(int leny=1;leny<=n;leny++)
			for(int x1=1;x1<=n-lenx+1;x1++)
				for(int y1=1;y1<=n-leny+1;y1++){
					int x2=x1+lenx-1,y2=y1+leny-1;
					if(x1==x2&&y1==y2) continue;
					dp[x1][y1][x2][y2]=max(abs(x1-x2),abs(y1-y2))+1;//初始值
					for(int k=x1;k<x2;k++)
						dp[x1][y1][x2][y2]=min(dp[x1][y1][x2][y2],dp[x1][y1][k][y2]+dp[k+1][y1][x2][y2]);
					for(int k=y1;k<y2;k++)
						dp[x1][y1][x2][y2]=min(dp[x1][y1][x2][y2],dp[x1][y1][x2][k]+dp[x1][k+1][x2][y2]);
				}
	cout<<dp[1][1][n][n]<<"\n";
}

6. 树形DP

6.1 树形DP基本操作

P2015 二叉苹果树 - 洛谷

const int N=1e2+10;
struct nod{
	int v=0;
	int w=0;
};
vector<nod> edge[N];
int dp[N][N],sum[N];
int n,q;
void dfs(int u,int fa){
	for(int i=0;i<edge[u].size();i++){//用i遍历u的所有子节点
		int v=edge[u][i].v,w=edge[u][i].w;
		if(v==fa) continue;//不回头搜索，避免循环
		dfs(v,u);//递归到最深的叶子节点，然后返回
		sum[u]+=sum[v]+1;//子树上的总边数
		for(int j=min(q,sum[u]);j>=0;j--)
			for(int k=0;k<=min(sum[v],j-1);k++)
				dp[u][j]=max(dp[u][j],dp[u][j-k-1]+dp[v][k]+w);
	}
}
void solve(){
	cin>>n>>q;
	for(int i=1;i<n;i++){
		int u,v,w;cin>>u>>v>>w;
		edge[u].push_back({v,w});
		edge[v].push_back({u,w});
	}
	dfs(1,0);
	cout<<dp[1][q];
}

P1352 没有上司的舞会 - 洛谷

时间复杂度为 $O(n)$。

vector<int> edge[N];
int dp[N][2],a[N],fa[N];
int n,q;
void dfs(int u){
	dp[u][0]=0,dp[u][1]=a[u];
	for(int i=0;i<edge[u].size();i++){//用i遍历u的所有子节点
		int v=edge[u][i];
		dfs(v);
		dp[u][1]+=dp[v][0];
		dp[u][0]+=max(dp[v][0],dp[v][1]);
	}
}
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<n;i++){
		int u,v;cin>>u>>v;
		edge[v].push_back(u);
		fa[u]=v;
	}
	int t=1;
	while(fa[t]) t=fa[t];
	dfs(t);
	cout<<max(dp[t][0],dp[t][1])<<"\n";
}

6.2 背包与树形DP

7. 一般优化

P3287 方伯伯的玉米田 - 洛谷

树状数组优化

#define lowbit(x) ((x)&-(x))
const int N=5e3+505;
int a[2*N],dp[2*N][505],t[505][N],n,k;
void update(int x,int y,int d){//更新区间
	for(int i=x;i<=k+1;i+=lowbit(i))
		for(int j=y;j<=5500;j+=lowbit(j))
			t[i][j]=max(t[i][j],d);
}
int query(int x,int y){//查询区间最大值
	int ans=0;
	for(int i=x;i>0;i-=lowbit(i))
		for(int j=y;j>0;j-=lowbit(j))
			ans=max(ans,t[i][j]);
	return ans;
}
void solve(){
	cin>>n>>k;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=n;i++)
		for(int j=k;j>=0;j--){
			dp[i][j]=query(j+1,a[i]+j)+1;
			update(j+1,a[i]+j,dp[i][j]);
		}
	cout<<query(k+1,5500);
}

8. 单调队列优化

8.1 单调队列优化原理

8.2 单调队列优化例题

P2627 Mowing the Lawn G - 洛谷

ll n,k,a[N],sum[N],dp[N];
ll ds[N];
int q[N],head=0,tail=1;//递减的单调队列，队头最大
ll que_max(int j){
	ds[j]=dp[j-1]-sum[j];
	while(head<=tail&&ds[q[tail]]<ds[j]) tail--;//去掉队尾
	q[++tail]=j;//进队
	while(head<=tail&&q[head]<j-k) head++;
	return ds[q[head]];
}
void solve(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i<=n;i++) dp[i]=que_max(i)+sum[i];
	cout<<dp[n];
}

9. 斜率优化/凸壳优化

9.1 状态转移方程变换平面斜率问题

9.2 求一个DP[ i ]

9.3 求所有DP[ i ]

9.4 例题

10. 四边形不等式优化

10.1 应用场合

10.2 四边形不等式优化操作

10.3 四边形不等式定义和单调性定义

10.4 四边形不等式定理

10.5 例题

12届集美大学校赛题解

2025-05-10T00:00:00+00:00

12届集美大学校赛题解

官方难度排序参考：

Easy：GBJHD
Medium：CAEL
Hard：KIF

A、地砖

题意：m 的矩形，向每个格子中填充字母，使得：所有同字母联通块必须为正方形。

最小化从上到下，从左到右的字典序。

题解：

最小化字典序是经典的贪心问题。

我们按照从上到下，从左到右的顺序枚举每一个未填充格子的颜色，判断是否可行，需要的时候将已有的正方形向右方和下方扩充一行和一列。

填到一个格子的时候，其左右上方紧邻格子都可能填充过。

如果该颜色与上方或右方相同，这种情况不合法。

如果它与左边颜色不同，那么可以构成 1*1 方块。

如果它与左边颜色相同，我们就要进一步考察左边的方块。

如果左边的方块不是一个已有正方形的右上角，那么不合法。

否则我们将该正方形向右方和下方扩充一行和一列，无法扩充则不合法。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=110;
int sn,sm;
char a[N][N];
char get_color(char lc,char uc,char rc){
	for(char i='A';i<='Z';i++){
		if(i!=lc&&i!=uc&&i!=rc){
			return i;
		}
	}
} 
void work(int x,int y){
	char c=get_color(a[x-1][y],a[x][y-1],a[x][y+1]);
	int len=1;
	while(a[x+len][y-1]!=c&&a[x-1][y+len]!=c&&x+len<=sn&&y+len<=sm&&!a[x+len][y]&&!a[x][y+len]){
		char t=get_color(c,a[x-1][y+len],0);
		if(t<c)break;
		len++;
	}
	for(int i=x;i<=x+len-1;i++){
		for(int j=y;j<=y+len-1;j++){
			a[i][j]=c;
		}
	}
	return;
}
int main(){
	cin>>sn>>sm;
	int cn,cm;
	cn=sn,cm=sm;
	for(int i=1;i<=sn;i++){
		for(int j=1;j<=sm;j++){
			if(!a[i][j])work(i,j);
		}
	}
	for(int i=1;i<=cn;i++){
		for(int j=1;j<=cm;j++){
			cout<<a[i][j];
		}
		cout<<"\n";
	}
}

B、逃离蜂巢

题意：有𝑛个陷阱，每拆除一个陷阱，生命值先加 𝑎 再减去 𝑏。任意时刻生命值必须为正数，求一个最优顺序，在初始生命值为ℎ的情况下拆除最多陷阱。

题解：

按 a-b 从大到小排序，按顺序拿取即可。

ll n,h,ans=0;cin>>n>>h;
vector<ll> c(n);
for(int i=0;i<n;i++){
    ll a,b;cin>>a>>b;
    c[i]=a-b;
}
sort(c.begin(),c.end());
for(int i=n-1;i>=0;i--){
    h+=c[i];
    ans++;
    if(h<=0) {ans--;break;}
}
cout<<ans<<"\n";

C、加密通讯

题意：给出一个 01 字符串若干子串 1 个数的奇偶性，构造最小字典序的解。

题解：

考虑该串的前缀异或和 $s[i]$，则 $parity[l,r]=s[r] \wedge s[l-1]$。

这是一个经典的2-SAT问题。

其最小字典序的解可以从前向后逐位确定，注意限制 s[0]=0。

考虑异或前缀和是否相同的限制，题目保证有解的话就可以从任意已知的位置的值得到所有相关位置的值，位置 0 的前缀和为 0，所以从 0 开始计算，如果遇到一个没算过的位置 i，为了最小化答案字典序，就让位置 i 的前缀和与位置 i -1 的前缀和值相等，这样答案里位置 i 的值就是 0 了，扫一遍就可以。

//第一种代码
#include <bits/stdc++.h>
using namespace std;
const int N = 6e3 + 10;
int n, k;
int head[N], to[N << 1],nxt[N << 1], tot = 0; 
int s[N], ans[N];
void add(int u, int v){
	nxt[++tot] = head[u];
	to[tot] = v;
	head[u] = tot;
}
void dfs(int u){
	for(int i = head[u];i;i=nxt[i]){
		int v = to[i];
		if(!s[v]){
			s[v] = 1;
			dfs(v);
		} 
	}
}
int main(){
	int n, k;cin >> n >> k;
	n+=1;
	for(int i = 1; i <= k; i ++){
		int l, r, val;cin >> l >> r >> val;
		if(val == 0){
			add(r, l - 1);
			add(l - 1, r);
			add(r + n, l - 1 + n);
			add(l - 1 + n, r + n);
		}
		else{
			add(r, l - 1 + n);
			add(l - 1, r + n);
			add(r + n, l - 1);
			add(l - 1 + n, r);
		}
	}
	int st = 0;
	dfs(n);
	for(int i = 1; i<= n; i ++){
		int node = (!st)*n + i;
		if(!s[i] && !s[i + n]){
			ans[i] = st;
			dfs(node);
		}
		else if(s[i]){
			ans[i] = 1;
			dfs(i);
			st = 1;
		}
		else{
			ans[i] = 0;
			dfs(i + n);
			st = 0;
		}
	}
	for(int i = 1; i < n - 1; i ++)
		cout << (ans[i] ^ ans[i - 1]) << ' ';
	cout << (ans[n - 1] ^ ans[n - 2]);
	return 0;
}

//第2种代码
vector<pair<int,int> > v[3005];
int n,m,e[3005],ans[3005];
bool on[3005];
void solve(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int l,r,x;cin>>l>>r>>x;
		l--;
		v[l].push_back({r,x});
		v[r].push_back({l,x});
	}
	for(int i=0;i<=n;i++)
		if(on[i]==0){
			on[i]=1;
			if(i!=0) e[i]=e[i-1];
			queue<int> q;
			for(q.push(i);!q.empty();q.pop()){
				int now=q.front();
				for(auto [to,w]:v[now])
					if(on[to]==0){
					e[to]=e[now]^w;
					on[to]=1,q.push(to);
				}
			}
		}
	for(int i=1;i<=n;i++) ans[i]=e[i-1]^e[i];
	for(int i=1;i<=n;i++) cout<<ans[i]<<" \n"[i==n];
}

D、简易量筒

题意：有一条河以及 n 个杯子，每个杯子有一个容量。使用这些杯子，能否量出对应体积的水？Q 组询问。

题解：

使用容积为 A 的杯子，我们既可以将水增加 A 也可以减少 A。

因此能够量出的体积为 $\sum_{i=1}^nA_ix_i，x_i是整数$。

按照扩展欧几里得定理，其一定为 $gcd(A_1,A_2,...,A_n)$ 的倍数。

cin>>n>>q;
cin>>ans;
for(int i=2;i<=n;i++){
    ll x;cin>>x;
    ans=__gcd(ans,x);
}
while(q--){
    ll x;cin>>x;
    if(x%ans==0) cout<<"Yes\n";
    else cout<<"No\n";
}

E、复杂量筒

题意：有 n 个量筒，第 i 个量筒为 $i!$。

在凑出一定体积的液体的所有方案中，我们选择使用的量筒总数最小的那个。

求量出 $l \sim r$ 中所有整数体积各一次每个量筒需要用几次，q 组询问。

题解：

最优方案容易贪心，优先选取 n 号量筒，不够时再选取 n-1 号，以此类推。

因此对于 $l\sim r$ 中的每个数，都把它写出 $k*n!+b(b<n!)$ 的形式。

k 的部分是等差数列求和。

对 b 的部分，预处理 $0 \sim n!-1$ 的结果，其呈现周期排布，使用前缀和数组可以快速得出答案。

G、电话

题意：给出一个电话键盘和一个号码，求手指移动的总长。

题解：

打表预处理按键的位置，直接计算，时间复杂度 $O(n)$。

//按键位置，不知为什么，页面放这段代码就报错
string s;cin>>s;
int x=a[s[0]-'0'][0],y=a[s[0]-'0'][1],sum=0;
for(int i=1;i<s.size();i++){
    sum+=abs(x-a[s[i]-'0'][0])+abs(y-a[s[i]-'0'][1]);
    x=a[s[i]-'0'][0],y=a[s[i]-'0'][1];
}
cout<<sum<<"\n";

H、花坛

题意：求有多少种合法的方案在 n*m 花坛中放满至多 4 种花，满足不存在同行同种花距离 <=3 ，不存在同列同种花距离 <=3 。

题解：

考虑任意同行或同列连续四格，其必定互异。

然后可以发现，确定左上了 4*4 格，其余格子全部固定。

暴搜左上格子即可。

//暴搜代码
void dfs(ll x,ll y){
	if(y==m+1&&x!=n){
		dfs(x+1,1);
		return;
	}else if(y==m+1&&x==n){
		ans++;
		return ;
	}
	for(int i=1;i<=4;i++){
		ll x1= x-3>=1ll ?b[x-3][y]:-1ll;
		ll x2= x-2>=1ll ?b[x-2][y]:-1ll;
		ll x3= x-1>=1ll ?b[x-1][y]:-1ll;
		ll y1= y-3>=1ll ?b[x][y-3]:-1ll;
		ll y2= y-2>=1ll ?b[x][y-2]:-1ll;
		ll y3= y-1>=1ll ?b[x][y-1]:-1ll;
		if(x1==i||x2==i||x3==i||y1==i||y2==i||y3==i){
			continue;
		}else{
			b[x][y]=i;
			dfs(x,y+1);
			b[x][y]=0;
		}
	}
}

//AC代码
void init(){
	a[1][1]=4;a[1][2]=12;a[1][3]=24;a[1][4]=24;
	a[2][1]=12;a[2][2]=84;a[2][3]=264;a[2][4]=216;
	a[3][1]=24;a[3][2]=264;a[3][3]=1056;a[3][4]=576;
	a[4][1]=24;a[4][2]=216;a[4][3]=576;a[4][4]=576;
}
int main(){
	init();
	cin>>n>>m;
	if(n>=4&&m>=4) cout<<a[4][4]<<"\n";
	else if(n>=4) cout<<a[4][m]<<"\n";
	else if(m>=4) cout<<a[n][m]<<"\n";
	else cout<<a[n][m]<<"\n";
}

J、分子测序

题意：求三维空间中任意三点不共线，任意四点不共面的 𝑛 个顶点的凸多面体有多少个面。

题解：

考虑新添加一个顶点，其可以看作是在其中一面上向外扩展出一个四面体，新增加 $4-2=2$ 个面，答案为 $2n-4$ 。

int test;cin>>test;
while(test--){
    int n;cin >> n;
    cout<<2*n-4<<"\n";
}

L、董事会

题意：有 n 个石子组成一个环，每个石子有一个颜色。

对于每个 0≤k≤n ，判断是否能删除连续的 k 个石子，使得剩下的任意相邻两个石子不同色。

const int maxn = 1e6+114;
const ll mod = 1e9+7;
const ll base = 131;
ll pre[maxn],a[maxn],_pow[maxn];
int n;
int nxt[maxn],lst[maxn];
int ans[maxn];
bool chk(int l,int r,int L,int R){
	return ((pre[r]+mod-pre[l-1])%mod*_pow[L]%mod)==((pre[R]+mod-pre[L-1])%mod*_pow[l]%mod);
}		
void work(){
	cin>>n;
	_pow[0]=1;
	for(int i=1;i<=n;i++) _pow[i]=_pow[i-1]*base%mod;
	for(int i=1;i<=n;i++) cin>>a[i],pre[i]=(pre[i-1]+a[i]*_pow[i]%mod)%mod;
	nxt[n]=n;
	for(int i=n-1;i>=1;i--){
		if(a[i]==a[i+1]) nxt[i]=i;
		else nxt[i]=nxt[i+1];
	}
	lst[1]=1;
	for(int i=2;i<=n;i++){
		if(a[i]==a[i-1]) lst[i]=i;
		else lst[i]=lst[i-1];
	}
	ans[0]=(lst[n]==1&&a[1]!=a[n]);
	for(int i=n-1;i>1;i--){
		bool flag=false;
		for(int l=1,r=i;l<=n;l=r+1,r=min(n,l+i-1)){
			if(nxt[l]>=r&&a[l]!=a[r]&&r-l+1==i) flag=true;
			int L=r+1,R=min(n,L+i-1);
			if(L>R) continue;
			if(a[r]==a[L]) continue;
			int liml=r-max(lst[r],l)+1;
			int limr=min(nxt[L],R)-L+1;
			int xl=(r-l+1)-liml+1,xr=r-l+1;
			int yl=(r-l+1)+1,yr=(r-l+1)+limr;
			yl-=(i-1),yr-=(i-1);
			xl=max(xl,yl);
			xr=min(xr,yr);
			if(xl<=xr){
				if(chk(l-1+xl,l-1+xr,l-1+xl+i-1,l-1+xr+i-1)==false) flag=true;
			}
		}
		ans[n-i]=flag;
	}
	ans[n-1]=1;
	for(int i=1;i<n-1;i++){
		int xl=1,xr=nxt[1],yl=lst[n],yr=n;
		yl-=(i+1),yr-=(i+1);
		xl=max(xl,yl);
		xr=min(xr,yr);
		if(xl<=xr){
			if(chk(xl,xr,xl+i+1,xr+i+1)==false&&a[1]!=a[n]) ans[i]=true;
		}
	}
	for(int i=0;i<n;i++) cout<<ans[i];
	for(int i=0;i<n;i++) ans[i]=0;
}

CF Round 1023 (Div. 2)补题

2025-05-06T00:00:00+00:00

Codeforces Round 1023 (Div. 2) 补题

此次排名情况：

共8k+，排名1651，做出ABC三题。
Rating+81，当前为 1442 。
比赛链接

A. LRC and VIP

题意：有一个长度为 n 的数组 a ，你需要将数组分成 2 个序列，满足一下条件：

每个元素只能属于二者之一
每个序列至少包含一个元素
两个序列全部GCD不相等

题解：当数组 a 中的元素全部相等时，不论序列如何分，两序列gcd相等，不可能划分。

比较数组 a 中的最大值和最小值，如果最大值和最小值相等，输出 no。

否则将最大值一个元素作为序列，其余的作为另一个序列即可。

因为 $gcd(a,b)≤min(a,b)$ ，其余的元素的 gcd 肯定比最大值小，且不相等。

//获得最大值
m=*max_element(a.begin(),a.end());
//获得最小值
n=*min_element(a.begin(),a.end());

void solve(){
	int n;cin>>n;
	vector<int> a(n);
	for(int i=0;i<n;i++) cin>>a[i];
	//获得最大值最小值
	int mn=*min_element(a.begin(),a.end());
	int mx=*max_element(a.begin(),a.end());
	if(mn==mx){cout<<"No\n";return;}
	cout<<"Yes\n";
	for(int i=0;i<n;i++)
		cout<<(1+(a[i]==mx))<<"\n";
}

B. Apples in Boxes

题意：有一个长度为 n 的数组 a ，两个人轮流操作。

选择一个 a 中的大于 0 的元素，使这个 $a_i$ 减 1。
如果没有可以减的元素，当前人输。
如果操作后，数组中最大值 - 最小值大于 k ，那么当前人输。

题解：

假设 $max(a)-min(a)≤k$ 成立，并且至少有一个 $a_i≥1$。那么可以在保持这个条件的情况下拿走一个苹果。

我们从最大元素中减去，最小元素不会发生变化。即 $max(a)$ 减少 0 或者减少 1，$max(a)-min(a)$ 只会减少，与 k 进行比较显然成立。有一个特例，即所有元素都相同的情况，操作后极值的差由 0 变成 1。

因此，对于一个有 $max(a)-min(a)≤k$ 的数组来说，唯一输的方式，就是将所有的 $a_i$ 全部输掉，全部等于 0。执行 $\sum_{i=1}^{n} a_i$ 次操作后全部输掉，因为每个回合都只会减少 1 。

如果一开始数组就不成立，直接输出第一个人。

void solve(){
	int n,k;cin>>n>>k;
	vector<int> a(n);
	ll sum=0;
	for(int i=0;i<n;i++) cin>>a[i],sum+=a[i];
	sort(a.begin(),a.end());
	a[n-1]--;//最大值-1
	sort(a.begin(),a.end());
	if(a[n-1]-a[0]>k||sum%2==0) cout<<"Jerry\n";
	else cout<<"Tom\n";
}

C. Maximum Subarray Sum

题意：给你一个长度为 n 的数组 a 和一个正整数 k，数组中有些元素可以任意更改，使最大子数组和正好是 k 。

题解：

不可能的情况：将可替换元素全部改为 -INF，如果最大子数组和仍然大于 k ，答案不可能。还有，如果没有可替换元素，且最大子数组和不为 k ，答案不可能。

其余皆有可能。

将可替换元素全部改为 -INF，然后选某个可替换元素，计算此元素前面的最大子数组和，计算后面的最大子数组和，然后将这个元素更改为某个值，使最大子数组和为 k 即可。

void solve(){
	ll n,k;cin>>n>>k;
	string s;cin>>s;
	vector<ll> a(n);
	for(int i=0;i<n;i++) cin>>a[i];
	int pos=-1;
	for(int i=0;i<n;i++)
		if(s[i]=='0')
			pos=i,a[i]=-1e13;
	ll mx=0,cur=0;
	for(int i=0;i<n;i++){
		cur=max(cur+a[i],a[i]);
		mx=max(mx,cur);
	}
	if(mx>k||(mx!=k&&pos==-1)){
		cout<<"No\n";
		return;
	}
	if(pos!=-1){
		mx=0,cur=0;
		ll l,r;
		for(int i=pos+1;i<n;i++){
			cur+=a[i];
			mx=max(mx,cur);
		}
		l=mx;
		mx=0,cur=0;
		for(int i=pos-1;i>=0;i--){
			cur+=a[i];
			mx=max(mx,cur);
		}
		r=mx;
		a[pos]=k-l-r;
	}
	cout<<"Yes\n";
	for(int i=0;i<n;i++){
		cout<<a[i]<<" ";
	}
	cout<<"\n";
}

D. Apple Tree Traversing

题意：有一棵 n 个节点的树，每个节点上有一个苹果。你可以进行如下操作：

选择一条路径 (u,v)，这条路径每个节点上都有一个苹果。
假设 d 是路径上苹果的个数，依次写下三个数字 (d,u,v)。
然后去掉这条路径上所有的苹果

使写下的序列最大，输出序列。

题解：题解复杂度为 $O(nlogn)$。

一棵树中的最长路径为树的直径，可以使用树形DP或者搜索求解。

假设 $f_i,g_i$ 是 $i$ 的子树中从 $i$ 出发的最长和第二长路径，

则树的直径为 $max_{i=1}^n f_i+g_i$。

当我们找到直径 $(u,v)$ 时，让我们更新路径 $(lca(u,v),root)$ 上所有 $u$ 的直径 $f_u,g_u$。

使用 set 为每个节点 $u$ 查找 $f_u,g_u$ ，并使用 priority_queue 保持最大 $f_i+g_i$。总复杂度为 $O(nlogn)$。

2024贵州省赛M题

2025-05-04T00:00:00+00:00

题目描述：

GZU 的农学院在阅湖养了$n$ 只鸭子，每只鸭子的肉质都有其对应的鲜美度，第 $i$ 只鸭子的鲜美度是在$[l_i ,r_i]$中的任意整数。嘴馋的贵大人想知道这 $n$ 只鸭子的鲜美度单调不减的方案数，结果可能很大，请对 $998244353$ 取模。

输入：

第一行一个整数 $n (1≤n≤ 500 )$；

接下来 $n$ 行每行两个整数$l_i ,r_i (1≤l_i,r_i ≤10^9 )$。

输出：

输出满足条件的方案数，对 $998244353$ 取模。

样例：

样例1：

输入:

2
3 6
1 4

输出：

解释：对于第一组样例有以下三种方案：$(3,3),(3,4),(4,4)$。

样例2：

输入：

输出：

// --- 解法二：一维状态 dp[i] ---
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int main(){
	ios::sync_with_stdio(0),cin.tie(0);
	int n;cin>>n;
	vector<long long> l(n+1), r(n+1);
	for(int i = 1; i <= n; i++){
		cin >> l[i] >> r[i];
	}
	// 离散化边界
	vector<long long> coords(2*n);
	for(int i = 1; i <= n; i++){
		coords.push_back(l[i]);
		coords.push_back(r[i] + 1);
	}
	//排序
	sort(coords.begin(), coords.end());
	//去重
	coords.erase(unique(coords.begin(), coords.end()), coords.end());
	
	int segCount = coords.size() - 1;
	// 计算每个离散段长度
	vector<long long> segLen(segCount);
	for(int j = 0; j < segCount; j++){
		segLen[j] = coords[j+1] - coords[j];
	}
	// 每只鸭子可用的段区间 [L[i], R[i]]
	//离散化后重新分配值
	vector<int> L(n+1), R(n+1);
	for(int i = 1; i <= n; i++){
		int Li = lower_bound(coords.begin(), coords.end(), l[i]) - coords.begin();
		int Ri = lower_bound(coords.begin(), coords.end(), r[i] + 1) - coords.begin() - 1;
		L[i] = Li; R[i] = Ri;
	}
	// 预处理逆元，用于组合计算
	vector<long long> inv(n+2);
	inv[1] = 1;
	for(int i = 2; i <= n+1; i++){
		inv[i] = (MOD - (MOD/i) * inv[MOD % i] % MOD) % MOD;
	}
	// dp[j] = 前 j 只鸭子的合法方案数
	vector<long long> dp(n+1, 0), dpnext;
	dp[0] = 1;
	// 遍历所有离散段
	for(int s = 0; s < segCount; s++){
		// 预计算该段上取 t 个值的组合数 f[t] = C(segLen[s] + t - 1, t)
		vector<long long> f(n+1, 0);
		f[0] = 1;
		if(n >= 1) f[1] = segLen[s] % MOD;
		for(int t = 2; t <= n; t++){
			long long mul = (segLen[s] + t - 1) % MOD;
			f[t] = f[t-1] * mul % MOD * inv[t] % MOD;
		}
		// dpnext 初始为 dp（不选取该段）
		dpnext = dp;
		// 尝试在该段上添加更多鸭子（末尾连续 t 只鸭子）
		for(int j = 0; j <= n; j++){
			if(dp[j] == 0) continue;
			if(j == n) continue;
			// 查看第 j+1 只鸭子是否允许落在该段
			if(!(L[j+1] <= s && s <= R[j+1])) continue;
			// 从 j+1 开始尝试连续放鸭子
			for(int t = 1; j + t <= n; t++){
				int duckPos = j + t;
				if(!(L[duckPos] <= s && s <= R[duckPos])) break;
				dpnext[j+t] = (dpnext[j+t] + dp[j] * f[t]) % MOD;
			}
		}
		dp.swap(dpnext);
	}
	cout << dp[n] % MOD << "\n";
	return 0;
}

当然可以，下面我们来非常详细地解释这份采用一维状态 dp[i] 的代码解法，也称为「解法二」。本方法相比三维DP更优雅且节省空间，核心依然是“分段 + 动态规划 + 组合计数”。

🧩 一句话总结：

这个算法通过离散化数轴、将每段看作“等价”的数域，并对每段进行动态规划，维护“前 i 只鸭子选择合法数值的方案数”，最终求得满足所有鸭子鲜美度单调不减的合法选法总数。

🧱 步骤详细拆解：

✅ 1. 输入读取和区间保存

vector<long long> l(n+1), r(n+1);
for(int i = 1; i <= n; i++){
    cin >> l[i] >> r[i];
}

读入每只鸭子的鲜美度区间 $[l_i, r_i]$。数组开到 n+1 是为了从 1 开始编号，简化逻辑。

✅ 2. 离散化

vector<long long> coords(2*n);
for(int i = 1; i <= n; i++){
    coords.push_back(l[i]);
    coords.push_back(r[i] + 1);
}
sort(coords.begin(), coords.end());
coords.erase(unique(coords.begin(), coords.end()), coords.end());

目的：由于 $l_i$ 和 $r_i$ 范围最大是 $10^9$，直接用这些值建DP数组不现实。因此我们：

把所有区间端点和 $r_i+1$ 加入 coords；
排序 + 去重，构造一个稀疏的、关键的“段落分界点”数组；
最终得到的段数是 segCount = coords.size() - 1，每一段为半开区间 $[x_j, x_{j+1})$。

✅ 3. 计算每个段的长度

for(int j = 0; j < segCount; j++){
    segLen[j] = coords[j+1] - coords[j];
}

段的长度也就是该段中一共包含多少整数（对组合数计算有用）。

✅ 4. 每只鸭子允许的段编号范围

for(int i = 1; i <= n; i++){
    int Li = lower_bound(coords.begin(), coords.end(), l[i]) - coords.begin();
    int Ri = lower_bound(coords.begin(), coords.end(), r[i] + 1) - coords.begin() - 1;
    L[i] = Li; R[i] = Ri;
}

这里将每只鸭子的原始区间 $[l_i, r_i]$ 映射成在离散段上的编号范围 $[L[i], R[i]]$。

注意：r[i]+1 是为了保持半开区间的一致性。

✅ 5. 预处理组合数用的逆元

inv[1] = 1;
for(int i = 2; i <= n+1; i++){
    inv[i] = (MOD - (MOD/i) * inv[MOD % i] % MOD) % MOD;
}

用来求组合数 $C(a + b - 1, b)$ 中除法的逆元（因为模数是质数，用费马小定理即可）。

✅ 6. 动态规划初始化

vector<long long> dp(n+1, 0), dpnext;
dp[0] = 1;

dp[i] 表示前 i 只鸭子构成合法非降序列的方案数。
初始只有 0 只鸭子时方案数为 1（空集）。

✅ 7. 遍历所有段，尝试“集中放一段鸭子”

for(int s = 0; s < segCount; s++){

我们依次枚举每一个段 s，在该段上尝试分配一组连续的鸭子。段的顺序是“从小到大”，天然满足了单调不减性要求。

✅ 8. 预处理该段上的组合数：f[t] 表示从该段中取 t 个非降序数的方式

vector<long long> f(n+1, 0);
f[0] = 1;
if(n >= 1) f[1] = segLen[s] % MOD;
for(int t = 2; t <= n; t++){
    long long mul = (segLen[s] + t - 1) % MOD;
    f[t] = f[t-1] * mul % MOD * inv[t] % MOD;
}

这是关键！

f[t] 表示从该段中取 t 个值（允许重复，非降序）的方法数，等价于隔板法中的：

(segLen+t−1t)\binom{\text{segLen} + t - 1}{t}

为什么用这个组合？因为段内所有数是“等价”的，我们只需要计数 “在这一段上放 t 只鸭子” 的方法总数。

✅ 9. 状态转移：从前 j 只鸭子的状态扩展

dpnext = dp; // 默认继承上次的 dp

for(int j = 0; j <= n; j++){
    if(dp[j] == 0) continue;
    if(j == n) continue; // 已经满了

    // 看第 j+1 只鸭子是否能放在段 s 上
    if(!(L[j+1] <= s && s <= R[j+1])) continue;

    for(int t = 1; j + t <= n; t++){
        int duckPos = j + t;
        if(!(L[duckPos] <= s && s <= R[duckPos])) break;

        // 将 dp[j] 状态扩展 t 个鸭子到当前段
        dpnext[j + t] = (dpnext[j + t] + dp[j] * f[t]) % MOD;
    }
}

每次尝试从已有的 j 只鸭子的状态出发，尝试在当前段 s 上安排 t 只新的鸭子；
必须保证这 t 只新鸭子都允许选在当前段；
然后用组合数 f[t] 更新新的状态 dp[j+t]。

✅ 10. 最终答案

cout << dp[n] % MOD << "\n";

最终 dp[n] 就是我们要的答案：全部 n 只鸭子，满足单调不减，每只鸭子在其合法区间内的总方案数。

🧠 总结重点

模块	核心技巧
离散化	降维处理、减小状态空间
动态规划	状态 `dp[i]`，表示前 i 只鸭子合法方案
状态转移	枚举段，集中安排一段连续鸭子
组合数预处理	使用隔板法 + 模逆元计算
单调性保证	因为按段递增枚举，无需显式检查非降

《算法竞赛入门到进阶》DP版

2025-05-03T00:00:00+00:00

动态规划学习（1）

《算法竞赛入门到进阶》学习。

《算法竞赛入门到进阶》

1. 动态规划的概念和思想

DP（Dynamic Programming）是一种算法思想，不是一个特定的算法。

DP与分治法的区别：

分治法是将问题分成独立的子问题，每个子问题能独立解决
DP的子问题是相关的，前面子问题的解决结果被后面的子问题使用。

求解DP有 $3$ 步，定义状态、状态转移、算法实现。

2. 基础DP

基础DP是一些经典问题，如递推、01背包、最长公共子序列（LCS）、最长递增子序列（LIS）等。

2.1 硬币问题

2.1.1 最少硬币问题

有 n 种硬币，面值分别为 $v_1,v_2,…,v_n$，数量无限。输入非负整数 s，选硬币使其和为 s。要求输出最少硬币组合。

void solve(){
	int S=251,N=5,s;
	int Min[S],v[5]={1,5,10,25,50};
	memset(Min,0x3f,sizeof(Min));
	Min[0]=0;
	for(int j=0;j<N;j++)
		for(int i=v[j];i<S;i++)
			Min[i]=min(Min[i],Min[i-v[j]]+1);
	cin>>s;
	cout<<Min[s]<<"\n";
}

上述时间复杂度是 $O(SN)$。

2.1.2 打印最少硬币组合

在DP中，除求最优解的数量外，往往还要求输出最优解本身。

在最少硬币问题中，如果要求打印组合方案，需要增加一个记录表 Min_path[i]，记录金额 i 需要的最后一个硬币。利用 Min_path[] 逐步倒推，就能得到所有的硬币。

void prin(int *Min_path,int s){
	while(s){
		cout<<Min_path[s]<<" ";
		s=s-Min_path[s];
	}
}
void solve(){
	int S=251,N=5,s;
	int Min[S],v[5]={1,5,10,25,50};
	int Min_path[S]={0};
	memset(Min,0x3f,sizeof(Min));
	Min[0]=0;
	for(int j=0;j<N;j++)
		for(int i=v[j];i<S;i++){
			if(Min[i]>Min[i-v[j]]+1){
				Min_path[i]=v[i];
				Min[i]=min(Min[i],Min[i-v[j]]+1);
			}
		}
	cin>>s;
	prin(Min_path,s);
}

用数组存储由哪个状态转移而来，即可得到转移路径。

2.1.3 所有硬币组合

有 n 种硬币，面值分别为 $v_1,v_2,…,v_n$，数量无限。输入非负整数 s，选硬币使其和为 s。要求输出所有的硬币组合数量。

如果选取硬币的数量无限：

void solve(){
	int S=251,N=5,s;
	int dp[S]={0},v[5]={1,5,10,25,50};
	dp[0]=1;
	for(int i=0;i<N;i++)
		for(int j=v[i];j<S;j++)
			dp[j]=dp[j]+dp[j-v[i]];
	cin>>s;
	cout<<dp[s]<<"\n";
}

如果选取的硬币数量有限：

void solve(){
	int C=101,M=251;
	int dp[M][C]={0};
	int v[5]={1,5,10,25,50};
	int ans[M]={0};
	dp[0][0]=1;
	for(int i=0;i<5;i++)
		for(int j=1;j<C;j++)
			for(int k=v[i];k<M;k++)
				dp[k][j]+=dp[k-v[i]][j-1];
	for(int i=0;i<M;i++)
		for(int j=0;j<C;j++)
			ans[i]+=dp[i][j];
	int s;
	while(cin>>s)
		cout<<ans[s]<<"\n";
}

2.2 01背包问题

约束条件： $\sum_{i=1}^{n} w_ix_i≤C ~,~ x_i∈\{0,1\},1≤i≤n$ 目标函数： $max\sum_{i=1}^{n}v_ix_i$ 基础代码如下：

void solve(){
	int n,m;
	cin>>n>>m;
	int w[n],v[n],dp[n][m+1]={0};
	for(int i=0;i<n;i++) cin>>w[i];
	for(int i=0;i<n;i++) cin>>v[i];
	for(int i=0;i<n;i++){
		for(int j=0;j<=m;j++){
			if(j<v[i]) dp[i][j]=dp[i-1][j];
			else dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
		}
	}
	cout<<dp[n][m]<<"\n";
}

滚动数组覆盖了中间转移状态，只留下了最后的状态，所有损失了很多信息，导致无法输出背包的方案。

滚动数组优化：

void solve(){
	int n,m;
	cin>>n>>m;
	int w[n],v[n],dp[m+1]={0};
	for(int i=0;i<n;i++) cin>>w[i];
	for(int i=0;i<n;i++) cin>>v[i];
	for(int i=0;i<n;i++){
		for(int j=m;j>=v[i];j--){
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
		}
	}
	cout<<dp[m]<<"\n";
}

2.3 最长公共子序列（LCS）

最长公共子序列（Longest Common Subsequence）问题：给定两个序列 X 和 Y，找出 X 和 Y 的一个最长公共子序列。

用 $dp[i][j]$ 表示子序列 $X_i$ 和 $Y_j$ 的最长公共子序列长度。

当 $X_i=Y_i$ 时，找出 $X_{i-1}$ 和 $Y_{i-1}$ 的最长公共子序列，然后在其尾部加上 $X_i$ 即可得到 $X$ 和 $Y$ 的最长公共子序列。

当 $X_i≠Y_i$ 时，最长公共子序列就是 $[X_{i-1},Y_j]$ 的LCS和 $[X_i,Y_{j-1}]$ 的LCS二者中最大值。

void solve(){
	string s1,s2;
	cin>>s1>>s2;
	int dp[s1.size()+1][s2.size()+1]={0};
	for(int i=1;i<=s1.size();i++)
		for(int j=1;j<=s2.size();j++){
			if(s1[i-1]==s2[j-1]) dp[i][j]=dp[i-1][j-1]+1;
			else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
		}
	cout<<dp[s1.size()][s2.size()]<<"\n";
	return ;
}

滚动数组优化：

void solve(){
	string s1,s2;
	cin>>s1>>s2;
	int dp[2][s2.size()+1];
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=s1.size();i++)
		for(int j=1;j<=s2.size();j++){
			if(s1[i-1]==s2[j-1]) dp[i%2][j]=dp[(i-1)%2][j-1]+1;
			else dp[i%2][j]=max(dp[(i-1)%2][j],dp[i%2][j-1]);
		}
	cout<<dp[s1.size()%2][s2.size()]<<"\n";
	return ;
}

这里不能定义 $int~dp[2][s2.size()+1]=\{0\}$ ，这样dp数组为变长数组（VLA），VLA是C99特性，不是标准C++的一部分，某些编译器（如GCC扩展）可能无法正确初始化。

2.4 最长递增子序列（LIS）

最长递增子序列（Longest Increasing Subsequence）。

第一种方法，将序列排序后与原序列求最长公共子序列即为LIS，复杂度为 $O(N^2)$。

void solve(){
	int n;cin>>n;
	int a[n],b[n],dp[2][n+1];
	for(int i=0;i<n;i++) cin>>a[i],b[i]=a[i];
	sort(b,b+n);
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++){
			if(a[i-1]==b[j-1]) dp[i%2][j]=dp[(i-1)%2][j-1]+1;
			else dp[i%2][j]=max(dp[(i-1)%2][j],dp[i%2][j-1]);
		}
	cout<<dp[n%2][n]<<"\n";
}

第二种方法，直接DP求解，状态 $dp[i]$ 表示以第 $i$ 个数为结尾的LIS长度，状态转移方程为 $dp[i]=max\{0,dp[j]\}+1,~0<j<i,A_j<A_i$ ，

答案为 $max\{dp[i]\}$，复杂度为 $O(N^2)$ 。

void solve(){
	int n,ans=0;cin>>n;
	int a[n],dp[n+1];
	for(int i=0;i<n;i++) cin>>a[i];
	memset(dp,0,sizeof(dp));
	for(int i=0;i<n;i++){
		dp[i]=1;
		for(int j=0;j<i;j++)
			if(a[j]<a[i]) dp[i]=max(dp[i],dp[j]+1);
	}
	for(int i=0;i<n;i++) ans=max(ans,dp[i]);
	cout<<ans<<"\n";
}

第三种方法，单调队列，复杂度为 $O(nlogn)$。

void solve(){
	int n,ans=0;cin>>n;
	int a[n];
	for(int i=0;i<n;i++) cin>>a[i];
	vector<int> v;
	v.push_back(a[0]);
	for(int i=1;i<n;i++){
		int x=upper_bound(v.begin(),v.end(),a[i])-v.begin();
		if(x==v.size()) v.push_back(a[i]);
		else v[x]=a[i];
	}
	cout<<v.size()<<"\n";
}

3. 递推与记忆化搜索

记忆化搜索，在用递归实现DP时，在递归程序中记录计算过的状态，并在后续的计算中跳过已经算过的重复状态。

在很多情况下，记忆化搜索的逻辑思路和程序比直接写递推更简单。

4.区间DP

区间DP的主要思想是现在小区间进行DP得到最优解，再利用小区间的最优解合并求大区间的最优解。

区间DP的两个难点，枚举所有可能的区间、状态转移方程。

下面用两个经典问题讲解：

4.1 石子合并问题

设有 $N$堆石子排成一排，其编号为 $1,2,3,\cdots,N$。每堆石子有一定的质量 $m_i$。现在要将这 $N$ 堆石子合并成为一堆。每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻。输出最小代价。

状态：$DP[i][j]$ 为从第 $i$ 堆石子到第 $j$ 堆石子的最小花费。

转移方程：$dp[i][j]=min(dp[i][k]+dp[k+1][j])+sum[i][j],i≤k≤j$

void solve(){
	int n;cin>>n;
	int m[N],dp[N][N],sum[N];
	sum[0]=0;
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++) 
		cin>>m[i],sum[i]=sum[i-1]+m[i];
	for(int len=1;len<n;len++){
		for(int i=1;i+len<=n;i++){
			int j=i+len;
			dp[i][j]=0x3f3f3f3f;
			for(int k=i;k<=j;k++){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
			}
		}
	}
	cout<<dp[1][n]<<"\n";
}

时间复杂度为 $O(n^3)$，只能用来处理规模 $n<250$ 的问题。

上述三重循环中，前两重循环是枚举所有可能的合并，无法优化，最后一重循环枚举分割点 $k$ ，是可以优化的。因为每次运行最后一层循环时，都在某个子区间内部寻找最优分割点，该操作在多个子区间是重复的。如果找到这个最优点后保存下来，用于下一次循环，就能避免重复计算。

用 $s[i][j]$ 表示区间 $[i,j]$ 中的最优分割点，第三重循环可以从区间 $[i,j-1)$ 的枚举优化到区间 $[s[i][j-1],s[i+1][j]]$ 的枚举。其中， $s[][]$ 的值是在前面的三重循环中找到并记录下来的。符合 “平行四边形优化” 的原理。

void solve(){
	int n;cin>>n;
	int m[N],dp[N][N],sum[N],s[N][N];
	sum[0]=0;
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++) 
		cin>>m[i],sum[i]=sum[i-1]+m[i],s[i][i]=i;
	for(int len=1;len<n;len++){
		for(int i=1;i+len<=n;i++){
			int j=i+len;
			dp[i][j]=0x3f3f3f3f;
			for(int k=s[i][j-1];k<=s[i+1][j];k++){
				if(dp[i][j]>dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]){
					dp[i][j]=dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1];
					s[i][j]=k;
				}
			}
		}
	}
	cout<<dp[1][n]<<"\n";
}

优化后，复杂度接近 $O(n^2)$ ，可以解决 $n<3000$ 的问题。

4.2 回文串问题

回文串问题：给定一个字符串，然后通过增加和删除部分字符串得到一个回文串，每个字母每种操作代价不同，求最小代价。

定义状态 $dp[i][j]$ 表示字符串 $s$ 的子区间 $s[i,j]$ 变成回文的最小花费。

void solve(){
	int n,m,w[26];
	cin>>m>>n;
	string s;
	cin>>s;s=" "+s;
	while(m--){
		char c;int l,r;
		cin>>c>>l>>r;
		w[c-'a']=min(l,r);
	}
	int dp[N][N]={0};
	for(int len=1;len<n;len++){
		for(int i=1;i<=n-len;i++){
			int j=i+len;
			if(s[i]==s[j]){
				dp[i][j]=dp[i+1][j-1];
			}else dp[i][j]=min(dp[i+1][j]+w[s[i]-'a'],dp[i][j-1]+w[s[j]-'a']);
		}
	}
	cout<<dp[1][n]<<"\n";
}

5. 树形DP

树本身具有 “子结构” 性质，具有递归性，符合DP的性质。

例题1：不相邻最大权值

一颗有根树上的每个结点有一个权值，相邻的父结点和子结点只能选择一个，如何选择使总权值之和最大。

状态：

$dp[i][0]$ 表示不选择 $i$ 结点时最优解；
$dp[i][1]$ 表示选择 $i$ 结点时最优解。

转移方程：

\[dp[i][0]+=max(dp[son][1],dp[son][0])\]
\[dp[i][1]+=dp[son][0]\]
以上 $son$，表示子结点，兄弟关系无限制，所以是兄弟求和

#include<bits/stdc++.h>
using namespace std;
const int N=6e3+5;
int value[N],dp[N][2],father[N],n;
vector<int> tree[N];//邻接表
void dfs(int u){
	dp[u][1]=value[u];
	for(int i=0;i<tree[u].size();i++){
		int son=tree[u][i];
		dfs(son);
		dp[u][0]+=max(dp[son][0],dp[son][1]);
		dp[u][1]+=dp[son][0];
	}
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>value[i];
	memset(father,-1,sizeof(father));
	for(int i=1;i<n;i++){
		int a,b;cin>>a>>b;
		tree[b].push_back(a);
		father[a]=b;
	}
	int t=1;
	while(father[t]!=-1) t=father[t];//查找根节点
	dfs(t);
	cout<<max(dp[t][0],dp[t][1])<<"\n";
	return 0;
}

上述遍历每一个结点，复杂度为 $O(n)$。

例题2：最远距离

一棵有根树，根节点为 1 ，对其中任意个结点，求最远结点的距离。

状态：

$dp[i][0]$ ：结点 i 的子树到 i 的最长距离
$dp[i][1]$ ：结点 i 的子树到 i 的次长距离
$dp[i][2]$ ：结点 i 往上父节点走的最长距离

#include<bits/stdc++.h>
using namespace std;
const int N=10100;;
struct Node{
	int id;//结点编号
	int cost;//第i结点连接到id结点的边权
};
vector<Node> tree[N];//邻接表
int dp[N][3];
int n;
void init_read(){
	for(int i=1;i<=n;i++) tree[i].clear();
	memset(dp,0,sizeof(dp));
	for(int i=2;i<=n;i++){
		int x,y;cin>>x>>y;
		Node tmp;
		tmp.id=i,tmp.cost=y;//i是x的子结点
		tree[x].push_back(tmp);
	}
}
void dfs1(int u){//dfs,先处理子结点,再处理父结点
	int one=0,two=0;
	for(int i=0;i<tree[u].size();i++){
		//遍历结点father的所有子结点
		Node child=tree[u][i];
		dfs1(child.id);//递归子结点
		int cost=dp[child.id][0]+child.cost;
		//更新最长距离和次长距离
		if(cost>=one){
			two=one;
			one=cost;
		}
		if(cost<one&&cost>two) two=cost;
	}
	dp[u][0]=one;
	dp[u][1]=two;
}
void dfs2(int u){//先处理父结点，再处理子结点
	for(int i=0;i<tree[u].size();i++){
		Node child=tree[u][i];
		if(dp[child.id][0]+child.cost==dp[u][0])//child在最长距离子树上
			dp[child.id][2]=max(dp[u][2],dp[u][1])+child.cost;
		else dp[child.id][2]=max(dp[u][2],dp[u][0])+child.cost;
		dfs2(child.id);
	}
}
int main(){
	while(cin>>n){
		init_read();//初始化，读入
		dfs1(1);//计算dp[][0],dp[][1]
		dp[1][2]=0;
		dfs2(1);//计算dp[][2]
		for(int i=1;i<=n;i++)
			cout<<max(dp[i][0],dp[i][2])<<"\n";
	}
}

6. 数位DP

数位DP：对数字的 “位” 进行与计数有关的DP。

在数位DP中，一般可以使用模板来做这种题型。

状态：$dp[i][j]$ 表示第 $i$ 位数中为 $j$ 的符合要求的数个数

转移方程：$dp[i][j]= \sum_{k=0}^{9} dp[i-1][k],特殊条件$

处理完DP数组后，根据给定的范围求答案。

如一个六位数 362415=000000~099999+100000~199999+200000~299999+300000~362415

\[ans=dp[6][0]+dp[6][1]+dp[6][2]+300000 \sim 362415\]

其中 300000~362415又可以看成00000~62415，但是涉及后一位的时候也需要特判。

例题1：不含62和4

在区间 $[m,n]$ 中，不含 62 和 4 的数字个数。

按照上面模板，我们只需要特判第 i 位为 4 或者第 i 位为 6 且上一位为 2 时continue就行了。

#include<bits/stdc++.h>
using namespace std;
int dp[100][10];
void init(){
	dp[0][0]=1;//初始化
	for(int i=1;i<=7;i++){//位数
		for(int j=0;j<=9;j++){//第i位值为j，后面全为0
			for(int k=0;k<=9;k++){//枚举上一位的所有可能值
				if(j==4||j==6&&k==2) continue;
				dp[i][j]+=dp[i-1][k];
			}
		}
	}
}
int solve(int x){//求1~k中有多少符合的数
	int len=0,digit[10],ans=0;
	memset(digit,0,sizeof(digit));
	while(x){
		digit[++len]=x%10;x/=10;
	}
	for(int i=len;i>=1;i--){
		for(int j=0;j<digit[i];j++){
			if(j==4||j==2&&digit[i+1]==6) continue;
			ans+=dp[i][j];
		}
		if(digit[i]==4||digit[i]==2&&digit[i+1]==6) break;
	}
	return ans;
}
int main(){
	int n,m;
	init();
	while(cin>>n>>m){
		if(n==0&&m==0) break;
		cout<<solve(m+1)-solve(n)<<"\n";
	}
	return 0;
}

7.状态压缩DP

每个状态 $dp[i][j]$ 表示的不是一个数值如花费长度等，而是代表集合的数量，这种处理复杂集合问题的DP叫做状态压缩DP。

集合的状态有很多，往往把方案用二进制数表示，即压缩成二进制。

例题1：Corn Fields G

在一块长方形的土地上，有的格子能种，有的不能种，选择格子种草，草不会相邻，有多少种方案？

状态：$dp[i][j]$表示在第 $i$ 行状态为 $j$ 的方案数

$f$ 数组表示DP数组，$g$ 数组判断状态是否合法，$F$ 数组表示输入每行可种植状态。9C0E37D6

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int p=100000000;
ll f[13][1<<12],n,m;
ll g[1<<12],a[13][13];
ll F[13];
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>a[i][j];
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			F[i]=(F[i]<<1)+a[i][j];//第i行能种的格子
	for(int i=0;i<(1<<m);i++){//枚举所有状态
		if(!(i&(i>>1))&&!(i&(i<<1))){//第i位左右都没有1
			g[i]=1;
			if((i&F[1])==i) f[1][i]=1;//是第一行的某状态
		}
	}
	for(int x=2;x<=n;x++)
		for(int j=0;j<(1<<m);j++)
			if(((j&F[x-1])==j)&&g[j])//状态可以在上一行&&可行
				for(int k=0;k<(1<<m);k++)
					if(((k&F[x])==k)&&!(j&k)&&g[k]){//状态可以在当行&&与上状态不相邻&&可行
						f[x][k]=(f[x][k]+f[x-1][j])%p;
					}
	int ans=0;
	for(int i=0;i<(1<<m);i++)
		ans=(ans+f[n][i])%p;
	cout<<ans;
	return 0;
}

例题2：旅行商问题（TSP）

有 n 个城市，知道任何两个城市之间的距离，从某城市出发经过每个城市且只经过一次，最后回到出发城市的最少花费。

这是NP难度的，没有多项式时间的高效算法。

状态：

\[S:已经访问过的城市集合\]
\[v:当前所在城市\]
\[dp[S][v]:从v出发访问所有未访问城市且回到起点的最小花费\]

状态转移：

\[dp[V][0]=0,V是最后一个城市\]
\[dp[S][v]=min(dp[S \cup {u}][u]+dist(v,u)) ,u \notin S\]

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,c[20][20],f[1<<20][20];
//f[城市经过状态][当前所在城市]=从当前城市出发经过未经过城市的费用最小
int main(){
	cin>>n;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			cin>>c[i][j];
	memset(f,0x3f,sizeof(f));//将dp数组赋值很大
	f[(1<<n)-1][0]=0;//全部节点都到达过
	for(int s=(1<<n)-2;s>=0;s--){
		for(int v=0;v<n;v++){
			//枚举当前集合，售货员所在位置
			for(int u=0;u<n;u++){
				if((s>>u)&1) continue;//已经到过u节点
				f[s][v]=min(f[s][v],f[s|(1<<u)][u]+c[v][u]);
				//经过u节点
			}
		}
	}
	cout<<f[0][0];
	return 0;
}

例题3：TSP变形

访问 n 个城市，可以从任意城市开始，每个城市访问的次数不少于1次，不多于2次。n 个城市之间有m条道路，每条道路有花费。最少费用是多少。

在普通TSP中，只有访问和不访问两种状态，这个题有3种情况，可以使用三进制压缩状态。

在下面代码中，$tri[i][j]$ 表示第 i 个路径，其第 j 位的值是城市状态。

状态：

$dp[i][j]$ ：当前所在城市 i 出发访问所有剩余城市的后回到起点的最小值。

转移：

\[dp[i][j]=min(dp[i][j],dp[k][l]+graph[k][i])\]

#include<bits/stdc++.h>
using namespace std;
int n,m;
//三进制每位权值
int bit[12]={0,1,3,9,27,81,243,729,2187,6561,19683,59049};
int tri[60000][11];
int dp[11][60000];
int graph[11][11];//存图
void make_trb(){//初始化，所有可能路径
	for(int i=0;i<59050;++i){//共3^10=59049+1种状态
		int t=i;
		for(int j=1;j<=10;++j){
			tri[i][j]=t%3;t/=3;
		}
	}
}
int cmp_dp(){
	int ans=0x3f3f3f3f;
	memset(dp,0x3f,sizeof(dp));
	for(int i=0;i<=n;i++) 
		dp[i][bit[i]]=0;//bit[i]是第i个城市，起点任意
	for(int i=0;i<bit[n+1];i++){
		int flag=1;//所有的城市都遍历过1次以上
		for(int j=1;j<=n;j++){//选一个终点
			if(tri[i][j]==0){//判断终点位是否为0
				flag=0;//还没有经历终点
				continue;
			}
			if(i==j) continue;
			for(int k=1;k<=n;k++){
				int l=i-bit[j];//i状态的第j位置
				if(tri[i][k]==0) continue;
				dp[j][i]=min(dp[j][i],dp[k][l]+graph[k][j]);
			}
		}
		if(flag)//找最小费用
			for(int j=1;j<=n;j++)
				ans=min(ans,dp[j][i]);
	}
	return ans;
}
int main(){
	make_trb();
	while(cin>>n>>m){
		memset(graph,0x3f,sizeof(graph));
		while(m--){
			int a,b,c;cin>>a>>b>>c;
			if(c<graph[a][b]) graph[a][b]=graph[b][a]=c;
		}
		int ans=cmp_dp();
		if(ans==0x3f3f3f3f) cout<<"-1\n";
		else cout<<ans<<"\n";
	}
	return 0;
}

2025年5月2日CF补题

2025-05-02T00:00:00+00:00

Codeforces Round 1022 (Div. 2) 补题

此次排名情况：

共8k+，排名3037，做出ABC三题。
Rating+35，当前为 1361 。
比赛链接

A. Permutation Warm-Up

题意：给定一个数字 $n$ ，求 $1\sim n$ 的所有排列与 $1 \sim n$ 差值的和的不同数量。

赛时我通过部分样例总结规律，得出会 $1,1,2,2,3,3,...$ 的差值往下增加。

于是先预处理，然后输出。

vector<int> vt(510);
void init(){
	vt[0]=0;
	vt[1]=1;
	for(int i=2,j=1;i<=500;i++){
		vt[i]=vt[i-1]+j;
		if(i%2) j++;
	}
}
void solve(){
	cin>>n;
	cout<<vt[n]<<"\n";
}

部分大佬题解：

对于一个 $p_i=i$ 的排列，我们可以通过不断交换两个位置的数把它变成任意排列。

发现每次交换两个数增加的值是偶数，那么最后和的值只会是偶数。

然后猜测所有偶数都可以拿到。那么求出最大的值看有多少偶数。

最大的值为最后一个排列的差，即 $n,n-1,....,1$ 与 $1,2,...,n$ 的差。

void solve() {
    int n;cin >> n;
    int ans = 0;
    for (int i = 1; i <= n; ++ i) {
    	ans += abs(i - (n - i + 1));
    }
    cout << ans / 2 + 1 << "\n";
}

还有一种写法没看懂：

void solve(){
  int n;cin >> n;
  int res = 0;
  for (int i = 1; i < n; i++)
    res += min(i, n - i);
  cout << res + 1 << '\n';
}

B. SUMdamental Decomposition

题意：构造一个长度为 $n$ 的正整数数组，数组元素全部异或结果为 $x$ ，求这个数组的和最小是多少。

两个数异或为 $0$ 不会对结果造成任何影响，当都取 $1$ 时结果最小。

我们可以看 $x$ 有多少个 $1$，如果 $n$ 大于这个数，就需要将多余的变成 $0$。小于或等于的直接就是 $x$ 。可以采用新学的 bitset 来判断有多少个 $1$ 。

一直错test2的测试点，特判 $m=0$ 和 $m=1$ 过了。

void solve(){
	cin>>n>>m;
	if(n==1&&m==0){
		cout<<"-1\n";
		return;
	}
	if(n==2&&m==1){
		cout<<"5\n";
		return ;
	}
	if(m==0){
		if(n%2==0) cout<<n<<"\n";
		else cout<<5+n-2<<"\n";
		return ;
	}
	if(m==1){
		if(n%2==1) cout<<n<<"\n";
		else cout<<5+n-2<<"\n";
		return ;
	}
	bitset<33> b(m);
	int z=b.count();
	ll sum=0;
	if(n>=z){
		if((n-z)%2==1){
			if(m%2==1){
				sum=m+n-z+1;
			}
			else sum=m+n-z+1;
		}
		else sum=m+n-z;
	}else{
		sum=m;
	}
	cout<<sum<<"\n";
}

部分大佬题解：

不需要 bitset ，直接使用内置函数 __builtin_popcount(x) 返回 $1$ 的个数。

for(int t = rd();t--;){
    int n = rd(),x = rd(),v = __builtin_popcount(x);
    if(n <= v)printf("%d\n",x);
    else if((n-v)%2==0)printf("%d\n",x+n-v);
    else if(x > 1)printf("%d\n",x+n-v+1);
    else if(x == 1)printf("%d\n",n+3);
    else printf("%d\n",n>1?n+3:-1);
}

C. Neo’s Escape

题意：给定一个数组 $a$ ，需要按大小顺序遍历所有元素，可以新建一个克隆人在一个元素前面，也可以让现有的克隆人左右移动，但是移动到某个元素，若该元素为遍历则直接遍历。最小新建克隆人数量是多少？

不要被题目带偏，说是要按大小顺序遍历所有元素，并且克隆人可以左右移动。

本质上这题目就是在统计数组 $a$ 的峰的数量。

int n;cin >> n;
vector<int> a(n);
for (int i=0;i<n;i++) cin >> a[i];
ll ans=1;
bool d=0;
for(int i=1;i<n;i++){
    if(d==0&&a[i-1]>a[i]) d=1;
    else if(d==1&&a[i-1]<a[i]){
        ans++;
        d=0;
    }
}
cout<<ans<<"\n";

D. Needle in a Numstack

题意：交互题。给定 $n$ 和 $k$ ，有两个数组 $A$ 和 $B$ ，有几个条件

两个数组长度之和是 $n$。
两个数组的长度都至少为 $k$。
数组中只包含从 $1 \sim k$ 的数字。
从 $A$ 中任意取出 $k$ 个连续元素，每个元素都是不同的，B也同样。

现在将 $C$ 数组等于数组 $A$ 加上数组 $B$，即 $C=A_1,...,A_x,B_1,...,B_y$。

你可以提出问题询问 $C$ 数组中第 $i$ 个元素的值，请你找出数组 $A$ 和数组 $B$ 的长度，或者无法唯一确定长度。

CF大佬代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
int T,n,k,a[N],b[N];
vector<int> p;
void solve(){
	if(n==2*k){
		cout<<'!'<<' '<<k<<' '<<k<<"\n";
		return;
	}
	if(p.empty()){
		cout<<'!'<<' '<<-1<<"\n";
		return;
	}
	int l=0,r=p.size()-1,res;
	cout<<'?'<<' '<<p[0]<<"\n";
	cin>>res;
	if(res==b[p[0]]){
		if(p[0]==k+1) cout<<'!'<<' '<<k<<' '<<n-k<<"\n";
		else cout<<'!'<<' '<<-1<<"\n";
		return;
	}
	while(l<r){
		int mid=l+r+1>>1;
		cout<<'?'<<' '<<p[mid]<<"\n";
		cin>>res;
		if(res==a[p[mid]]) l=mid;
		else r=mid-1;
	}
	if(r==p.size()-1){
		if(p[r]==n-k) cout<<'!'<<' '<<n-k<<' '<<k<<"\n";
		else cout<<'!'<<' '<<-1<<"\n";
		return;
	}
	if(p[r]+1==p[r+1]) cout<<'!'<<' '<<p[r]<<' '<<n-p[r]<<"\n";
	else cout<<'!'<<' '<<-1<<"\n";
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>T;
	while(T--){
		cin>>n>>k;
		for(int i=1;i<=k;++i) cout<<'?'<<' '<<i<<"\n",cin>>a[i];
		for(int i=n-k+1;i<=n;++i) cout<<'?'<<' '<<i<<"\n",cin>>b[i];
		for(int i=k+1;i<=n;++i) a[i]=a[i-k];
		for(int i=n-k;i;--i) b[i]=b[i+k];
		p.clear(),p.shrink_to_fit();
		for(int i=k+1;i<=n-k;++i) if(a[i]!=b[i]) p.emplace_back(i);
		solve();
	}
	return 0;
}

知乎大佬题解：

特别注意前后的长度都要大于等于 $k$。

询问前 $k$ 个和后 $k$ 个，观察循环节是否相同。

不相同，直接二分找到什么时候不相同的一段

然后直接暴力询问 $k+1$ 长度，判断中间是否有一段即在 $A$ ，也在 $B$.

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
void solve(){
	int n, k;
	cin >> n >> k;
	auto query = [&](int x) -> int {
		cout << "? " << x <<"\n";
		int res;
		cin >> res;
		return res;
	};
	vector<int> pre(k), sf(k);
	for (int i = 1; i <= k; i++) 
		pre[i % k] = query(i);
	for (int i = n - k + 1; i <= n; i++) 
		sf[i % k] = query(i);
	if (pre == sf) {
		if (n == 2 * k) {
			cout << "! " << k << " " << k << "\n";
		} else {
			cout << "! -1" << "\n";
		}
		return;
	}
	int id = -1;
	for (int i = 0; i < k; i++) 
		if (pre[i] != sf[i]) 
			id = i;
	if (id == 0) id = k;
	int c = n / k + ((n % k) >= id ? 1 : 0);
	int l = 1, r = c;
	while (l < r) {
		int mid = l + r >> 1;
		if (query((mid - 1) * k + id) == pre[id % k]) {
			l = mid + 1;
		} else {
			r = mid;
		}
	}
	int lena = 0, lenb = n;
	for (int i = (l - 2) * k + id; i <= (l - 1) * k + id; i++) {
		int res = query(i);
		if (res == pre[i % k] && res != sf[i % k]) {
			lena = i;
		} else if (res != pre[i % k] && res == sf[i % k]) {
			lenb = min(lenb, i);
		}
	}
	lena = max(lena, k);
	lenb = min(lenb, n - k + 1);
	if (lena == lenb - 1)
		cout << "! " << lena << " " << n - lena << "\n";
	else 
		cout << "! -1" << "\n";
}
int main(){
	std::ios::sync_with_stdio(0);
	int t = 1;
	std::cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}

E. Spruce Dispute

题意：有一棵有 $n$ 个顶点的树，其中的 $n-1$ 个顶点上挂着饰品，有 $\frac{n-1}{2}$ 种不同的颜色，每种颜色恰好有两个饰品。

移走树的哪一条边，重新排列饰品，使相同颜色的饰品之间路径长度最大呢？

移走一条边：选择一对相邻顶点 $a$ 和 $b( a<b )$，然后从装饰树中移除顶点 $b$ 并将 $b$ 的所有相邻顶点( $a$ 除外)直接连接到 $a$ 。

知乎大佬题解：

首先观察到，所有的边都被最大的路径数经过时最优。

所有我们希望找到一个根，每棵子树的的大小都小于等于 $n/2$，一定能找到。

然后所有点的贡献都是到他的路径长度加上点子树大小。我们发现这个点一定是叶子节点。

对于把节点分成两部分，且编号相同的不在同一个子树中，使用DFS序。

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
void solve(){
	int n;cin >> n;
	vector<vector<int>> adj(n + 1);
	for (int i = 1; i < n; i++) {
		int u, v;cin >> u >> v;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	vector<int> sz(n + 1, 1), dep(n + 1), p(n + 1), in(n + 1), ord(n + 1);
	int cur = 0;
	auto dfs = [&](auto self, int u, int fa) -> void {
		sz[u] = 1;
		p[u] = fa;
		in[u] = ++cur;
		ord[in[u]] = u;
		for (auto v : adj[u]) {
			if (v == fa) {
				continue;
			}
			dep[v] = dep[u] + 1;
			self(self, v, u);
			sz[u] += sz[v];
		}
	};
	dfs(dfs, 1, 0);
	auto find = [&](auto self, int u) -> int {
		for (auto v : adj[u]) {
			if (v == p[u] || 2 * sz[v] <= n) {
				continue;
			}
			return self(self, v);
		}
		return u;
	};
	int rt = find(find, 1);
	p[rt] =dep[rt] =cur = 0;
	dfs(dfs, rt, 0);
	int x = -1;
	for (int i = 1; i <= n; i++) {
		if (i != rt && adj[i].size() == 1 && (x == -1 || dep[x] > dep[i])) {
			x = i;
		}
	}
	cout << x << " " << p[x] << "\n";
	if (x < p[x]) x = p[x];
	vector<int> ans(n + 1);
	ord.erase(ord.begin() + in[x]);
	for (int i = 1; i <= n / 2; i++) {
		ans[ord[i]] = ans[ord[i + n / 2]] = i;
	}
	for (int i = 1; i <= n; i++) {
		cout << ans[i] << " \n"[i == n];
	}
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0);
	int t = 1;cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}

F. Fallen Towers

题意：有一个长度为 $n$ 的 $a$ 数组。有一种操作是使 $a_i=0$，$a_i$ 后面的元素都 $+1$，如果$a_i$本来就等于0，就不会都 $+1$。

现在按照任意顺序对所有的元素进行操作，即每个 $a_i$ 都会操作一次。

最终得到的 $a$ 数组必须是不递减的。求最终得到的 $a$ 数组中不存在的最小非负整数。

CF大佬代码：

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int N=5e5+10;
int n;
i64 a[N],b[N],c[N],d[N];
bool check(int x){
	for(int j=n;j>=1;j--){
		c[j]=x-1-(n-j);
		c[j]=max(0ll,c[j]);
	}
	for(int i=1;i<=n;i++) b[i]=a[i];
	for(int j=1;j<=n;j++) d[j]=0;
	for(int i=1;i<=n;i++){
		d[i]+=d[i-1];
		if(d[i]<c[i]) return 0;
		if(i==n) return 1;
		i64 val=d[i]-c[i]+b[i];
		if(val==0) continue;
		i64 l=i+1;
		i64 r=min((i64)n,i+val);
		d[l]+=1;
		d[r+1]-=1;
	}
	return 1;
}
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++) b[i]=0;
	for(int i=1;i<=n;i++) cin>>a[i];
	a[n]=0;
	int l=1,r=n+1;
	while(l<r){
		int mid=l+r+1>>1;
		if(check(mid)) l=mid;
		else r=mid-1;
	}
	cout<<r<<"\n";
}
int main() {
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;cin>>t;
	while(t--) solve();
	return 0;
}

2025年5月1号vp天梯赛

2025-05-01T00:00:00+00:00

VP天梯赛

比赛时间3小时。

L1共100分，拿95分；

L2共100分，拿82分；

L3共90分，拿38分；

总共290分，拿199分。

因题目难度原因，部分题目不列举。

L1-6 这不是字符串题

大模拟，不知为啥一个测试点错误一个测试点段错误。

我采用vector只能拿10分，知乎大佬采用string能拿满。

#include <bits/stdc++.h>
using namespace std;
void solve(){
	int n,m;cin>>n>>m;
	string s;
	for(int i=1;i<=n;i++){
		int x;cin>>x;
		s.push_back(char('a'+x-1));
	}
	while(m--){
		int op;cin>>op;
		if(op==1){
			int x;cin>>x;
			int len=x;
			string t;
			while(x--){
				int k;cin>>k;
				t.push_back(char('a'+k-1));
			}
			int x2;cin>>x2;
			int len2=x2;
			string t2;
			while(x2--){
				int k;cin>>k;
				t2.push_back(char('a'+k-1));
			}
			if(s.find(t)==string::npos){
				continue;
			}else{
				s.replace(s.find(t),len,t2);
			}
		}else if(op==2){
			string ne;
			for(int i=0;i<s.length()-1;i++){
				int x1=s[i]-'a'+1,x2=s[i+1]-'a'+1;
				if((x1+x2)%2==0){
					ne.push_back(s[i]);
					ne.push_back(char((x1+x2)/2+'a'-1));
				}else{
					ne.push_back(s[i]);
				}
			}
			ne.push_back(s.back());
			s=ne;
		}else{
			int l,r;cin>>l>>r;
			l--;
			reverse(s.begin()+l,s.begin()+r);
		}
	}
	for(int i=0;i<s.length();i++){
		int x=(s[i]-'a'+1);
		if(i!=s.length()-1) cout<<x<<" ";
		else cout<<x;
	}
}
int main() {
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	while(t--) solve();
	return 0;
}

L1-7 大幂数

从最大幂次开始往下遍历。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
	ll n;
	cin>>n;
	ll x=log2(n);
	for(int i=x;i>=1;i--){
		ll sum=0;
		ll y=1,z=0;
		while(sum<n){
			sum+=pow(y,i);
			y++;
		}
		if(sum==n){
			for(int j=1;j<y;j++){
				cout<<j<<'^'<<i;
				if(j!=y-1) cout<<'+';
			}
			return 0;
		}
	}
	cout<<"Impossible for "<<n<<".";
	return 0;
}

L1-8 现代战争

又是模拟，采用map或数组存储哪些行和列没有，采用优先队列快速按大小取值。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,m,k,xlen,ylen;
struct nod{
	int zhi;
	int x;
	int y;
	friend bool operator <(nod a,nod b){
		return a.zhi<b.zhi;
	}
}a[1001][1001];
map<int,bool> mpx,mpy;
priority_queue<nod> pq;
int main(){
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>a[i][j].zhi;
			a[i][j].x=i;
			a[i][j].y=j;
			pq.push(a[i][j]);
		}
	}
	while(k--){
		nod z=pq.top();pq.pop();
		while(!(mpx[z.x]==0&&mpy[z.y]==0)&&!pq.empty()){
			z=pq.top();pq.pop();
		}
		mpx[z.x]=1,mpy[z.y]=1;
		xlen++,ylen++;
	}
	int xx=0,yy=0;
	for(int i=1;i<=n;i++){
		if(mpx[i]==1) continue;
		yy=0;
		for(int j=1;j<=m;j++){
			if(mpy[j]==1) continue;
			cout<<a[i][j].zhi;
			yy++;
			if(yy!=m-ylen) cout<<" ";
		}
		cout<<"\n";
	}
	return 0;
}

L2-1 算式拆解

典。关于算式运算采用stack可简单快速。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
string s,str;
stack<string> st;
int a,b=1;
int main(){
	cin>>s;
	int i=0;
	str="";
	for(int i=0;i<s.size();i++){
		if(s[i]=='('){
			if(str!=""){
				st.push(str);
				str="";
			}
			a++;
			st.push("(");
		}else if(s[i]!=')'){
			str+=s[i];
		}else{
			if(str!=""){
				st.push(str);
				str="";
			}
			cout<<st.top();
            cout<<"\n";
			b=1;
			st.pop();st.pop();
		}
	}
	return 0;
}

L2-2 三点共线

此题25分赶时间我只拿了16分走人。

知乎大佬题解：

枚举 $y=0$ 和 $y=1$ 时的 $x$，再用 bitset 维护 $y=2$ 时的 $x$ 即可。

和我思路一样，我没去重并且采用unordered_map维护。

const int N = 8e6 + 7;
const int d = 4e6; // 这里把所有点都向右移动4e6即可保证不会出现负数
vector<int> a[2];
bitset<N> pos;
void solve(){
    int n; cin >> n;
    rep(i, 1, n) {
        int x, y; cin >> x >> y;
        if(y < 2) a[y].push_back(x);
        else pos[x + d] = true;
    }
    rep(i, 0, 2) sort(all(a[i]));
    rep(i, 0, 2) a[i].erase(unique(all(a[i])),a[i].end());
    vector<pii> ans;
    for(int &x0 : a[0]) {
        for(int &x1 : a[1]) {
            int x2 = x1 * 2 - x0;
            if(pos[x2 + d]) ans.push_back({x1, x0});
        }
    }
    sort(all(ans));
    if(!ans.empty()) {
        for(auto &[x1, x0] : ans) {
            int x2 = x1 * 2 - x0;
            cout << '[' << x0 << ", 0] [" << x1 << ", 1] [" << x2 << ", 2]\n";
        }
    } else cout << -1;
}

L2-3 胖达的山头

前缀和基础题。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int l,r,l1,r1;
map<int,int> mp;
int sum[100000];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		int a,b,c;
		scanf("%d:%d:%d",&a,&b,&c);
		l=a*60*60+b*60+c;
		scanf("%d:%d:%d",&a,&b,&c);
		r=a*60*60+b*60+c;
		sum[l]++;sum[r+1]--;
	}
	int ans=0;
	for(int i=1;i<=86400;i++){
		sum[i]+=sum[i-1];
		ans=max(sum[i],ans);
	}
	cout<<ans;
	return 0;
}

L2-4 被n整除的n位数

25分拿了16分走人。

知乎大佬题解：

直接暴搜！

~~我还利用性质花费大量时间拿16分，成nt了~~

ll n, a, b;
bool f = true;
void dfs(ll x, int dep) {
	if(dep == n) {
		if(x >= a && x <= b) {
			cout << x << '\n';
			f = false;
		}
		return;
	}
	rep(i, 0, 9) {
		if((x * 10 + i) % (dep + 1)) continue;
		dfs(x * 10 + i, dep + 1);
	}
}
void solve(){
	cin >> n >> a >> b;
	int st = to_string(a)[0] - '0', ed = to_string(b)[0] - '0';
	rep(i, st, ed) dfs(i, 1);
	if(f) cout << "No Solution";
}

L3-1 人生就像一场旅行

时间不够了，想dfs拿点分，但题目都还没读明白。

知乎大佬题解：

点的个数为500，没给边的数量，为完全图时会卡掉 Dijkstra。可以用 Floyd 解决此问题。

先走花费最小的点，如果有多个花费最小的点再选沿途心情指数最高的点。天梯赛以前有道思想一模一样的题。L2-001 紧急救援

好吧，我对于最短路算法全部还给教练了。

const int inf = 1e9; // 防止爆int
const int N = 5e2 + 7;
int d[N][N], h[N][N];
void Solution(){
	int b, n, m, k; cin >> b >> n >> m >> k;
	rep(i, 1, n) rep(j, 1, n) d[i][j] = inf; // Floyd初始化
	rep(i, 1, n) d[i][i] = 0;
	rep(i, 1, m) {
		int x, y, u, v; cin >> x >> y >> u >> v;
		d[y][x] = d[x][y] = min(d[x][y], u); // 处理重边
		h[y][x] = h[x][y] = max(h[x][y], v);
	}
	rep(k, 1, n) rep(i, 1, n) rep(j, 1, n) { // Floyd
		if(d[i][j] == d[i][k] + d[k][j]) {
			h[i][j] = max(h[i][j], h[i][k] + h[k][j]);
		} else if(d[i][j] > d[i][k] + d[k][j]) {
			d[i][j] = d[i][k] + d[k][j];
			h[i][j] = h[i][k] + h[k][j];
		}
	}
	while(k --) {   // 处理询问
		int x; cin >> x;
		vector<int> ans;
		rep(y, 1, n) {
			if(y == x || d[x][y] > b) continue;
			if(ans.size()) cout << ' ';
			cout << y;
			ans.push_back(y);
		}
		if(ans.empty()) {
			cout << "T_T\n";
			continue;
		} else cout << '\n';
		int hmax = 0;
		for(auto &y : ans) hmax = max(hmax, h[x][y]);
		bool f = false;
		for(auto &y : ans) {
			if(h[x][y] != hmax) continue;
			if(f) cout << ' ';
			cout << y;
			f = true;
		}
		cout << '\n';
	}
}

L3-2 影响力

暴力拿了20分，总分30。

知乎大佬题解：

拆成八个方向分别算，

采用递推。$(i,j)$左上方（不含正上正左）的距离和=$(i-1,j-1)$左上方（含正上正左）的距离和+$(i,j)$左上方的方格数量。

似乎也可以说是一个DP。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll cal(int i){
	return (i*(i+1ll)/2);
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int n,m;cin>>n>>m;;
	vector<vector<ll> > pre(n,vector<ll>(m,0));
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			pre[i][j]=cal(i)+cal(j);
			if(i&&j) pre[i][j]+=pre[i-1][j-1]+1ll*i*j;
		}
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			ll x;cin>>x;
			cout << x * (pre[i][j] + pre[n - 1 - i][j] + pre[i][m - 1 - j] + pre[n - 1 - i][m - 1 - j] - cal(j) - cal(m - 1 - j) - cal(i) - cal(n - 1 - i)) << " \n"[j == m - 1];
		}
	}
	return 0;
}

L3-042 污染大亨

没找到AC题解，只有暴力dfs16分。

#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize(2)
#define int long long 
#define double long double
#define _rep(i,a,b) for(int i=(int)(a);i<=(int)b;++i)
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define pp pop_back()
#define fi first
#define se second
typedef pair<int,int> PII;
typedef pair<double,double> PDD;
int n,m,k;
const int N=1e6+10,INF=4e18,P=998244353;
vector<vector<int>>v(N);
int c[N];
int st[N];
int sum;
int qmi(int a,int b,int P){
	int res=1;
	while(b){
		if(b&1)res=res*a%P;
		a=a*a%P;
		b>>=1;
	}
	return res;
}
void infact(int u){
	sum++;
	st[u]++;
	for(auto i:v[u]){
		infact(i);
	}
	return;
}
void finfact(int u){
	st[u]--;
	for(auto i:v[u]){
		finfact(i);
	}
	return;
}
int res=0;
void dfs(int u,vector<int>&ve,int now){
	bool bl=false;
	_rep(i,1,n){
		if(st[i])continue;
		bl=true;
		sum=0;
		infact(i);
		dfs(u+1,ve,now*qmi(c[u],sum,P)%P);
		finfact(i);
	}
	if(!bl)res+=now,res%=P;
}
void solve(){
	cin>>n;
  	_rep(i,2,n){
		int x;
		cin>>x;
		v[x].pb(i);
	}
	_rep(i,1,n)cin>>c[i];
	vector<int>ve;
	dfs(1,ve,1);
	cout<<res;
}
signed main(){
	IOS;
	int T=1;
	while(T--)
		solve();
	return 0;
}

DP入门学习

2025-04-30T00:00:00+00:00

DP学习

DP入门学习

清华大学翁家翌将其分为 $8$ 类，分别为序列DP、区间DP、坐标DP、数轴DP、树型DP、数位DP、状压DP、记忆化搜索。

北京大学yxc将其分为 $10$ 类，分别为背包问题、线性DP、区间DP、计数DP、数位DP、状压DP、树形DP、记忆化搜索、基环树DP、插头DP。

罗勇军老师的《算法竞赛》和洛谷进阶篇将其分为 $4$ 类，分别为数位DP、状压DP、区间DP、树形DP。

除了上述状态类型外，还有优化。

优化基本有单调队列优化、斜率优化、四边形不等式优化。

D. Serval and Kaitenzushi Buffet

xglixzk提供的题目

https://codeforces.com/contest/2085/problem/D

取 $i$ 盘寿司的时间应该不晚于 $(n-i*(k+1)+1)$ 分钟，这个约束限制了可以取寿司的时间。

因此我们会按时间顺序列举 $n$ 分钟，并在达到一个约束条件时，即当前分钟是某 $i$ 的 $(n-i*(k+1)+1)$ 分钟时，贪心拿走之前美味值最大的盘子。

没取盘子的美味都可以通过堆来维护。总复杂度为 $O(nlog n)$ 。

ll ans=0,n,k;
cin>>n>>k;
priority_queue<ll> q;
for(int i=1;i<=n;i++){
    int x;cin>>x;
    q.push(x);
    if((n-i+1)%(k+1)==0){
        ans+=q.top();
        q.pop();
    }
}
cout<<ans<<"\n";

算法	问题	边权要求	时间复杂度
BFS	一个起点到所有点	无边权或为1	\(<O(m+n)\)
Dijkstra(优先队列)	一个起点到所有点	非负数	\(<O((m+n)\log_2n)\)
SPFA	一个起点到所有点	允许有负数	\(<O(mn)\)
Floyd-Warshall	所有点到所有点	允许有负数	\(<O(n^3)\)

TangZiFan's Blog

25年ICPC第一场网络赛题解

主题介绍

Problem A. Who Can Win

Problem B. Creating Chaos

Problem C. Canvas Painting

Problem D. Min-Max Tree

Problem G. Sorting

Problem I. Knapsack Problem

Problem M. Teleporter

不定积分

第四章 不定积分

一、不定积分的概念与性质

基本积分表

不定积分的性质

二、换元定积分法

三、分部积分法

四、有理函数的积分

25年睿抗国赛题解

2025年(RAICOM)睿抗机器人开发者大赛CAIP国赛题解

RC-u1 谁拿冠军了？

RC-u2 理包

RC-u3 删除屏蔽词

RC-u4 穷游

RC-u5 工序优化

第三章 微分中值定理与导数应用

第三章 微分中值定理与导数应用

一、微分中值定理

1.罗尔定理

2.拉格朗日中值定理

3.柯西中值定理

二、洛必达法则

三、泰勒公式

第一个泰勒公式

第二个泰勒公式

四、函数单调性与曲线凹凸性

判断函数单调性

判断凹凸性

五、函数的极值与最值

1.极值

2.最值

六、函数图像描绘

七、曲率

图论学习

图论

1.图的存储

链式前向星

2.拓扑排序

基于BFS的拓扑排序

基于DFS的拓扑排序

3.欧拉路

8.最短路径

Dijkstra(优先队列)

第二章 导数与微分

第二章 导数与微分

一、基本函数求导法则

二、和差积商的求导法则

三、反函数的求导法则

四、复合函数的求导法则（链式法则）

五、高阶导数

六、隐函数和参数方程函数的导数

七、函数的微分

网站logo修改及添加博客图片

图片改进

算法竞赛（高级数据结构）

《算法竞赛》第 4 章 高级数据结构

1. 并查集

并查集的基本操作

带权并查集

例题

2.树状数组

单点修改+区间查询

区间修改+单点查询

区间修改+区间查询

二维区间修改+区间查询

3.线段树

线段树模板

区间最值

区间合并

扫描线

第四章不定积分

第三章微分中值定理与导数应用

第三章微分中值定理与导数应用

第二章导数与微分

第二章导数与微分

《算法竞赛》第 4 章高级数据结构

《算法竞赛》第 5 章动态规划