Toyota Programming Contest 2024#3（AtCoder Beginner Contest 344）（A,B,C,D,E,F）

比赛链接

这场偏简单，C是暴力，D是变种背包，E是map+链表，F是四维dp。DF出的很好，建议做。

---

A Spoiler

题意：

给你一个由小写英文字母和 | 组成的字符串 $S$。$S$ 中保证包含两个 |。

请删除两个|之间的字符，包括|本身，并打印得到的字符串。

思路：

用 string 的 find_first_of() 和 find_last_of() 成员函数可以很容易找到 | 的位置，然后再用 substr() 成员函数提取字串即可。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

string str;

int main(){
	cin>>str;
	int a=str.find_first_of("|"),b=str.find_last_of("|");
	cout<<str.substr(0,a)<<str.substr(b+1);
	return 0;
}

---

B Delimiter

题意：

给你 $N$ 个整数 $A_1,A_2,\dots ,A_N$，每行一个，共 $N$ 行。但是，输入中没有给出 $N$。
此外，下面的内容是有保证的：

• $A_i\ne 0$ ( $1\le i\le N-1$ )
• $A_N=0$

按此顺序打印 $A_N,A_{N-1},\dots ,A_1$。

思路：

因为要逆序输出，用个栈存一下，读到 $0$ 就停止读入然后输出。

code：

#include <iostream>
#include <cstdio>
#include <stack>
using namespace std;

int t;
stack<int> s;

int main(){
	do{
		cin>>t;
		s.push(t);
	}while(t);
	
	while(!s.empty()){
		cout<<s.top()<<endl;
		s.pop();
	}
	return 0;
}

---

C A+B+C

题意：

给你三个序列 $A=(A_1,\dots ,A_N)$、$B=(B_1,\dots ,B_M)$ 和 $C=(C_1,\dots ,C_L)$。

此外，还给出了一个序列 $X=(X_1,\dots ,X_Q)$。针对每个 $i=1,\dots ,Q$ 求解下面的问题：

问题：能否从 $A$、$B$ 和 $C$ 中各选择一个元素，使它们的和为 $X_i$？

思路：

发现数据范围很小，$N,M,L$ 最多就 $100$，因此直接暴力即可。枚举三个数组中的每个元素，算出所有可能的结果，最后把得到的所有数放进set里，之后查询即可

code：

#include <iostream>
#include <cstdio>
#include <set>
using namespace std;
const int maxn=105;

int a[5][maxn],Q;

int main(){
	for(int i=1;i<=3;i++){
		cin>>a[i][0];
		for(int j=1;j<=a[i][0];j++)
			cin>>a[i][j];
	}
	set<int> s;
	for(int i=1;i<=a[1][0];i++)
		for(int j=1;j<=a[2][0];j++)
			for(int k=1;k<=a[3][0];k++)
				s.insert(a[1][i]+a[2][j]+a[3][k]);
	
	for(cin>>Q;Q;Q--){
		int t;
		cin>>t;
		puts((s.find(t)==s.end())?"No":"Yes");
	}
	return 0;
} 

---

D String Bags

题意：

最初有一个空字符串 $S$。
此外，还有袋子 $1,2,\dots ,N$，每个袋子都包含一些字符串。
袋 $i$ 包含 $A_i$ 个字符串 $S_{i,1},S_{i,2},\dots ,S_{i,A_i}$。

对 $i=1,2,\dots ,N$ 重复以下步骤：

• 选择并执行以下两个操作之一：
  • 支付 $1$ 日元，从袋子 $i$ 中选择一个字符串，并将其连接到 $S$ 的末尾。
  • 不做任何操作。

给定字符串 $T$，求使最后的 $S$ 等于 $T$ 所需的最小金额。
如果无法使最后的 $S$ 等于 $T$，则打印 -1。

限制因素

• $T$ 是由小写英文字母组成的字符串，长度在 $1$ 和 $100$ 之间（含）。
• $N$ 是介于 $1$ 和 $100$ 之间的整数，包含在内。
• $A_i$是介于$1$和$10$之间的整数，包括$1$和$10$。
• $S_{i,j}$是由小写英文字母组成的字符串，长度在$1$和$10$之间（包括$1$和$10$）。

思路：

看清楚题，注意是按顺序从第 $i$ 个袋子中取一个，不能回头取，也不能一个袋子取多个。所有 $AC\times 57/WA\times 1$ 的大概率是一个袋子取了多个字符串（也就是说不能滚动数组优化）。

读懂题之后，这个题其实就是比较明显的背包了。设 $dp[i][j]$ 表示从前 $i$ 个袋子中拼到 $j$ 长度的最少花费，如果不从第 $i$ 个袋子选字符串，那么就可以转移到 $dp[i+1][j]$，如果从第 $i$ 个袋子中选取一个字符串，如果这个字符串长度为 $len$ 并且这个字符串与 $T$ 串的 $j\sim j+len-1$ 部分子串正好相同，这个字符串就可以拼到这里，状态转移到 $dp[i+1][j+len]$。

