算法 on 热尘的博客

关于dp状态转移方程的设计4

Sat, 18 Jul 2026 16:50:28 +0800

我们有的时候会发现一个问题，题目给的数据范围或者是某些引导让我们的dp状态设计非常显然，但是可能转移的时候会遇到难以维护或者复杂度不对的情况。

那么我们需要考虑优化，在算法中一种常见的优化是预处理，在某些时候我们可以通过将难以放在方程里维护的数据或者难以找到维护顺序的参数进行预处理，但是记住我们需要去找到使我们这个预处理不会跟随dp方程而改变的性质。

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 100005;
const int M = 205;
int n, m, k, dp[N][M], t[N], s[N];

struct Node {
 int s;
 int t;
 int d;
 int w;
 bool operator <(const Node& other)const {
 if (w != other.w) {
 return w < other.w;
 }
 else return d < other.d;
 }
}a[N];

bool cmp(Node A, Node B) {
 if (A.s != B.s) {
 return A.s < B.s;
 }
 else {
 return A.t < B.t;
 }
}

priority_queue<Node>q;

signed main() {
 cin >> n >> m >> k;
 for (int i = 1;i <= k;i++) {
 cin >> a[i].s >> a[i].t >> a[i].d >> a[i].w;
 }
 sort(a + 1, a + k + 1, cmp);
 int cur = 1;
 t[0] = 1;
 for (int i = 1;i <= n;i++) {
 while (cur <= k && a[cur].s <= i) {
 q.push(a[cur++]);
 }
 if (q.empty()) t[i] = i + 1;
 else {
 Node x = q.top();
 if (x.t < i) {
 i--;
 q.pop();
 continue;
 }
 t[i] = x.d + 1;
 s[i] = x.w;
 }
 }
 memset(dp, 0x3f, sizeof dp);
 dp[0][0] = 0;
 for (int i = 0;i <= n;i++) {
 for (int j = 0;j <= m;j++) {
 dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j]);
 dp[t[i]][j] = min(dp[t[i]][j], dp[i][j] + s[i]);
 }
 }
 int ans = LONG_LONG_MAX;
 for (int i = 0;i <= m;i++) {
 ans = min(ans, dp[n + 1][i]);
 }
 cout << ans << endl;
 return 0;
}

01分数规划学习笔记

Thu, 16 Nov 2023 17:48:00 +0800

起因：P1642 规划

说实话我的印象里是做过这种题的，但是当时好像理解后就跑路了，现在来复习一下。

什么是01分数规划呢?

其实就是让你跑一个01背包，但是物品有三个权值，重量都为1，然后让你求选的物品的剩下两个权值比值最大，也就是性价比。

这种东西在没有选择依赖关系的情况下看起来确实可以贪心，但是这样就没意思了，所以我们来说说有依赖关系怎么求，对于最普通的01分数规划问题来说一般都是二分答案，也就是我们要求的那个最优的性价比。

之后我们根据这个平均性价比，反推出一个物品相对于平均值的贡献，然后就可以大力用各种各样的dp求出当前的最大值了，如果大于0就说明还有优化空间，反之则没有。

要退役了，什么最优比率生成树，什么最优比率环也不打算学，就这样吧。

关于动态规划的转移1

Wed, 01 Nov 2023 13:40:00 +0800

对于一道dp题，它可能让你转移的时候维护两个优先级，那么我们暴力一点，如果不满足两个条件的话就不转移，比如求两个最小值，总会有一个是最优先考虑，那么选的如果超出第一优先级的话就一定是错误的，所以在小于等于第一优先级的时候再去考虑第二优先级。

参考题目：Bottles

P6413 [COCI2008-2009#3] NAJKRACI 题解

Tue, 31 Oct 2023 21:39:00 +0800

之前没有接触过最短路图，退役前正好趁这道题学习一下。

其实最短路图没有多少东西，但是考到的时候就很有用废话。

首先对于一张图来说，以一个点来跑单源最短路的话，那么这个起点到所有点的最短路必定构成一张 $\texttt{DAG}$，那么这就是很优秀的，但是如果我们更极端一点，用奇怪的方式规定（当然也可能直接说）两点间的最短路有且只有一条，那么我们跑出来的就变成了一颗最短路树。

来看这道题，题面非常简介，发现这道题中的边如果不被任何最短路经过的话便是毫无作用的，所以我们跑出最短路图，然后便是用拓扑排序在 $\texttt{DAG}$ 上进行递推计数。

因为题中的数据范围很小，所以我们暴力地枚举起点，以枚举的起点跑单源最短路，然后对跑出来的 $\texttt{DAG}$ 进行答案累加就可以了。

但是要注意一点，我们的 $\texttt{DAG}$ 要进行反拓扑序，因为我们记录的是以某一点为起点的 $\texttt{DAG}$，不反过来跑的话记的数是错的。

然后求哪些边是最短路经过的边的时候其实用上了dp回溯（因为最短路算法本质就是动态规划嘛），我们只需要枚举边，然后判断是否 $dis[v]=dis[x]+e[i].wide$ 就可以了。

然后对于跑最短路因为没有负权边所以我用的是堆优化 $\mathrm{Dijkstra}$。

复杂度分析：$\mathrm{O}(n^2logn+n^2)$ 理论实测均可过。

（因为我也是才学所以代码有所借鉴其他题解）

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1505;
const int mod=1e9+7;
int n,m,head[N],cnt;

struct Edge{
 int to;
 int next;
 int wide;
}e[5005];

void adding(int u,int v,int w){
 e[++cnt].to=v;
 e[cnt].wide=w;
 e[cnt].next=head[u];
 head[u]=cnt;
}

int cnt1[N],cnt2[N],dis[N],vis[N],ans[5005];
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>q;
void dij(int s){
 memset(cnt1,0,sizeof cnt1);
 memset(dis,127,sizeof dis);
 memset(vis,0,sizeof vis);
 dis[s]=0;
 cnt1[s]=1;
 q.push(make_pair(dis[s],s));
 vector<int>dot;
 while(q.size()){
 int x=q.top().second;
 q.pop();
 if(vis[x]) continue;
 vis[x]=1;
 dot.push_back(x);
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 if(dis[v]>dis[x]+e[i].wide){
 dis[v]=dis[x]+e[i].wide;
 cnt1[v]=cnt1[x];
 q.push(make_pair(dis[v],v));
 }else if(dis[x]+e[i].wide==dis[v]){
 cnt1[v]+=cnt1[x];
 }
 }
 }
 reverse(dot.begin(),dot.end());
 for(auto x:dot){
 cnt2[x]=1;
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 if(dis[v]==dis[x]+e[i].wide){
 cnt2[x]=(cnt2[x]+cnt2[v])%mod;
 ans[i]+=1ll*cnt1[x]%mod*cnt2[v]%mod;
 ans[i]%=mod;
 }
 }
 }
}

