2023ICPC南京 - A F G I

目录

• A. Cool, It's Yesterday Four Times More
• F. Equivalent Rewriting
• G. Knapsack
• I. Counter
• L. Elevator

The 2023 ICPC Asia Nanjing Regional Contest

A 暴力
F 拓扑排序
G 01背包变式
I 思维
L 思维

A. Cool, It's Yesterday Four Times More

定义上下左右相邻的 '.' 为一个连通块
那么一个连通块里至少有一只袋鼠可以成为赢家，那么该连通块所有的袋鼠都可以成为赢家；如果一个连通块里至少有一只袋鼠不是赢家，那么该连通块的所有袋鼠都不是赢家。

注意到 $n,m\le 5\times {10}^3$，所有暴力判断每只袋鼠是否能成为赢家即可。对于每只袋鼠利用 bfs 找其连通块，对剩下的非其连通块的袋鼠一步一步考虑其是否可能留下，若剩下的所有的袋鼠都不可留下，那么这个连通块的所有袋鼠都是赢家

int fx[4] = {0, 1, 0, -1},
	fy[4] = {1, 0, -1, 0};
 
void solve(){
	int n, m;
	cin >> n >> m;
	vector<string> ss(n);
	vector vis(n, vector<int>(m, 0));
	for(int i = 0; i < n; ++ i) cin >> ss[i];
	int ans = 0, idx = 0;
	for(int i = 0; i < n; ++ i){
		for(int j = 0; j < m; ++ j){
			if(ss[i][j] == '.' && vis[i][j] == 0){
				queue<pii> q;
				vector<pii> path;
				q.push({i, j});
				++ idx;
				vis[i][j] = idx;
				while(q.size()){
					auto [x, y] = q.front();
					q.pop();
					path.push_back({x - i, y - j});
					for(int k = 0; k < 4; ++ k){
						int xx = x + fx[k], yy = y + fy[k];
						if(xx >= 0 && xx < n && yy >= 0 && yy < m && ss[xx][yy] == '.' && !vis[xx][yy]){
							q.push({xx, yy});
							vis[xx][yy] = idx;
						}
					}
				}
				bool f = true;
				for(int a = 0; a < n && f; ++ a){
					for(int b = 0; b < m && f; ++ b){
						if(vis[a][b] == idx || ss[a][b] != '.') continue;
						bool ok = true;
						for(auto [dx, dy] : path){
							int x = a + dx, y = b + dy;
							if(x < 0 || x >= n || y < 0 || y >= m || ss[x][y] != '.'){
								ok = false; break;
							}
						}
						if(ok){// ok - 没掉下去
							f = false;
						}
					}
				}
				if(f) ans += path.size();
			}
		}
	}
	cout << ans << '\n';
	return ;
}

F. Equivalent Rewriting

当某个下标最后一次出现时，其就是关键操作，即所有包含该下标的操作都需要在本操作的前面。
我们考虑对于所有的操作与其对应的关键操作建单向边，再跑拓扑排序，得到字典序尽可能大的拓扑序。如果最后得到的拓扑序不是1~n，则有解，反之无解

void solve(){
	int n, m;
	cin >> n >> m;
	vector<int> p[n], b(m + 1, 0);
	for(int i = 0; i < n; ++ i){
		int c;
		cin >> c;
		while(c--){
			int a;
			cin >> a;
			p[i].push_back(a);
			b[a] = i;
		}
	}
	set<int, greater<int>> e[n];
	vector<int> in(n, 0);
	for(int i = n - 1; i >= 0; -- i){
		for(auto x : p[i]){
			if(i != b[x] && !e[i].count(b[x])){
				++ in[b[x]];
				e[i].insert(b[x]);
			}
		}
	}
	vector<int> q[2];
	vector<int> ans;
	for(int i = 0; i < n; ++ i){
		if(in[i] == 0) q[0].push_back(i);
	}
	int id = 0;
	while(ans.size() < n){
		sort(q[id].begin(), q[id].end(), greater<int>());
		for(auto u : q[id]){
			ans.push_back(u);
			for(auto v : e[u]){
				-- in[v];
				if(in[v] == 0) q[1 - id].push_back(v);
			}
		}
		q[id].clear();
		id = 1 - id;
	}
	bool f = false;
	for(int i = 0; i < n && !f; ++ i)
		if(i != ans[i]) f = true;
	if(f){
		cout << "Yes\n";
		for(int i = 0; i < n; ++ i)
			cout << ans[i] + 1 << " \n"[i == n - 1];
	}else cout << "No\n";
	return ;
}