由于第 $i$ 个袋子只能选一个字符串，所以不能滚动数组优化，乖乖二维DP。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int maxn=105;
const int inf=1e9;

int n,m;
string t;
vector<vector<int> > dp(maxn,vector<int>(maxn,inf));

int main(){
	cin>>t;
	n=t.length();
	t=" "+t;
	
	cin>>m;
	for(int i=0;i<=m;i++)dp[i][0]=0;
	for(int i=1,_;i<=m;i++){
		for(cin>>_;_;_--){
			string s;
			int len;
			cin>>s;
			len=s.length();
			
			for(int j=1;j<=n;j++){
				dp[i][j]=min(dp[i][j],dp[i-1][j]);
				if(j-len>=0 && t.substr(j-len+1,len)==s)
					dp[i][j]=min(dp[i][j],dp[i-1][j-len]+1);
			}
		}
	}
	if(dp[m][n]==inf)cout<<-1<<endl;
	else cout<<dp[m][n]<<endl;
	return 0;
}

---

E - Insert or Erase

题意：

给你一个长度为 $N$ 的序列 $A=(A_1,\dots ,A_N)$。$A$ 中的元素是不同的。

请按照给出的顺序处理 $Q$ 个查询。每个查询属于以下两种类型之一：

• 1 x y：在 $A$ 中元素 $x$ 后面紧接着插入 $y$。当给出此查询时，保证 $x$ 存在于 $A$ 中。
• 2 x：从 $A$ 中删除元素 $x$。当给出此查询时，保证$x$存在于$A$中。

保证在处理完每一个查询后，$A$都不是空的，并且其元素都是不同的。

处理完所有查询后，打印 $A$。

思路：

对操作 $1$，需要查找 $x$ 的位置，然后在它后面插入 $y$，对操作 $2$，需要查找 $x$ 的位置，然后删掉它。因为题目非常贴心地告诉我们每个元素值都不一样，所以可以用 $map$ 建立起值到位置的映射，而插入删除，就需要使用链表了。

code：

这里写的 头节点为 $0$ 的循环双向链表。

#include <iostream>
#include <cstdio>
#include <map>
using namespace std;
const int maxn=2e5+5;

int n,Q;
int nxt[maxn<<1],pre[maxn<<1],a[maxn<<1],cnt;
map<int,int> mp;

int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		mp[a[i]]=i;
		nxt[i-1]=i;
		pre[i]=i-1;
	}
	cnt=n;
	for(cin>>Q;Q;Q--){
		int op,x,y,p;
		cin>>op;
		if(op==1){
			cin>>x>>y;
			p=mp[x];
			a[++cnt]=y;
			mp[y]=cnt;
			pre[cnt]=p;
			nxt[cnt]=nxt[p];
			pre[nxt[p]]=cnt;
			nxt[p]=cnt;
		}
		else {
			cin>>x;
			p=mp[x];
			mp.erase(x);
			nxt[pre[p]]=nxt[p];
			pre[nxt[p]]=pre[p];
		}
	}
	for(int p=nxt[0];p;p=nxt[p]){
		cout<<a[p]<<" ";
	}
	return 0;
}

---

F - Earn to Advance

题意：

有一个网格，网格中有 $N$ 行和 $N$ 列。让 $(i,j)$ 表示从上面起第 $i$ 行和从左边起第 $j$ 列的正方形。

高桥最初在 $(1,1)$ 个方格中的钱为零。

当高桥在 $(i,j)$ 号方格时，他可以在一次行动中完成以下其中一项：

• 停留在同一位置并增加$P_{i,j}$个数字。
• 从他的钱中支付 $R_{i,j}$ 并移动到 $(i,j+1)$ 格。
• 从他的钱中支付 $D_{i,j}$ 并移动到 $(i+1,j)$ 格。

他不能走会使他的金钱变为负数或使他离开棋盘的一步棋。

如果高桥采取最优行动，他需要下多少步棋才能到达 $(N,N)$ 位置？

思路：

当看到 $N\le 80$ 的时候就不对劲起来了。可以跑 $N^4$，甚至还能带点常数。

我们到达某个位置的时候，最少需要描述：横坐标，纵坐标，时间，剩余金钱 四个状态参数。而金钱这东西我们可以先在一个地方打很长时间的工，赚很多钱再向后走，这样可能是更优的。而我们在打工的时候很难知道赚多少合适，也不知道后面有没有更好的打工地点。那么如何解决呢？

考虑到我们走过一个路径到达 $(i,j)$ 点的时候，路径上经过的所有点我们都可以提前在那打工，显然我们在最赚钱的地方打工。对这个打工地点，我们如果在 $(i,j)$ 上需要钱，那么之前离开这个打工地点之前，可以先不走，留下来多赚几天钱。也就是说我们相当于可以随时随地回到前面路径上的任何一个点来赚钱。