signed main(){
 scanf("%lld%lld",&n,&m);
 for(int i=1;i<=m;i++){
 int s1,s2,s3;
 scanf("%lld%lld%lld",&s1,&s2,&s3);
 adding(s1,s2,s3);
 }
 for(int i=1;i<=n;i++){
 dij(i);
 }
 for(int i=1;i<=m;i++){
 printf("%lld\n",ans[i]);
 }
 return 0;
}

01BFS学习笔记

Wed, 25 Oct 2023 10:29:00 +0800

本人随机跳题到了一道看起来是最短路的题，但是本人并不想去暴力建图懒，发现如果抽象成一张图的话边权只有 $0$ 或者 $1$，于是去学了个01BFS。

什么是01BFS呢，其实这是一种最短路的优化，我们都知道BFS要用到queue来维护正确性，但是这在找边权不相等的最短路里就很难受，所以我们需要给他规定一个转移顺序。

我们把queue换成deque，如果这条边边权是1的话就放在队尾，否则放在队首，参考dij里priority_queue的证明，这其实就是找到性质手动模拟了一个优先队列，并且我们的复杂度是优秀的 $O(n)$，以为少了一个堆的log，就很优秀。

当然适用范围有点窄，只能在边权为 $0$ 和一种其他正数中使用。

参考题目：P1849 [USACO12MAR] Tractor S

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
int n,sx,sy,a[N][N],t[N][N];
int stx[6]{-1,0,1,0};
int sty[6]{0,-1,0,1};
deque<pair<int,int>>q;
void BFS(){
 q.push_front(make_pair(sx,sy));
 memset(t,-1,sizeof t);
 t[sx][sy]=0;
 while(q.size()){
 int x=q.front().first;
 int y=q.front().second;
 q.pop_front();
 for(int i=0;i<4;i++){
 int tx,ty;
 tx=x+stx[i];
 ty=y+sty[i];
 if(tx<0||tx>=N) continue;
 if(ty<0||ty>=N) continue;
 if(t[tx][ty]!=-1) continue;
 if(a[tx][ty]){
 t[tx][ty]=t[x][y]+1;
 q.push_back(make_pair(tx,ty));
 }else{
 t[tx][ty]=t[x][y];
 q.push_front(make_pair(tx,ty));
 }
 }
 }
}

int main(){
 scanf("%d%d%d",&n,&sx,&sy);
 for(int i=1;i<=n;i++){
 int s1,s2;
 scanf("%d%d",&s1,&s2);
 a[s1][s2]=1;
 }
 BFS();
 printf("%d",t[0][0]);
 return 0;
}

关于需要处理复杂依赖关系的题

Tue, 24 Oct 2023 19:37:00 +0800

多考虑图论转化，比如求解依赖关系中的最小值，第一眼容易开成dp，没思路时不妨想想求解连通性的最值算法，最小生成树。

参考题目：P5994 [PA2014] Kuglarz

关于dp状态转移方程的设计3

Tue, 24 Oct 2023 15:16:00 +0800

对于一些需要优化空间的dp题，单纯地让dp方程每一维表示一个条件的话无法确切表示出一个无后效性的状态，那么我们可以另这个方程加一些限制条件，但是不表示在方程里，比如对于一个线性dp，我们规定 $dp[i][j]$ 为到第 $i$ 位选择 $j$ 个，但是我们另外规定第 $i$ 个必须选，这样在一些题中就可以满足无后效性了。

参考题目：P4182 [USACO18JAN] Lifeguards P

关于拓扑排序的应用

Mon, 23 Oct 2023 21:39:00 +0800

P2017

这道题的让我们对图中的无向边进行定向，那么我们先把无向边断开，相当于拆成若干个有向连通块，然后我们对所有点进行拓扑排序求出它们的拓扑序，然后我们就可以按照拓扑序的大小关系对无向边进行定向，证明明天再补。

很好我来补证明了。

因为有多个连通块，所以先考虑一个连通块，我们发现对于一个连通块内的点来说，点的拓扑序大小关系一定是严格与单独在这个连通块内拓扑排序的拓扑序相同，那么如果按照之前说的那样对无向边进行定向的话，因为序号小的一定只能指向序号大的，假设给你一堆有序号的点，规定只能从序号小的点向序号大的点连边，那么我们发现这样无论怎么连它都是一张DAG，此题同理。

字符串读入踩坑1

Fri, 20 Oct 2023 10:31:00 +0800

对于有些题目来说我们读入字符串如果不想一个一个读入判断的话我们就一定要使用 getline() 函数，但是我们要注意一点是如果在要读入的字符串前面读入过其他形式的数据，那么这个函数会把上一行剩下来的换行符当做一行来读入，那么我们便会少读入一行字符串，所以我们要在读入字符串前调用一次 getline() 函数，这样就可以覆盖掉上一行的换行符。

参考题目：P1767 家族

搜索踩坑1

Thu, 19 Oct 2023 21:30:00 +0800

