Atcoder ABC 353 全題解

A-Problem-Solver發表於2024-05-12

最近看的人好少……都快不想寫了……

你們的支援就是我創作的最大動力！

AB

%你

CDE

題意：有一個一個一個函式，把函式兩兩配對式求值，求這些值最後的總和

C

考慮將所有的和減去 $ 10^8 $ 出現的次數。

將整個陣列排序，然後進行二分，求第一個與這個數的和 $ \ge 10^8 $ 的位置，然後與這個數的位置取 max，看後面的數的數量即可。

// Problem: C - Sigma Problem
// Contest: AtCoder - AtCoder Beginner Contest 353
// URL: https://atcoder.jp/contests/abc353/tasks/abc353_c
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

#define ll long long
#define mod 100000000ll

ll a[300005];

int main() {
	int n;
	scanf("%d", &n);
	ll ans = 0;
	for (int i = 0; i < n; i++) {
		scanf("%lld", &a[i]);
		ans += a[i] * (n - 1);
	}
	sort(a, a + n);
	for (int i = 0; i < n; i++) {
		int cnt = n - max((int)(lower_bound(a, a + n, mod - a[i]) - a), i + 1);
		ans -= mod * cnt;
	}
	printf("%lld", ans);
}

D

兩個數拼湊，比如 $ a $ 位的 $ x $ 和 $ b $ 位的 $ y $，組成的數為 $ 10^bx + y $。

因此，我們可以考慮每個數的 $ 10^b $，那麼一個數對答案的貢獻，就等於它後面的數的 $ 10^b $ 之和，加上前面的數的數量，再將和乘上自己得到的結果。

可以倒序掃描，也可以用字尾和。

// Problem: D - Another Sigma Problem
// Contest: AtCoder - AtCoder Beginner Contest 353
// URL: https://atcoder.jp/contests/abc353/tasks/abc353_d
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

#define ll long long
#define mod 998244353

ll a[200005], suf[200005];
ll prod[200005];

ll calc_prod(ll x) {
	ll ans = 1;
	while (x) {
		ans *= 10;
		x /= 10;
	}
	return ans;
}

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%lld", &a[i]);
		suf[i] = a[i];
		prod[i] = calc_prod(a[i]);
		a[i] %= mod;
	}
	for (int i = n - 1; i >= 0; i--) {
		suf[i] = (suf[i] + suf[i + 1]) % mod;
		prod[i] = (prod[i] + prod[i + 1]) % mod;
	}
	ll ans = 0;
	for (int i = 0; i < n; i++) {
		ans = (ans + a[i] * prod[i + 1] % mod + suf[i + 1]) % mod;
	}
	printf("%lld", ans);
}

E

字首？Trie 樹走上！

先把所有字串插進去，然後進行 dfs 或遍歷。

對於一個節點，統計裡面的字串數量 $ n $，那麼答案就會額外加 $ \frac{n(n - 1)}{2} $。

// Problem: E - Yet Another Sigma Problem
// Contest: AtCoder - AtCoder Beginner Contest 353
// URL: https://atcoder.jp/contests/abc353/tasks/abc353_e
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

#define ll long long

int trie[300005][26];
ll val[300005], cnt = 1;

void insert(string s) {
	int node = 0;
	val[0]++;
	for (char x : s) {
		if (trie[node][x - 'a'] == -1) {
			trie[node][x - 'a'] = cnt++;
		}
		node = trie[node][x - 'a'];
		val[node]++;
	}
}

int main() {
	memset(trie, -1, sizeof trie);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		string s;
		cin >> s;
		insert(s);
	}
	ll ans = 0;
	for (int i = 1; i < cnt; i++) {
		ans += val[i] * (val[i] - 1) / 2;
	}
	printf("%lld", ans);
}

F

首先在一個標準方格紙上走，找出最壞情況。

接著，考慮三種情況：

  1. $ L \to L $

  2. $ L \to S $

  3. $ S \to S $

（第二種包括了 $ S \to L $）

首先考慮核心的第一種情況。

從一個大塊走到斜對角相鄰的另一個大塊，可以從它們夾著的小塊過去，代價為2，那麼一般來說，代價就是座標除以 $ K $ 後的切比雪夫距離乘 2。

但是也有特例：

image

這時候就應該走紅色而非綠色。

那怎麼辦？沒辦法，只能特判 $ K = 2 $ 的情況！

有了 $ L \to L $ 的基礎，23 兩類情況就很好處理了，先列舉一個方向從 $ S $ 走到 $ L $，然後再 $ L \to L $ 處理即可。

// Problem: F - Tile Distance
// Contest: AtCoder - AtCoder Beginner Contest 353
// URL: https://atcoder.jp/contests/abc353/tasks/abc353_f
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

#define ll long long

bool large(ll bx, ll by) {
	return (bx + by) & 1;
}

// X-1,X+1,Y-1,Y+1

ll s_to_l(ll x, ll y, ll sz, int dir) {
	x %= sz, y %= sz;
	if (dir == 0) {
		return x + 1;
	} else if (dir == 1) {
		return sz - x;
	} else if (dir == 2) {
		return y + 1;
	} else {
		return sz - y;
	}
}