G. Knapsack

普通的01背包 + 可以免价格获得 k 件物品的价值
可以发现，最终带走的物品中，最贵的的 k 件物品一定是免价格获得的，不然就可以找到更优解

所以将所有物品按照价格升序，维护后缀取 k 件物品的最大价值和，前缀跑01背包，再枚举前后缀分界线，和的最大值即为最终答案

void solve(){
	int n, w, k;
	cin >> n >> w >> k;
	vector<pii> a(n);
	for(auto &[x, y] : a) cin >> x >> y;
	sort(a.begin(), a.end());
	vector<ll> dpk(n + 1, 0);
	multiset<int> s;
	if(k)
		for(int i = n - 1; i >= 0; -- i){
			if(s.size() < k){
				s.insert(a[i].second);
				dpk[i] = a[i].second;
			}else if(*s.begin() < a[i].second){
				dpk[i] = a[i].second -*s.begin();
				s.erase(s.begin());
				s.insert(a[i].second);
			}
			dpk[i] += dpk[i + 1];
		}
	ll ans = dpk[0];
	vector<ll> dp(w + 1, 0);
	for(int i = 0; i < n; ++ i){
		auto [x, y] = a[i];
		for(int j = w; j >= x; -- j){
			dp[j] = max(dp[j], dp[j - x] + y);
		}
		ans = max(ans, dp[w] + dpk[i + 1]);
	}
	cout << ans << '\n';
	return ;
}

I. Counter

对所有已知信息按照 a 升序排序，对于每一个数，考虑其与前一个已知条件

• 如果说值变大了，要么是一直选择按按钮 '+'，要么选择一个时刻按按钮 'c'再一直按 '+'
• 如果说值变小了，一定是选择一个时刻按按钮 'c'再一直按 '+'

判断这两个条件是否对于所有排序后两两已知条件是否成立即可

void solve(){
	int n, m;
	cin >> n >> m;
	vector<pii> a(m);
	for(auto &[x, y] : a) cin >> x >> y;
	a.push_back({0, 0});
	sort(a.begin(), a.end());
	for(int i = 1; i <= m; ++ i){
		auto [x, y] = a[i];
		auto [px, py] = a[i - 1];
		if(y >= py && (x - px >= y + 1 || x - px == y - py)) continue;
		if(y <= py && x - px >= y + 1) continue;
		cout << "No\n";
		return ;
	}
	cout << "Yes\n";
	return ;
}

L. Elevator

按照楼层从高到低尽可能的放货物

const int N = 1e5 + 5, inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f, mod = 998244353;
 
struct node{
	int c, w, f;
}p[N];
 
void solve(){
	ll n, k;
	cin >> n >> k;
	for(int i = 0; i < n; ++ i)
		cin >> p[i].c >> p[i].w >> p[i].f;
	sort(p, p + n, [&](node x, node y){
		return x.f > y.f;
	});
	ll ans = 0;
	for(int i = 0; i < n; ++ i){
		if(p[i].c == 0) continue;
		ans += p[i].f * (p[i].c * p[i].w / k);
		if(p[i].c * p[i].w % k){
			ans += p[i].f;
			ll now = k - (p[i].c * p[i].w) % k;
			for(int j = i + 1; now && j < n; ++ j){
				if(p[j].c * p[j].w <= now){
					now -= p[j].c * p[j].w;
					p[j].c = 0;
				}else{
					p[j].c -= now / p[j].w;
					now %= p[j].w;
				}
			}
		}
	}
	cout << ans << '\n';
	return ;
}