有些搜索最短路程的长度的题目，我们如果直接返回第一个搜索到的答案很可能是错的，因为有些路程计算方式和我们的BFS步数并不成正比，但是我们知道路程长度随BFS步数有单调性，那么我们便需要在搜索的时候扩展一点范围，比如在大于当前最小答案后再将这个点ban掉，这样就会保证正确性。

参考题目：P7663 [COCI2014-2015#5] JABUKE

关于dp状态转移方程的设计2

Wed, 18 Oct 2023 09:06:00 +0800

对于一些状态转移方程较好写的dp题，但是复杂度很难看，并且很难在数学方面上进行优化的dp题，我们可以考虑重构状态转移方程，比如要dp双线程操作的话，我们可以把一个线程写在方程里，另一个记录在数组的值里，这样就可以把看似暴力的方程优化成一个最普通的背包，相当于抽象了背包dp的重量和价值，这样的方程看起来有一种偏重关系，而且这样写兴许还可以处理两个线程的优先级，但是我还没见到过这样的题。

参考题目：P2224 [HNOI2001] 产品加工

关于dp状态转移方程的设计1

Tue, 17 Oct 2023 13:54:00 +0800

对于一些按照题意模拟设计 $dp$ 毫无思路的情况下，考虑正难则反，比如让你从一个字符串中删去不合法的字符，这样看起来只有暴力，但是反过来思考成我们在这个字符串中按顺序选择若干个字符使其组成的字符串合法且代价最小，那么这样就很容易设计状态转移方程了。

参考题目：P2187 小Z的笔记

P9705 「TFOI R1」Unknown Graph 题解

Mon, 16 Oct 2023 16:40:00 +0800

一道有趣简单的构造题。

阅读题面，发现这似乎很难找到完美的贪心策略，那么我们考虑网络流。

先说建模方式：

考虑拆点，把每个点拆成编号为 $i$ 和 $n+i$ 的两个点。

首先从超级源点 $s$ 向编号为 $1 \sim n$ 的每一个点连流量为这个点出度的边。

然后再从 $1 \sim n$ 的点向每一个编号为 $n+1$ 到 $2n$ 流量为 $1$ 的边，当然因为题中给出了 $m$ 条限制，那么不对这些限制的点进行连边就好了。

最后从编号为 $n+1$ 到 $2n$ 的点向超级汇点 $t$ 连一条流量为这个点入度的边就好了。

大概建了个这么个图：

那么边数就是这个网络的最大流（因为保证有解），至于怎么输出构造的边，我们去遍历这个网络的残余流量，如果第二步建的正向边的流量为 $0$ 那么就说明这条边被我们选择了，我们输出这条边的两个节点就好。

然后因为这是个二分图，那么我们的复杂度就是优秀的 $O(n\sqrt n)$。

这道题其实就是直接对着题意进行网络流模拟，是一道很好的板子题。

如果还没理解就看看代码，自认为很好看（

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
const int inf=1e9+7;
int n,m,in[N],out[N],head[2*N],cnt=1,s,t,mp[N][N],num=1;
struct Edge{
 int from;
 int to;
 int next;
 int wide;
}e[2*N*N+2*N];

void adding(int u,int v,int w){
 e[++cnt].to=v;
 e[cnt].from=u;
 e[cnt].wide=w;
 e[cnt].next=head[u];
 head[u]=cnt;
}

int dis[2*N],now[2*N];

bool BFS(){
 for(int i=1;i<=2*n+1;i++){
 dis[i]=inf;
 }
 dis[s]=0;
 queue<int>q;
 q.push(s);
 now[s]=head[s];
 while(q.size()){
 int x=q.front();
 q.pop();
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 // cout<<x<<" "<<v<<endl;
 if(dis[v]==inf&&e[i].wide){
 dis[v]=dis[x]+1;
 now[v]=head[v];
 q.push(v);
 }
 }
 }
 return dis[t]!=inf;
}

int DFS(int x,int sum){
 if(x==t) return sum;
 int k,res=0;
 for(int i=now[x];i&∑i=e[i].next){
 int v=e[i].to;
 now[x]=i;
 if(dis[v]==dis[x]+1&&e[i].wide){
 k=DFS(v,min(e[i].wide,sum));
 if(k==0){
 dis[v]=inf;
 }
 e[i].wide-=k;
 e[i^1].wide+=k;
 sum-=k;
 res+=k;
 }
 }
 return res;
}

int Dinic(){
 int res=0;
 while(BFS()){
 res+=DFS(s,inf);
 }
 return res;
}

void Debug(){
 for(int x=0;x<=2*n+1;x++){
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 cout<<x<<" "<<v<<" "<<e[i].wide<<endl;
 }
 }
}

int main(){
 scanf("%d",&n);
 for(int i=1;i<=n;i++){
 scanf("%d",&in[i]);
 }
 for(int i=1;i<=n;i++){
 scanf("%d",&out[i]);
 }
 scanf("%d",&m);
 for(int i=1;i<=m;i++){
 int s1,s2;
 scanf("%d%d",&s1,&s2);
 mp[s1][s2]=1;
 }
 s=0,t=2*n+1;
 for(int i=1;i<=n;i++){
 for(int j=1;j<=n;j++){
 if(i==j) continue;
 if(mp[i][j]) continue;
 adding(i,j+n,1);
 adding(j+n,i,0);
 num+=2;
 }
 }
 for(int i=1;i<=n;i++){
 adding(s,i,out[i]);
 adding(i,s,0);
 }
 for(int i=n+1;i<=2*n;i++){
 adding(i,t,in[i-n]);
 adding(t,i,0);
 }
 Debug();
 printf("%d\n",Dinic());
 for(int i=2;i<=num;i+=2){
 if(!e[i].wide){
 printf("%d %d\n",e[i].from,e[i].to-n);
 }
 }
 return 0;
}

P5032 经验题解