但是我们并不知道我们是如何到达 $(i,j)$ 的，自然也不知道路径上有什么点。但是我们只关心经过的最赚钱的那个地点，也就是我们返回前面打工的地点，加上这题可以跑 $N^4$ ，那么我们就可以把这个点放进 $dp$ 里，具体来说，设 $dp[i][j][x][y]$ 表示到达 $(i,j)$ 并在 $(x,y)$ 打工的最少花费时间和最多剩余金钱。

这里 $dp$ 是个 $pair$ 类型，存储最少花费时间和最多剩余金钱。那么哪种值算最优？答案是花费时间最少的最优，其次剩余金钱最多的最优。因为我们可以随时回去赚钱，所以我们不挣闲钱，只要钱够就绝对不多花一天时间挣钱。因为我们推最优状态的最优推理时，经过的路径上的点一定是越来越挣钱的，你转移过来的时候剩余的最多的金钱最多不会超过前面路径上的 最赚钱地点上 一天赚的钱，也就小于在 $(x,y)$ 上一天赚的钱，花费时间少的多花一天时间在 $(x,y)$ 挣钱，手上的钱一定更多。因此这样排序是正确的。

$dp[i][j][x][y]$ 可以由 $dp[i-1][j][x][y]$ 和 $dp[i][j-1][x][y]$ 转移得到，而转移过来时，分别需要花费 $D[i-1][j]$ 和 $R[i][j-1]$ 的代价，这时候就可能需要去 $(x,y)$ 赚钱。

假设从 $dp[i-1][j][x][y]$ 转移过来，设在 $(i,j)$ 这里花费了 $tm$ 时间挣钱，手上剩余 $lst$ 钱，挣钱效率 $c=P[x][y]$，转移代价 $w=D[i-1][j]$，需要花费 $k$ 天来赚钱，就有：$$lst+k\ast c-w\ge 0$$$$k\ge \frac{w-lst}{c}$$$$k=\lceil \frac{w-lst}{c}\rceil$$

另外我们在 $(i,j)$ 的时候，可以把之后挣钱的地点改为 $(i,j)$，这时 $dp[i][j][i][j]$ 可以由所有 $dp[i][j][x][y](1\le x\le i,1\le y\le j)$ 推过来。

code：

#include <iostream>
#include <cstdio>
#include <queue>
#define mk make_pair
using namespace std;
typedef long long ll;
const int maxn=85;
const ll inf=1e18;

int n;
vector<vector<ll> > P(maxn,vector<ll>(maxn));
vector<vector<ll> > R(maxn,vector<ll>(maxn));
vector<vector<ll> > D(maxn,vector<ll>(maxn));

vector<vector<vector<vector<pair<ll,ll> > > > > 
	dp(maxn,vector<vector<vector<pair<ll,ll> > > >
	(maxn,vector<vector<pair<ll,ll> > >
	(maxn,vector<pair<ll,ll> >(maxn,mk(inf,0)))));

pair<ll,ll> g(pair<ll,ll> x,pair<ll,ll> y){
	if(x.first!=y.first)return (x.first<y.first)?x:y;
	return (x.second>y.second)?x:y;
}

int main(){
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			cin>>P[i][j];
	for(int i=1;i<=n;i++)
		for(int j=1;j<n;j++)
			cin>>R[i][j];
	for(int i=1;i<n;i++)
		for(int j=1;j<=n;j++)
			cin>>D[i][j];
	
	dp[1][1][1][1]=mk(0,0);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			for(int x=1;x<=i;x++){
				for(int y=1;y<=j;y++){
					ll k,c,tm,lst,w;
					if(i>1 && i-1>=x){
						tm=dp[i-1][j][x][y].first;//花了多少时间 
						lst=dp[i-1][j][x][y].second;//剩了多少钱 
						w=D[i-1][j];//走过来需要花的钱 
						c=P[x][y];//挣钱的效率 
						k=max(0ll,(w-lst+c-1)/c);//需要花多长时间挣钱 
						dp[i][j][x][y]=g(dp[i][j][x][y],mk(tm+k+1,lst+k*c-w));
					}
					if(j>1 && j-1>=y){
						tm=dp[i][j-1][x][y].first;
						lst=dp[i][j-1][x][y].second;
						w=R[i][j-1];
						c=P[x][y];
						k=max(0ll,(w-lst+c-1)/c);
						dp[i][j][x][y]=g(dp[i][j][x][y],mk(tm+k+1,lst+k*c-w));
					}
					dp[i][j][i][j]=g(dp[i][j][i][j],dp[i][j][x][y]);
				}
			}
		}
	}
	cout<<dp[n][n][n][n].first<<endl;
	return 0;
}