比赛链接

官方题解（视频）

这场偏思维，感觉好像没啥算法。E需要动态维护前 $k$ 小，F是个离散化加dp，状态和递推方程比较 非常规，建议还是看一下涨涨姿势。

---

A 小A的文化节

思路：

签到

code：

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

int n,m,a[maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>a[i];
	int ans=0;
	for(int i=1,t;i<=m;i++){
		cin>>t;
		ans+=a[t];
	}
	cout<<ans;
	return 0;
}

---

B 小A的游戏

思路：

只有两种加分方式，一种是一个人加 $3$ 分，另一个人加 $0$ 分，一种是两人各加 $1$ 分.。

发现如果没有平局的话，两人分数一定是 $3$ 的倍数，加入平局后，两人分数的差值仍然是 $3$ 的倍数。反过来，如果分数的差值是 $3$ 的倍数的话，就可以凑出来某人赢了几场，平了几场，输了几场。换句话说，就是两人分数之差为 $3$ 的倍数=有解。

code：

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

int T,a,b;

int main(){
	cin>>T;
	while(T--){
		cin>>a>>b;
		puts((abs(a-b)%3==0)?"Yes":"No");
	}
	return 0;
}

---

C 小A的数字

思路：

看半天以为是二进制位，结果是十进制位。。。

当然是尝试贪心地将每个数位都置为 $0$，如果本来就是 $0$ 就置为 $1$。因为要求是正整数，所以结果为 $0$ 的时候还需要特判。

code：

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

int T,n;

int main(){
	cin>>T;
	while(T--){
		cin>>n;
		int flag=n%10;
		stack<int> s;
		while(n){
			s.push((n%10)?0:1);
			n/=10;
		}
		while(!s.empty() && s.top()==0)s.pop();
		if(s.empty()){
			if(flag==1)s.push(2);
			else s.push(1);
		}
		
		while(!s.empty()){
			cout<<s.top();
			s.pop();
		}
		cout<<endl;
	}
	return 0;
}

---

D 小A的线段（easy version）

思路：

因为 $m\le 10$ 很小，所以直接暴力枚举选取线段的情况，然后逐一验证即可。

验证的时候可以用差分来优化。

code：

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn=15;

int n,m;
int st[maxn],ed[maxn];

bool check(int sta){
	vector<int> a(n+5);
	for(int i=0;i<m;i++){
		if(sta>>i&1){
			a[st[i]]++;
			a[ed[i]+1]--;
		}
	}
	for(int i=1;i<=n;i++){
		a[i]+=a[i-1];
		if(a[i]<2)return false;
	}
	return true;
}

int main(){
	cin>>n>>m;
	for(int i=0;i<m;i++)cin>>st[i]>>ed[i];
	
	int ans=0;
	for(int i=0;i<(1<<m);i++)
		ans+=check(i);
	cout<<ans;
	return 0;
}

---

E 小A的任务

思路：

因为我们选了所有前 $i$ 个 $A$ 任务，才有资格去前 $i$ 个 $B$ 任务中选任务，一开始的想法是 $dp$。第 $i$ 个任务我们可以只选一个 $A$ 任务，或者同时选择一个 $A$ 任务和相应的 $B$ 任务，设 $dp[i][j]$ 表示前 $i$ 个任务选 $j$ 个 $B$ 任务的最小时间，转移方程为 d p [ i ] [ j ] = m i n { d p [ i − 1 ] [ j ] , d p [ i − 1 ] [ j − 1 ] + B i } + A i dp[i][j]=min\{dp[i-1][j],dp[i-1][j-1]+B_i\}+A_i dp[i][j]=min{dp[i−1][j],dp[i−1][j−1]+Bi​}+Ai​。不过这样转移时间复杂度是 $O(n^2)$ 的，因为它会同时处理出前 $i$ 个任务中选择 $0\sim i$ 个 $B$ 任务的最小代价，因此时间复杂度降不下来，大部分数据我们根本用不到。

考虑其他做法，发现如果我们决定只做前 $i$ 个 $A$ 任务后，我们做 $k$ 个 $B$ 任务一定是做前 $i$ 个中用时最小的 $k$ 个任务。这么做的好处是我们可以使用一个堆来动态维护住前 $i$ 个 $B$ 任务中最小的 $k$ 个用时，这样我们跑一遍下来就得到了 $i$ 取 $k\sim n$ 所有情况下 $B$ 任务的选取情况，也就得到了最小的用时。验证一遍的时间复杂度是 $O(n\ast logk)$ 的，总时间复杂度应该是 $O(n\ast q\ast logk)$，运算次数约为 $10^5\ast 100\ast log\approx 2\ast 10^8$，时限有 $3s$ ，可以通过。

code：

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;

int n,q;
int a[maxn],b[maxn];

ll solve(int k){
	ll tot=0,ans;
	priority_queue<int> h;
	for(int i=1;i<=k;i++){
		tot+=a[i];
		tot+=b[i];
		h.push(b[i]);
	}
	ans=tot;
	for(int i=k+1;i<=n;i++){
		tot+=a[i];
		if(b[i]<h.top()){
			tot-=h.top();
			h.pop();
			tot+=b[i];
			h.push(b[i]);
			ans=min(ans,tot);
		}
	}
	return ans;
}