Mon, 25 Sep 2023 15:36:00 +0800

同机房同学找到的题，一看 $\mathrm{tag}$，什么？队列？不会怎么办？

小问题，因为我会暴力。

首先，好长的题面，直接看简要题意，可以发现我们只需要求出最大能合成到多少等级，因为数学知识薄弱，打开 $\mathrm{python}$，发现

既然只有 $23$ 那么我们便可以直接开一个数组（桶）来记录每个等级的附魔书出现了多少次，然后从下往上扫，便可以 $\mathrm{O}(n)$ 地求出最高能合成多大等级的附魔书。

那么下一步我们就要计算它的最小合成费用，因为合成继承的费用是两者之间的 $\mathrm{max}$ 加一，那么一个明显的贪心策略便是每次合成取两个当前费用最大的，其实这样暴力维护的话有点麻烦，但是根据递归的优先选择性其实根本不用特意维护。

long long cal(int dep){
 if(a[dep]){
 a[dep]--;
 return 1;
 }
 int s1=cal(dep-1);
 int s2=cal(dep-1);
 y+=s1+s2;
 return (max(s1,s2)<<1)+1;
}

因为如果这样写的话，对于一个等级的附魔书来说一定是按照从小到大的顺序进行合并，而且因为一定是用偶数个进行合成，所以这依旧是满足我们的贪心策略的。

最后因为不保证模数为质数求逆元还要用扩展欧几里德~~说实话我觉得这很没必要~~

最后进行整体算法复杂度分析，考虑递归形成了一个满二叉树的最坏情况，叶子节点数便是 $\mathrm{n}$，那么根据树的基本知识这颗满二叉树的总节点数依旧是 $\mathrm{n}$ 量级的，所以总体算法复杂度 $\mathrm{O}(n)$。

#include<bits/stdc++.h>
using namespace std;
inline void read(int &x){
 char ch=getchar();x=0;
 while(!isdigit(ch)) ch=getchar();
 while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
}
const int N=10000007;
int n,a[N],maxn,x;
long long y;

long long cal(int dep){
 if(a[dep]){
 a[dep]--;
 return 1;
 }
 int s1=cal(dep-1);
 int s2=cal(dep-1);
 y+=s1+s2;
 return (max(s1,s2)<<1)+1;
}

int ex_gcd(int s1,int s2,int &s3,int &s4){
 if(s2==0){
 s3=1;
 s4=0;
 return s1;
 }
 int temp=ex_gcd(s2,s1%s2,s4,s3);
 s4-=s3*(s1/s2);
 return temp; 
}

int main(){
 read(n);
 for(int i=1;i<=n;i++){
 int temp;
 read(temp);
 maxn=max(temp,maxn);
 a[temp]++;
 }
 int ans,temp=0,judge;
 for(int i=1;i<=maxn||temp;i++){
 temp=a[i]+temp>>1;
 x=max(x,i);
 }
 cal(x);
 judge=ex_gcd(x,y,ans,temp);
 if(judge!=1) return printf("-1"),0;
 else return printf("%lld",(ans%y+y)%y),0;
}

P4645 [COCI2006-2007#3] BICIKLI 题解

Tue, 08 Aug 2023 20:34:00 +0800

一道很好的图论练手题。

难得题意很简洁，就是让你进行一个路径计数，看到这么简洁的路径计数我第一眼想到的就是通过拓扑排序进行计数 $\texttt{dp}$，并且题中说明了是单向道路，那么这就是一个很简单的 $\texttt{DAG}$ 上 $\texttt{dp}$。

但是仍然有一些地方需要注意，因为题中并没有保证这张图是一张有向无环图，所以我们要去判断有环的情况，我们跑一遍 $\texttt{Tarjan}$ 算法便可以找出这个图中所有的环，但是题中的所需要的特判当且仅当路径数为无穷时，所以我们要找的是图中对从 $\texttt{1}$ 号节点到 $\texttt{2}$ 号节点路径数有贡献的环。

至于如何判断这个环是否对路径数有贡献，这个环对路径数有贡献当且仅当可以从 $\texttt{1}$ 号节点走到这个环上并且可以从这个环走到 $\texttt{2}$ 号节点上。

想要知道能否从 $\texttt{1}$ 号节点到环很简单，搜一遍就好了，但是能否从环到达 $\texttt{2}$ 号节点就是另一个问题了，正所谓正难则反，我们另外建出一份反图从 $\texttt{2}$ 号节点跑一遍和刚才一样的就好了，这也是图论题中常用的技巧。

另外一个注意事项，拓扑排序中我们需要根据下一个的入度来判断是否可以入队，但是有些点和边是根本遍历不到的，那么就会走到半路就寄了，所以我们要在判断是否能从 $\texttt{1}$ 号节点到环的时候顺便记录一下有用的入度，当然记得要用 $\texttt{BFS}$ 不然会多加出一些入度。

时间复杂度:$\mathrm{O}(n)$。

（注：本题诈骗数据，记得开 $10^5$）

code

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=100004;
const int mod=1e9;
int n,m,head[N],cnt,in[N],dis[N],head1[N],cnt1;

struct Edge{
	int to;
	int next;
}e[N],e1[N];

void adding(int u,int v){
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}

void adding1(int u,int v){
	e1[++cnt1].to=v;
	e1[cnt1].next=head1[u];
	head1[u]=cnt1;
}

int dfn[N],low[N],tot,vis[N],num,size[N],color[N];
bool check[N],check1[N];
stack<int> s;
void Tarjan(int x){//Tarjan板子不多说了 
	dfn[x]=low[x]=++tot;
	s.push(x);
	vis[x]=1;
	for(int i=head[x];i;i=e[i].next){
		int v=e[i].to;
		if(!dfn[v]){
			Tarjan(v);
			low[x]=min(low[x],low[v]);
		}else if(vis[v]){
			low[x]=min(low[x],low[v]);
		}
	}
	if(dfn[x]==low[x]){
		num++;
		while(s.top()!=x){
			int temp=s.top();
			s.pop();
			vis[temp]=0;
			size[num]++;
			color[temp]=num;
		}
		vis[x]=0;
		size[num]++;
		color[x]=num;
		s.pop();
	}
}

queue<int>q;
void BFS1(int x){
	q.push(1);
	check[1]=1;
	while(q.size()){
		int x=q.front();
		q.pop();
		for(int i=head[x];i;i=e[i].next){
			int v=e[i].to;
			if(!check[v]){
				check[v]=1;
				q.push(v);
			}
			in[v]++;//记录入度 
		}
	}
}

void DFS1(int x){
	for(int i=head1[x];i;i=e1[i].next){
		int v=e1[i].to;
		if(check1[v]) continue;
		check1[v]=1;
		DFS1(v);
	}
}

void tuopu(){
	dis[1]=1;
	q.push(1);
	while(q.size()){
		int x=q.front();
		q.pop();
		for(int i=head[x];i;i=e[i].next){
			int v=e[i].to;
			if(check1[v]){
				dis[v]+=dis[x];
				dis[v]%=mod;
				in[v]--;
				if(in[v]==0){//入度为零才能加 
					q.push(v);
				}
			}
		}
	}
}

signed main(){
	scanf("%lld%lld",&n,&m);
	for(int i=1;i<=m;i++){
		int s1,s2;
		scanf("%lld%lld",&s1,&s2);
		adding(s1,s2);
		adding1(s2,s1);//建反图 
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i]) Tarjan(i);
	}
	check[1]=1;//记录正图的点能否被遍历到 
	check1[2]=1;//同上记录反图 
	BFS1(1);//第一遍要用BFS 
	DFS1(2);
	for(int i=1;i<=n;i++){
		if(check[i]&&size[color[i]]!=1&&check1[i]){
			printf("inf\n");
			return 0;
		}
	}
	tuopu();
	printf("%lld",dis[2]);
	return 0;
}

