省流版
- A. 判斷末三位即可
- B. 逐位判斷即可
- C. 列舉所有分組情況即可
- D. 列舉線段順序、端點順序即可
- E. 二分答案，發現貴的機器數量不超過\(100\)，列舉求最小花費看是否可行即可
- F. 樸素DP，複雜度分析得到有效時刻不超過\(O(n^2)\)而非\(O(s_i)\)，直接\(DP\)即可
A - Takahashi san 2 (abc374 A)
題目大意
給定一個字串，問結尾是不是san
解題思路
直接判斷最後三個字母即可，python可以一行。
神奇的程式碼
print("Yes" if input().strip().endswith('san') else "No")
B - Unvarnished Report (abc374 B)
題目大意
給定兩個字串，問第一個字母不相同的次數。
解題思路
逐位判斷即可。
python的想法，即先找出不同的位置，然後取最小值。
神奇的程式碼
a = input().strip()
b = input().strip()
if len(a) > len(b):
a, b = b, a
if len(a) < len(b):
a += ' ' * (len(b) - len(a))
pos = [i for i in range(len(a)) if a[i] != b[i]]
if not pos:
print(0)
else:
print(pos[0] + 1)
C - Separated Lunch (abc374 C)
題目大意
給定\(n\)個數字，分成兩組，使得和最大值最小。
解題思路
\(n \leq 20\)，直接花 \(O(2^n)\)列舉分組情況，每種情況花 \(O(n)\)統計和，所有情況取最小值即可。總的時間複雜度為\(O(2^nn)\)。
神奇的程式碼
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a)
cin >> x;
int tot = accumulate(a.begin(), a.end(), 0);
int up = (1 << n);
int ans = 2e9 + 7;
for (int i = 0; i < up; ++i) {
int cnt = 0;
for (int j = 0; j < n; ++j) {
cnt += ((i >> j) & 1) * a[j];
}
ans = min(ans, max(cnt, tot - cnt));
}
cout << ans << '\n';
return 0;
}
D - Laser Marking (abc374 D)
題目大意
二維平面，給定\(n\)個線段，用鐳射印表機列印。
鐳射移動速率為\(s\)，列印時的速率為 \(t\)。
規定列印順序，使得耗時最短。初始鐳射位於\((0,0)\)。
解題思路
列印順序，即規定列印線段的順序，以及每個線段從哪個端點開始列印。
由於\(n \leq 6\)，因此花 \(O(n!)\)列舉順序，花 \(O(2^n)\)列舉線段的列印端點，然後花 \(O(n)\)計算時間即可。
總的時間複雜度為\(O(n!2^nn)\)。
神奇的程式碼
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, s, t;
cin >> n >> s >> t;
vector<array<int, 4>> a(n);
for (auto& x : a) {
cin >> x[0] >> x[1] >> x[2] >> x[3];
}
vector<int> id(n);
iota(id.begin(), id.end(), 0);
double ans = 1e9 + 7;
int up = (1 << n);
auto dist = [](int x, int y, int sx, int sy) -> double {
return sqrt((x - sx) * (x - sx) + (y - sy) * (y - sy));
};
auto solve = [&](vector<int>& id, int dir) -> double {
int x = 0, y = 0;
double res = 0;
for (auto& i : id) {
auto [sx, sy, ex, ey] = a[i];
if ((dir >> i) & 1) {
swap(sx, ex);
swap(sy, ey);
}
res += dist(x, y, sx, sy) / s;
res += dist(sx, sy, ex, ey) / t;
x = ex;
y = ey;
}
return res;
};
do {
for (int i = 0; i < up; i++) {
ans = min(ans, solve(id, i));
}
} while (next_permutation(id.begin(), id.end()));
cout << fixed << setprecision(10) << ans << '\n';
return 0;
}
E - Sensor Optimization Dilemma 2 (abc374 E)
題目大意
製作產品，有\(n\)道工序。
每道工序有兩種裝置，單價 \(p_i\)和 \(q_i\)，一天可做 \(a_i\)和 \(b_i\)的產品。
最終的生產效率是所有工序的產品數量的最小值。
現有 \(x\)元，問生產效率的最大值。
解題思路
這題寫的有點不明不白。
首先列舉這個最大值，然後看可不可行。容易發現生產效率越小越容易滿足，越大越難滿足，因此這個答案可以二分（典型的最小值最大）。
二分了生產效率\(m\)後，剩下的問題就是讓每一個工序的產能都\(\geq m\)，且讓花費最小。
這裡只有兩種機器，一個樸素的想法就是計算單位產能的價格，即 \(\frac{p_i}{a_i}\)和 \(\frac{q_i}{b_i}\)看看那個小，那我們肯定買小的那個。
但是會有個問題，如果我們只買小的，然後產能剛好 \(=m\)，此時肯定是最優策略。但如果產能 \(>m\)，此時滿足了\(\geq m\)，但花費不見得是最小的：比如可以少買幾個，多買另外的，使得產能剛好 \(=m\)，且花費比前面的還小（樣例一就是個反例）。
假設 \(a_i\)的單價更低，上述考慮的是全買\(a_i\)的，但不一定是花費最小的，退而求其次，買一些 \(b_i\)來替換 \(a_i\)，那我應該買多少個\(b_i\)呢？
由於\(a_i, b_i \leq 100\)，比賽時就直接猜的 \(b_i\)的範圍就是 \(1 \sim 100\)，再大的話完全可以又等價的\(a_i\)替換之類的。然後就過了。
現在細細想來，這裡的問題即為\(a_i x + b_iy \geq m\)，找到一個最好的\((x,y)\)滿足該不等式，且 \(p_i x + q_i y\)最小。\(x,y\)的範圍都高達 \((10^7)\)，直接遍歷不現實，但我們知道 \(x\)儘可能大是最好的，因此這裡的 \(y\)的範圍不會很大，但有多小呢？
假設\(y=0\)的情況，此時全買 \(a_i\)，最壞情況就是\(a_ix = m + a_i - 1\)，產量超了太多，現在想透過買一些\(b_i\)使得產量超標少一點，比如多一臺\(b_i\)，少幾臺\(a_i\)，就能讓超標量少 \(1\) ，這樣\(b_i\)最多多買\(a_i-1\)臺，就能調整產能剛剛好\(=m\)之類的。 因此\(y\)的範圍最多就到 \(a_i\)。
神奇的程式碼
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
vector<array<int, 4>> a(n);
for (auto& i : a) {
cin >> i[0] >> i[1] >> i[2] >> i[3];
}
auto check = [&](int t) {
LL sum = 0;
for (auto& i : a) {
auto [a, p, b, q] = i;
if (1ll * p * b > 1ll * q * a)
swap(a, b), swap(p, q);
LL tmp = 1e9 + 7;
for (int j = 0; j < a; ++j) {
LL cost = 1ll * max(0, (t - j * b + a - 1) / a) * p + j * q;
tmp = min(tmp, cost);
}
sum += tmp;
}
return sum <= x;
};
int l = 0, r = 1e9 + 8;
while (l + 1 < r) { // [l,r)
int mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l << '\n';
return 0;
}
F - Shipping (abc374 F)
題目大意
\(n\)個單，第 \(i\)個單從 \(s_i\)時刻可以接。
一次最多接 \(k\)個單，接了後 \(x\)時刻之後才能再接。
一個單的不滿意度為接單時刻與可接時刻的差，即\(t_i - s_i\)。
求最小的不滿意度，
解題思路
這題難在複雜度分析。
樸素\(dp\)即 \(dp[i][j]\)表示前 \(i\)時刻，完成了前 \(j\)個單的最小不滿意度。但這裡時刻數高達\(10^{12}\)，不大行。
時刻數不能作為狀態。但考慮上述狀態，有非常多的顯然不優的狀態：我接單的時刻，只有兩類：
- 我現在剛剛可以接單，就立刻接還在囤積的單。
- 或者我等等下一個單，然後一起接。
考慮這樣的時刻數有多少：
- 第一類的時刻數，就是形如\(s_i + x + x + x...\)，但注意到每 \(+x\)，必定有一個囤積的單，如果沒有囤積的單，那下一個時刻就是第二類的（某個\(s_j\)）。因此第一類的時刻數，對於每個 \(i\)來說只有\(O(n)\)個，即最多有\(n\)個\(+x\) 。因此總的時刻數就\(O(n^2)\)個。
- 第二類的時刻數，顯然就是\(O(n)\)個。
所以，上述\(dp[i][j]\)中的 \(i\)，拋去顯然不優的狀態，剩下的只有 \(O(n^2)\)個需要考慮的狀態，加之 \(j\)有\(O(n)\)狀態，其狀態數就是 \(O(n^3)\)，加之轉移複雜度是\(O(k)\)，總的時間複雜度就是\(O(n^3k)\)。
轉移考慮往後轉移的方式，程式碼裡，則為\(dp[i][j]\)表示完成前 \(i\)個單，此時時刻為 \(j\)的最小不滿意度，因為\(j\)是離散的所以是個 \(map\)。然後列舉接下來完成的單的數量\(l\)，計算不滿意度轉移即可。計算不滿意度即\(\sum t - s_i\)，可以用字首和最佳化，或者列舉\(l\)時維護 \(\sum s_i\)。
標準寫法500ms
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, x;
cin >> n >> k >> x;
vector<LL> t(n);
for (auto& i : t)
cin >> i;
vector<LL> sum(n);
partial_sum(t.begin(), t.end(), sum.begin());
vector<map<LL, LL>> dp(n + 1);
dp[0][0] = 0;
auto get_sum = [&](int l, int r) {
if (l > r)
return 0ll;
return sum[r] - (l ? sum[l - 1] : 0);
};
for (int i = 0; i < n; ++i) {
for (auto& [now, val] : dp[i]) {
int st = i;
for (int j = 1; j <= k && i + j <= n; ++j) {
int ed = st + j;
LL cur = max(now, t[ed - 1]);
LL nxt = val + j * cur - get_sum(st, ed - 1);
if (dp[i + j].count(cur + x)) {
dp[i + j][cur + x] = min(dp[i + j][cur + x], nxt);
} else {
dp[i + j][cur + x] = nxt;
}
}
}
}
LL ans = 1e18 + 7;
for (auto& [_, val] : dp[n]) {
ans = min(ans, val);
}
cout << ans << '\n';
return 0;
}
下面的是比賽時寫的，加了點小小的轉移最佳化，省去了一些不必要的轉移（即囤積的單肯定全部處理）。
賽場時寫的稍加最佳化的1ms
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, x;
cin >> n >> k >> x;
vector<LL> t(n);
for (auto& i : t)
cin >> i;
vector<LL> sum(n);
partial_sum(t.begin(), t.end(), sum.begin());
vector<map<LL, LL>> dp(n + 1);
dp[0][0] = 0;
auto get_sum = [&](int l, int r) {
if (l > r)
return 0ll;
return sum[r] - (l ? sum[l - 1] : 0);
};
for (int i = 0; i < n; ++i) {
for (auto& [now, val] : dp[i]) {
int st = i;
int ed = upper_bound(t.begin(), t.end(), now) - t.begin(); // 囤積的單
int cnt = max(1, ed - st);
for (int j = min(k, cnt); j <= k && i + j <= n; ++j) { // 囤積的單肯定全部處理
ed = st + j;
LL cur = max(now, t[ed - 1]);
LL nxt = val + j * cur - get_sum(st, ed - 1);
if (dp[i + j].count(cur + x)) {
dp[i + j][cur + x] = min(dp[i + j][cur + x], nxt);
} else {
dp[i + j][cur + x] = nxt;
}
}
}
}
LL ans = 1e18 + 7;
for (auto& [_, val] : dp[n]) {
ans = min(ans, val);
}
cout << ans << '\n';
return 0;
}
G - Only One Product Name (abc374 G)
題目大意
給定\(n\)個長度為 \(2\)的大寫字串，構造一個字串列表，滿足每個大寫字元都作為子串出現在這列表裡，且列表裡每個字串的 \(2\)字母子串都是這 \(n\)個字串裡的，即出現的都在子串裡，子串裡的都出現了。
解題思路
<++>
神奇的程式碼