int main(){
	cin.tie(0)->sync_with_stdio(false);
	
	cin>>n>>q;
	for(int i=1;i<=n;i++)cin>>a[i];
	for(int i=1;i<=n;i++)cin>>b[i];
	
	while(q--){
		int k;
		cin>>k;
		cout<<solve(k)<<endl;
	}
	return 0;
}

---

F 小A的线段（hard version）

思路：

不难发现其实区间里很多位置其实都是没啥用的。$10^5$ 个位置被 $200$ 个线段分成了 $400$ 多个段，段内的所有位置其实没啥用，我们其实可以直接把这些段看成一个点，一个位置。这样离散化一下，$10^5$ 个位置就变成了 $400$ 多个位置。

因为每个位置只要覆盖两次及以上就行了，所以每个位置我们可以看作只有三种状态：覆盖了零次，覆盖了一次，覆盖两次以上，每条线段可以将若干位置的状态进行变化，因此考虑动态规划。

设 $dp[i][j]$ 表示前 $i$ 个位置覆盖了两次及以上，前 $j$ 个位置覆盖了一次的选取线段方法数，为了前面状态不会出现断层（比如前面先覆盖了两次，然后后面变成覆盖一次，然后又变成覆盖了两次），我们对所有线段按左端点进行排序，然后按顺序取更新 $dp$ 值即可（因为我们考虑了左端点在前 $i$ 个位置的线段，那么前面的位置就必须都是覆盖了两次，否则后面更新 $dp$ 也不可能更新状态，这样就保证了我们不需要考虑前面出现断层的情况，因为一定更新不了答案）。

官方题解给出的状态转移方程如下：

我写的时候没看题解，直接分类讨论的，思路是一样的。转移方程如下：

假设我们现在考虑到了第 $k$ 个线段，线段左右端点分别为 $l,r$，设 $dp[i][j]$ 表示前 $i$ 个位置覆盖了两次及以上，前 $j$ 个位置覆盖了一次的选取线段方法数 $(l\le r,i\le j)$。于是有（箭头表示可以转移）：

1. 不选取该线段：$dp[k-1][i][j]\to dp[k][i][j]$
2. 选取该线段：
   1. 当 $l-1\le i\le j\le r$ 时，$dp[k-1][i][j]\to dp[k][j][r]$
   2. 当 $l-1\le i\le r<j$ 时，$dp[k-1][i][j]\to dp[k][r][j]$
   3. 当 $r<i\le j$ 时，$dp[k-1][i][j]\to dp[k][i][j]$

上面第四条和第一条的实际意义是不一样的，前者表示不选取该线段的方法数，后者是选取的方法数，所以两者不影响，正常相加即可。

根据递推式，发现我们实际用的其实是 $l-1$，而不是 $l$，因为离散化后点与点之间相邻关系会被打破，比如 $3,7$ 离散化后是 $1,2$，虽然离散化后 $2$ 减一就等于 $1$，但这并不代表 $7$ 减一就等于 $3$，所以我们离散化的时候直接对 $l-1$ 离散化，而不是 $l$。

另外就是 $1$ 和 $n$ 作为区间左右端点也要放入到离散化数组中去，左端点由于上面所有线段左端点都减一的影响，这里也要减 $1$，也就是说认为左端点是 $0$。

code：

还能滚动数组优化，不过没写

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define pii pair<int,int>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const int maxm=205;
const ll mod=998244353;

int n,m;
vector<pii> itv;

vector<int> tmp;

int main(){
	cin>>n>>m;
	tmp.push_back(0);
	tmp.push_back(n);
	for(int i=1,l,r;i<=m;i++){
		cin>>l>>r;l--;
		tmp.push_back(l);
		tmp.push_back(r);
		itv.push_back(pii(l,r));
	}
	sort(tmp.begin(),tmp.end());
	tmp.erase(unique(tmp.begin(),tmp.end()),tmp.end());
	n=tmp.size();
	auto find=[&](int x)->int{return lower_bound(tmp.begin(),tmp.end(),x)-tmp.begin()+1;};
	for(auto& [l,r]:itv){
		l=find(l);
		r=find(r);
	}
	sort(itv.begin(),itv.end());
	
	vector<vector<vector<ll> > > dp(m+1,vector<vector<ll> >(n+1,vector<ll>(n+1,0)));
	dp[0][1][1]=1;
	for(int k=1;k<=m;k++){
		auto [l,r]=itv[k-1];
		for(int i=0;i<=n;i++)
			for(int j=i;j<=n;j++)
				dp[k][i][j]=dp[k-1][i][j];
		for(int i=0;i<=n;i++){
			for(int j=i;j<=n;j++){
				if(l<=i){
					if(i<=r){
						if(j<=r){
							dp[k][j][r]+=dp[k-1][i][j];
							dp[k][j][r]%=mod;
						}
						else {
							dp[k][r][j]+=dp[k-1][i][j];
							dp[k][r][j]%=mod;
						}
					}
					else {
						dp[k][i][j]+=dp[k-1][i][j];
						dp[k][i][j]%=mod;
					}
				}
			}
		}
		
	}
	cout<<dp[m][n][n]<<endl;
	return 0;
}