P3112 [USACO14DEC] Guard Mark G 题解

Fri, 30 Jun 2023 10:48:00 +0800

有一说一这道题和国王游戏很像，但是多了一个高度的维度，当然起先我只认为用这个判断是否合法然后取最优解就好了，然后写了一发~~爆切57 pts~~。

#include<bits/stdc++.h>
using namespace std;
const int N=25;
int n,h,cnt,t[N],ans=INT_MAX;
struct Cow{
 int height;
 int weight;
 int strength;
}e[N];

bool cmp(Cow A,Cow B){
 if(B.strength-A.weight!=A.strength-B.weight){
 return A.strength-B.weight>B.strength-A.weight;
 }else{
 return A.height>B.height;
 }
}

int main(){
 scanf("%d%d",&n,&h);
 for(int i=1;i<=n;i++){
 scanf("%d%d%d",&e[i].height,&e[i].weight,&e[i].strength);
 }
 sort(e+1,e+n+1,cmp);
 int sum=0;
 for(int i=1;i<=n;i++){
 t[i]=t[i-1]+e[i].weight;
 sum+=e[i].height;
 if(sum>=h){
 cnt=i;
 break;
 }
 }
 for(int i=1;i<=cnt;i++){
 ans=min(ans,e[i].strength-(t[cnt]-t[i]));
 }
 if(!cnt||ans<0){
 printf("Mark is too tall\n");
 }else{
 printf("%d",ans);
 }
 return 0;
}

那么问题出现在哪呢？注意到对于这道题这个贪心策略是不全面的，有的时候我们可以在排序后的奶牛中间移除一些没有那么优秀的，而且注意到 $n$ 的范围非常小，那么我们便可以使用状态压缩和搜索两种方式枚举使用哪些奶牛，这样就变成了一个完美的贪心策略。

而对于排序方式来说，我们注意到只考虑两个奶牛的话，两个相邻的奶牛位置的交换是对于其他奶牛来说没有任何影响，那么只需要按照两个奶牛的体重和承受能力的差值进行排序就好了。

复杂度：$\mathrm{O}(2^nn)$。

这里给出我的搜索代码。

#include<bits/stdc++.h>
using namespace std;
const int N=25;
int n,h,ans=-INT_MAX,a[N],t[N];
struct Cow{
 int height;
 int weight;
 int strength;
}e[N],s[N];

bool cmp(Cow A,Cow B){
 if(B.strength-A.weight!=A.strength-B.weight){//贪心策略排序
 return A.strength-B.weight>B.strength-A.weight;
 }else{
 return A.height>B.height;
 }
}

int cal(){
 int temp=INT_MAX;
 int cnt=0;
 t[0]=0;
 for(int i=1;i<=n;i++){
 if(a[i]){
 s[++cnt]=e[i];//提取出选中的奶牛
 }
 }
 sort(s+1,s+1+cnt,cmp);//排序
 int sum=0;
 for(int i=1;i<=cnt;i++){
 sum+=s[i].height;
 t[i]=t[i-1]+s[i].weight;//前缀和节省复杂度
 }
 if(sum<h){//特判
 return -INT_MAX;
 }
 for(int i=1;i<=cnt;i++){
 temp=min(temp,s[i].strength-(t[cnt]-t[i]));//记录答案，这种情况的答案便是对于每一头奶牛的剩余承受重量取最小值
 }
 return temp;
}

void DFS(int dep,int now){
 a[dep]=now;
 if(dep==n){
 ans=max(ans,cal());
 return;
 }
 DFS(dep+1,1);
 DFS(dep+1,0);
 return;
}

int main(){
 scanf("%d%d",&n,&h);
 for(int i=1;i<=n;i++){
 scanf("%d%d%d",&e[i].height,&e[i].weight,&e[i].strength);
 }
 DFS(1,1);//搜索
 DFS(1,0);
 if(ans<0){//小于0说明根本搭不了 
 printf("Mark is too tall\n");
 }else{
 printf("%d",ans);
 }
 return 0;
}