ll dis_l(ll bx1, ll by1, ll bx2, ll by2, ll sz) {
	if (sz == 1) {
		return abs(bx1 - bx2) + abs(by1 - by2);
	} else if (sz == 2) {
		ll ans = min(abs(bx1 - bx2), abs(by1 - by2)) * 2;
		ans += (max(abs(bx1 - bx2), abs(by1 - by2)) - min(abs(bx1 - bx2), abs(by1 - by2))) / 2 * 3;
		return ans;
	}
	return max(abs(bx1 - bx2), abs(by1 - by2)) * 2;
}

ll dx[] = {-1, 1, 0, 0};
ll dy[] = {0, 0, -1, 1};

int main() {
	ll sz;
	scanf("%lld", &sz);
	ll sx, sy, tx, ty;
	scanf("%lld %lld", &sx, &sy);
	scanf("%lld %lld", &tx, &ty);
	ll bsx = sx / sz, bsy = sy / sz, btx = tx / sz, bty = ty / sz;
	ll ans = abs(sx - tx) + abs(sy - ty);
	if (sz == 1) {
		printf("%lld", ans);
		return 0;
	}
	if (large(bsx, bsy) && large(btx, bty)) {
		printf("%lld", dis_l(bsx, bsy, btx, bty, sz));
	} else if (!large(bsx, bsy) && !large(btx, bty)) {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				// cerr << i << " " << j << " ";
				// cerr << s_to_l(sx, sy, sz, i) << " " << s_to_l(sx, sy, sz, j);
				// cerr << " " << dis_l(bsx + dx[i], bsy + dy[i], btx + dx[j], bty + dy[j]) << endl;
				ans = min(ans, s_to_l(sx, sy, sz, i) + s_to_l(tx, ty, sz, j) + dis_l(bsx + dx[i], bsy + dy[i], btx + dx[j], bty + dy[j], sz));
			}
		}
		printf("%lld", ans);
	} else {
		if (!large(bsx, bsy)) {
			swap(bsx, btx);
			swap(bsy, bty);
			swap(sx, tx);
			swap(sy, ty);
		}
		for (int i = 0; i < 4; i++) {
			ans = min(ans, s_to_l(tx, ty, sz, i) + dis_l(bsx, bsy, btx + dx[i], bty + dy[i], sz));
		}
		printf("%lld", ans);
	}
}

G

考慮 DP，設 $ f_i $ 為我們必須參加第 $ i $ 場最多能賺到的錢。

聰明的你肯定已經想到了一個 $ O(n^2) $ 的 DP：

\[f_i = \max_{1 \le j < i} f_j + C \cdot |i - j| \]

把轉移分成兩部分，從前面過來和從後面過來。

然後你就會發現，從前面過來的，由於 $ i > j $，所以可以把絕對值符號去掉！

那麼，我們定一個“虛擬起點”，這個點位於所有點的後面。容易發現，從前面轉移來的時候，從“虛擬起點”計算代價和從真正的點計算代價，大小關係以及差的關係仍然保持一致。

後面的同理。

現在，我們只有一個轉移的起點了（即“虛擬起點”），那麼我們就可以用樹狀陣列進行單點更新，字首查詢 max 進行轉移了，時間複雜度 $ O(n log n) $。

// Problem: G - Merchant Takahashi
// Contest: AtCoder - AtCoder Beginner Contest 353
// URL: https://atcoder.jp/contests/abc353/tasks/abc353_g
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

#define ll long long

int n;
ll cost, pre_bit[200005], suf_bit[200005], f[200005];

void update(int i, ll x) {
	int p = i;
	int j = n - i + 1;
	while (i < 200003) {
		pre_bit[i] = max(pre_bit[i], x - cost * (n - p)); // 虛擬起點 n
		i += (i & -i);
	}
	while (j < 200003) {
		suf_bit[j] = max(suf_bit[j], x - cost * p); // 虛擬起點 0
		j += (j & -j);
	}
}

ll query(int i) {
	int p = i;
	int j = n - i + 1;
	ll ans = -0x3f3f3f3f3f3f3f3fll;
	while (i) {
		ans = max(ans, pre_bit[i] + cost * (n - p));
		i -= (i & -i);
	}
	while (j) {
		ans = max(ans, suf_bit[j] + cost * p);
		j -= (j & -j);
	}
	return ans;
}

int main() {
	scanf("%d %lld", &n, &cost);
	int m;
	scanf("%d", &m);
	memset(pre_bit, -0x3f, sizeof pre_bit);
	memset(suf_bit, -0x3f, sizeof suf_bit);
	update(1, 0);
	ll ans = 0;
	for (int i = 1; i <= m; i++) {
		int t;
		ll p;
		scanf("%d %lld", &t, &p);
		f[i] = query(t) + p;
		// cerr << f[i] << endl;
		ans = max(ans, f[i]);
		update(t, f[i]);
	}
	printf("%lld", ans);
}

相關文章