P2530 [SHOI2001] 化工厂装箱员题解

Fri, 30 Jun 2023 07:56:00 +0800

首先我第一眼看到这道题时以为这是一道贪心，贪心策略是对于每一次手里的 $10$ 个货物都优先放下个数最多的。当然这后来想一想便是错误的，因为如果假如手里有 $6$ 个 $A$，但是手里有 $4$ 个 $B$，而且 $6$ 个是一个 $A$，$5$ 个 $C$，那么这个贪心策略很明显就不满足最优解了。

所以考虑 $dp$，一开始我是想开四维数组，一维用来记录 $dp$ 到第几个了，另外三维用来记录所有没拿出去的 $A,B,C$ 的个数，但是后来发现这样需要维护的东西太多，那么经过观察范围发现我的数组设计应该是没有问题的，那么就改变一下状态设计，对于转移来说，最优秀的便是把后面三个维度转换成现在手里所持有的三个物品的个数，这样数组提供的信息就足够维持我们的 $dp$ 转移了，如何转移写在代码注释里了。

复杂度：$\mathrm{O}(1000n)=O(n^2\sqrt[]{n})$

code:

#include<bits/stdc++.h>
using namespace std;
const int N=105;
int n,a[N],dp[N][11][11][11];
string s;

int main(){
 scanf("%d",&n);
 for(int i=1;i<=n;i++){//使用字符串防止玄学出锅
 cin>>s;
 a[i]=s[0]-'A'+1;
 }
 memset(dp,0x3f,sizeof dp);//因为要取最小值所以dp数组初始化极大值
 dp[0][0][0][0]=0;//dp起点设置
 for(int T=1;T<=n;T++){
 for(int i=0;i<=10;i++){
 for(int j=0;j<=10;j++){
 for(int k=0;k<=10;k++){
 if(i+j+k>10) continue;//如果三个相加超过10的话这个状态不合法
 if(a[T]==1&&i!=0){//以下三个if分别表示对于a[T]的每一种情况只拿进来却不放下
 dp[T][i][j][k]=min(dp[T][i][j][k],dp[T-1][i-1][j][k]);
 }
 if(a[T]==2&&j!=0){
 dp[T][i][j][k]=min(dp[T][i][j][k],dp[T-1][i][j-1][k]);
 }
 if(a[T]==3&&k!=0){
 dp[T][i][j][k]=min(dp[T][i][j][k],dp[T-1][i][j][k-1]);
 }
 dp[T][0][j][k]=min(dp[T][0][j][k],dp[T][i][j][k]+1);//以下三行对应的是这一次拿出每一种的可能
 dp[T][i][0][k]=min(dp[T][i][0][k],dp[T][i][j][k]+1);
 dp[T][i][j][0]=min(dp[T][i][j][0],dp[T][i][j][k]+1);
 }
 } 
 }
 }
 printf("%d",dp[n][0][0][0]);//因为最后手里什么都不剩，所以输出全为0的状态
 return 0;
}

P4209 学习小组题解

Sat, 17 Jun 2023 15:39:00 +0800

$\mathrm{tag}$：网络流，费用流

我第一眼看到这道题的平方建边的时候我还以为需要一些数学方面的优化，但是同机房大佬瞅了一眼跟我说暴力建边能过，我心里一群草泥马奔腾而过。。。

这题的基本建模其实就是按照题意模拟：

$1.$ 从超级源点向每一位同学连一条流量为 $\mathrm{k}$，费用为 $0$ 的边。

$2.$ 从每个同学向愿意参加的社团连一条容量为 $1$，费用为手续费的相反数，因为交的手续费算收益（~~赚翻了~~）。

$3.$ 最后便是刚才说的暴力建边，根据公式从每个社团向汇点连 $n$ 条边，每一条边的容量为 $1$,费用为——$C_i \times (2 \times Num-1)$，$Num$ 表示第几条边。

但是我们注意到题目要求的最大流量是参加的人数尽量多而不是学习小组的人数之和，那么我们这里用一个贪心的思想，再从每个同学向汇点连一条容量为 $k-1$，费用为 $0$ 的边，因为我们只要保证这个同学参加了任意一个学习小组就够了。

如果财务处能赚到钱就让学生去参加，赚不到直接让这个学生走费用为 $0$ 的边就好了（~~真黑啊~~）。

复杂度分析：Dinic 复杂度，是肯定能过的啦。

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9+7;
const int N=10005;
int n,m,sum,a[N],b[N],head[N],cnt=1,s,t,ans;

struct Edge{
 int to;
 int next;
 int wide;
 int val;
}e[N*N];

void adding(int u,int v,int w,int val){
 e[++cnt].to=v;
 e[cnt].val=val;
 e[cnt].wide=w;
 e[cnt].next=head[u];
 head[u]=cnt;
}
int dis[N],vis[N];
int now[N];
bool SPFA(){
 for(int i=1;i<=t;i++){
 dis[i]=inf;
 }
 dis[s]=0;
 queue<int>q;
 q.push(s);
 vis[s]=1;
 now[s]=head[s];
 while(q.size()){
 int x=q.front();
 q.pop();
 vis[x]=0;
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 if(e[i].wide&&dis[v]>dis[x]+e[i].val){
 now[v]=head[v];
 dis[v]=dis[x]+e[i].val;
 if(!vis[v]){
 q.push(v);
 vis[v]=1;
 }
 }
 }
 }
 return dis[t]!=inf;
} 

int DFS(int x,int sum){
 if(x==t) return ans+=dis[t]*sum,sum;
 int k,res=0;
 vis[x]=1;
 for(int i=now[x];i&∑i=e[i].next){
 int v=e[i].to;
 now[x]=i;
 if(e[i].wide&&(dis[v]==dis[x]+e[i].val)&&!vis[v]){
 k=DFS(v,min(sum,e[i].wide));
 if(k==0){
 dis[v]=inf;
 }
 e[i].wide-=k;
 e[i^1].wide+=k;
 sum-=k;
 res+=k;
 }
 }
 vis[x]=0;
 return res;
}

void Dinic(){
 while(SPFA()){
 DFS(s,inf);
 }
}

int main(){
 scanf("%d%d%d",&n,&m,&sum);
 t=n+m+1;
 for(int i=1;i<=m;i++){
 scanf("%d",&a[i]);
 }
 for(int i=1;i<=m;i++){
 scanf("%d",&b[i]);
 }
 for(int i=1;i<=n;i++){//第一步
 adding(s,i,sum,0);
 adding(i,s,0,0);
 }
 char c;
 for(int i=1;i<=n;i++){//第二步
 for(int j=1;j<=m;j++){
 c=getchar();
 if(c!='1'&&c!='0'){//防止字符串出锅
 j--;
 continue;
 }
 if(c=='1'){
 adding(i,j+n,1,-b[j]);
 adding(j+n,i,0,b[j]);
 }
 }
 }
 for(int i=1;i<=m;i++){//暴力第三步
 for(int j=1;j<=n;j++){
 adding(i+n,t,1,a[i]*(2*j-1));
 adding(t,i+n,0,-a[i]*(2*j-1));
 }
 }
 for(int i=1;i<=n;i++){//贪心优化
 adding(i,t,sum-1,0);
 adding(t,i,0,0);
 }
 Dinic();
 printf("%d",ans);
 return 0;
}

SP688 SAM - Toy Cars题解

Mon, 12 Jun 2023 14:10:00 +0800

双倍经验P3419

其实我第一眼看到这道题的时候以为是一道 $\texttt{DP}$，但是想了想就发现要记录的状态实在太多，于是就去想贪心。

考虑每次拿玩具对总体的贡献，因为能同时放在地上的玩具个数有限，而我们又只计算拿玩具下来的次数，于是便可得出一个贪心结论，那便是对于把玩具放回去这个行为，下一次玩这个玩具的时间距离现在越远一定越优，因为我们不能不玩任何一个玩具。

所以我们在把玩的顺序读入后，倒序枚举预处理出这个玩具下一次玩的时间，那么至于如何选择，只需要用一个优先队列维护即可，因为要存两维，一个是用来排序的 $\texttt{next}$ 数组，一个是这个玩具的 $\texttt{id}$，所以我们用优先队列存一个 $\texttt{pair}$ 类即可。

复杂度为跑不满的 $\mathrm{O}(nlogn)$。

另外温馨提示，多测不清空，爆零两行泪。

#include<bits/stdc++.h>
using namespace std;
const int N=500005;
int n,k,p,a[N],nex[N],temp[N],ans,vis[N],tot;

priority_queue<int,vector<pair<int,int>>>q;
//也可以这样写
// priority_queue<pair<int,int>>q;
void init(){//预处理函数
 while(!q.empty()){
 q.pop();
 }
 memset(temp,0,sizeof temp);
 memset(nex,0,sizeof nex);
 memset(vis,0,sizeof vis);
 ans=0;
}

int main(){
 int T;
 scanf("%d",&T);
 for(int l=1;l<=T;l++){
 scanf("%d%d%d",&n,&k,&p);
 for(int i=1;i<=p;i++){
 scanf("%d",&a[i]);
 }
 for(int i=p;i>=1;i--){//预处理出nex数组
 if(temp[a[i]]==0) nex[i]=1e6;
 else nex[i]=temp[a[i]];
 temp[a[i]]=i;
 }
 for(int i=1;i<=p;i++){
 if(!vis[a[i]]){
 if(q.size()==k){
 vis[q.top().second]=0;
 q.pop();
 }
 q.push(make_pair(nex[i],a[i]));
 ans++;
 vis[a[i]]=1;
 }else{//因为有新的进入队列更新，而优先队列不好维护弹出，所以把范围开大一个，防止错误弹出
 k++;
 q.push(make_pair(nex[i],a[i]));
 }
 }
 printf("%d\n",ans);
 init();
 }
 return 0;
}

P3005 [USACO10DEC]The Trough Game S题解

Tue, 30 May 2023 13:28:00 +0800

首先看到这道题的数据范围就可以想到是枚举暴力。

而对于枚举我们有两种方法，一种是 $\texttt{DFS}$，而另一种是通过二进制来进行枚举（~~反正我用的 $\texttt{DFS}$~~）。

而这题有两种情况的翻译并没有给出，一种是无解输出 $\texttt{IMPOSSIBLE}$，另一种是解法不唯一输出 $\texttt{NOT UNIQUE}$。

而对于 $\texttt{IMPOSSIBLE}$ 我们只需要判断 $\texttt{DFS}$ 后是否找到了一种解就好了。

对于 $\texttt{NOT UNIQUE}$ 情况我们也只需要在判断是否找到了不唯一的合法解就可以了。

复杂度 $\mathrm{O}(2^{n}m)$，不完全估计 $\mathrm{O}(104857600)$，$\texttt{1s}$ 肯定是能过的啦。

code

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

int n,m,t[25],ans[25];
bool flag=false,judge;
struct Query{
 int a[25];
 int num;
}q[105];

bool check(){//判断解是否合法的函数
 for(int i=1;i<=m;i++){
 int temp=0;
 for(int j=1;j<=n;j++){
 if(q[i].a[j]&&t[j]){
 temp++;//记录搜到的结果的有草料的个数
 }
 }
 if(temp!=q[i].num){//不符合条件直接返回
 return false;
 }
 }
 for(int i=1;i<=n;i++){
 ans[i]=t[i];
 }
 if(flag==true){//是否有过合法解
 judge=true;
 }
 return true;
}

void DFS(int dep){
 if(dep==n){//搜完n个就检查是否合法
 if(check()){
 flag=true;
 }
 return;
 }
 t[dep+1]=1;//枚举每一种情况
 DFS(dep+1);
 // if(flag) return;
 t[dep+1]=0;
 DFS(dep+1);
 // if(flag) return;
}

int main(){
 scanf("%d%d",&n,&m);
 for(int i=1;i<=m;i++){
 for(int j=1;j<=n;j++){
 char s;
 cin>>s;
 if(s==' '||s=='\n'){//防止玄学字符串出锅
 j--;
 continue;
 }
 q[i].a[j]=s-'0';
 }
 scanf("%d",&q[i].num);
 }
 //搜索
 t[1]=1;
 DFS(1);
 t[1]=0;
 DFS(1);
 if(!flag){
 printf("IMPOSSIBLE");
 return 0;
 }
 if(judge){
 printf("NOT UNIQUE");
 return 0;
 }
 for(int i=1;i<=n;i++){
 printf("%d",ans[i]);
 }
 return 0;
}

P1653 [USACO04DEC] Cow Ski Area G

Thu, 11 May 2023 21:01:00 +0800

题解

一句话：输出缩点后的出度为 $0$ 的点的个数和入度为 $0$ 的点的个数的最大值

首先对这个矩阵进行建模，如果能滑到就建一条单向边。

for(int i=1;i<=n;i++){
 for(int j=1;j<=m;j++){
 if(i>1&&a[i-1][j]<=a[i][j]){
 adding(cal(i,j),cal(i-1,j));
 }
 if(i<n&&a[i+1][j]<=a[i][j]){
 adding(cal(i,j),cal(i+1,j));
 }
 if(j>1&&a[i][j-1]<=a[i][j]){
 adding(cal(i,j),cal(i,j-1));
 }
 if(j<m&&a[i][j+1]<=a[i][j]){
 adding(cal(i,j),cal(i,j+1));
 }
 }
 }

然后使用 Tarjan 进行缩点，最后记录缩点后的入度和出度就可以了，答案就是出度为 $0$ 的强连通分量的个数和入度为 $0$ 的强连通分量的个数取 $\max$，最后不要忘了特判一下如果只有一个强连通分量的话就不需要建立任何一道缆车。

code

#include<bits/stdc++.h>
using namespace std;
const int N=250005;
int n,m,head[N],cnt,a[505][505];

struct Edge{
 int to;
 int next;
}e[4*N];

void adding(int u,int v){
 e[++cnt].to=v;
 e[cnt].next=head[u];
 head[u]=cnt;
}

int cal(int i,int j){
 return (i-1)*m+j;
}
int dfn[N],low[N],id,vis[N],is[N],tot;
stack<int> s;
void Tarjan(int x){//缩点
 dfn[x]=low[x]=++id;
 s.push(x);
 vis[x]=1;
 for(int i=head[x];i;i=e[i].next){
 int v=e[i].to;
 if(!dfn[v]){
 Tarjan(v);
 low[x]=min(low[v],low[x]);
 }else if(vis[v]){
 low[x]=min(low[x],dfn[v]);
 }
 }
 if(dfn[x]==low[x]){
 ++tot;
 while(s.top()!=x){
 int temp=s.top();
 s.pop();
 is[temp]=tot;
 vis[temp]=0;
 }
 int temp=s.top();
 s.pop();
 is[temp]=tot;
 vis[temp]=0;
 }
}
int in[N],out[N],tt1,tt2;
int main(){
 scanf("%d%d",&m,&n);
 for(int i=1;i<=n;i++){
 for(int j=1;j<=m;j++){
 scanf("%d",&a[i][j]);
 }
 }
 for(int i=1;i<=n;i++){//建边
 for(int j=1;j<=m;j++){
 if(i>1&&a[i-1][j]<=a[i][j]){
 adding(cal(i,j),cal(i-1,j));
 }
 if(i<n&&a[i+1][j]<=a[i][j]){
 adding(cal(i,j),cal(i+1,j));
 }
 if(j>1&&a[i][j-1]<=a[i][j]){
 adding(cal(i,j),cal(i,j-1));
 }
 if(j<m&&a[i][j+1]<=a[i][j]){
 adding(cal(i,j),cal(i,j+1));
 }
 }
 }
 for(int i=1;i<=n*m;i++){
 if(!dfn[i]) Tarjan(i);
 }
 for(int k=1;k<=n*m;k++){//记录入度和出度
 for(int i=head[k];i;i=e[i].next){
 int v=e[i].to;
 if(is[v]!=is[k]){
 in[is[v]]++;
 out[is[k]]++;
 }
 }
 }
 for(int k=1;k<=tot;k++){
 if(!in[k]) tt1++;
 if(!out[k]) tt2++;
 }
 if(tot==1){//输出答案
 printf("0");
 }else{
 printf("%d",max(tt1,tt2));
 }
 return 0;
}

算法 on 热尘的博客

关于dp状态转移方程的设计4

01分数规划学习笔记

关于动态规划的转移1

P6413 [COCI2008-2009#3] NAJKRACI 题解

01BFS学习笔记

关于需要处理复杂依赖关系的题

关于dp状态转移方程的设计3

关于拓扑排序的应用

字符串读入踩坑1

搜索踩坑1

关于dp状态转移方程的设计2

关于dp状态转移方程的设计1

P9705 「TFOI R1」Unknown Graph 题解

P5032 经验 题解

P4645 [COCI2006-2007#3] BICIKLI 题解

code

P3112 [USACO14DEC] Guard Mark G 题解

P2530 [SHOI2001] 化工厂装箱员 题解

code:

P4209 学习小组 题解

$\mathrm{tag}$：网络流，费用流

SP688 SAM - Toy Cars题解

双倍经验P3419

P3005 [USACO10DEC]The Trough Game S题解

code

P1653 [USACO04DEC] Cow Ski Area G

题解

code

P5032 经验题解

P2530 [SHOI2001] 化工厂装箱员题解

P4209 学习小组题解