AtCoder Beginner Contest 375

省流版

• A. 枚举所有子串判断即可
• B. 模拟计算记录累加即可
• C. 根据旋转的周期性对每个点旋转次数取模后暴力旋转即可
• D. 枚举$k$，考虑 $i,j$的对数，写成数学表达式后维护个数和位置和即可
• E. 背包问题，以前两个数组和为状态，考虑每个数移动到何处转移即可
• F. 逆向，删边变加边，维护加边后的距离变化即可
• G. 最短路径图的割边判断，根据最短路条数判断是否必经即可

A - Seats (abc375 A)

题目大意

给定一个字符串，问有多少个形如#.#的子串。

解题思路

枚举所有子串依次比较即可。

神奇的代码

#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;
    string s;
    cin >> n >> s;
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans += (s.substr(i, 3) == "#.#");
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

B - Traveling Takahashi Problem (abc375 B)

题目大意

二维平面，给定$n$个点，从$(0,0)$出发，依次经历这些点，最后回到 $(0,0)$，求其欧几里德距离和。

解题思路

依次模拟计算距离和，累加即可。

神奇的代码

#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<array<int, 2>> p(n + 2);
    p[0] = {0, 0};
    for (int i = 1; i < n + 1; i++) {
        cin >> p[i][0] >> p[i][1];
    }
    p[n + 1] = {0, 0};
    double ans = 0;
    auto dist = [](array<int, 2> a, array<int, 2> b) {
        return sqrt(1ll * (a[0] - b[0]) * (a[0] - b[0]) +
                    1ll * (a[1] - b[1]) * (a[1] - b[1]));
    };
    for (int i = 1; i < p.size(); ++i) {
        ans += dist(p[i], p[i - 1]);
    }
    cout << fixed << setprecision(10) << ans << '\n';
 
    return 0;
}
 

---

C - Spiral Rotation (abc375 C)

题目大意

给定一个$n \times n$的正方形，对于 $i \in [1, n]$ ，依次进行如下操作：

• 以$(i,i)$为一角的 $(n - i + 1) \times (n - i - 1)$ 的正方形顺时针旋转$90$度。

输出最终的矩形。

解题思路

注意到旋转的区间是往中间收缩的，因为旋转操作具有结合性和周期性（旋转$4$次等于没旋转），所以依次遍历该正方形的每个元素$(i,j)$，可以求出它进行了多少次 顺时针旋转 $90$度，然后对 $4$取余后，再进行对应次数的顺时针旋转即可。

其实暴力的复杂度是$(2n^2 \log n)$，虽然$n \leq 3000$，但貌似还是不能过。

神奇的代码

#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<string> s(n);
    for (auto& i : s)
        cin >> i;
    auto tr = [](int x, int y, int n) { return make_pair(y, n - 1 - x); };
    auto tr_cnt = [&](int x, int y, int n, int c) {
        for (int i = 0; i < c; ++i) {
            tie(x, y) = tr(x, y, n);
        }
        return make_pair(x, y);
    };
    vector<string> t = s;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            int cnt = min({i, j, n - 1 - i, n - 1 - j}) + 1;
            auto [x, y] = tr_cnt(i, j, n, cnt % 4);
            t[x][y] = s[i][j];
        }
    }
    for (auto i : t)
        cout << i << '\n';
 
    return 0;
}
 

---

D - ABA (abc375 D)

题目大意

给定一个字符串$s$，问有多少$i < j < k$，满足 $s_is_js_k$是回文串。

解题思路

枚举$k$，考虑满足条件的 $i$，那必然有$s_i == s_k$，然后固定这个$i$，考虑 $j$的方案数，即为 $k - i - 1$。

也就是说，对于当期 $k$，其对答案的贡献为 $\sum_{i < k \& s_i==s_k} k - i - 1 = (k-1) cnt_{a_k} - \sum_{i < k \& s_i == s_k} i$。

因此我们只需动态维护两个数组：

• $cnt_i$表示字符为$i$的位置数
• $sum_i$表示字符为$i$的位置的和

就可以$O(1)$求得固定$k$时， $(i,j,k)$的方案数。

对所有的$k$累加即为答案。时间复杂度为 $O(n)$。

神奇的代码

#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);
    string s;
    cin >> s;
    array<int, 26> cnt{};
    array<LL, 26> sum{};
    LL ans = 0;
    for (int i = 0; i < s.size(); ++i) {
        int c = s[i] - 'A';
        ans += 1ll * cnt[c] * (i - 1) - sum[c];
        cnt[c]++;
        sum[c] += i;
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

E - 3 Team Division (abc375 E)

题目大意

三个数组，操作为，花费$1$的代价，将一个数从一个数组移动到另一个数组。

问最小的代价，使得三个数组的和相等，或告知不可行。

数组和$\sum b_i \leq 1500$。

解题思路

考虑两个数组的简化版。

考虑朴素搜索，即依次考虑每个数，应该移动还是不移动。其复杂度显然是$O(2^n)$。

因为状态是包含了每个数的数组位置，它过于冗余了，考虑到我们要求的答案，我们可以仅保留一个简化的状态即可：

• 一个数组的和

知道了一个数组的和，对于当前数，移动还是不移动，其带来的影响都可以进行转移，最后也能直接得到答案。

因为总数不变，所以知道了一个数组的和，另一个数组的和其实也知道了，即设 $dp[i][j]$表示考虑了前 $i$个数，第一个数组和为 $j$的最小移动代价。对于一个数，考虑移动或不移动，对 $j$的影响转移即可。这样的复杂度即为 $O(n \sum b_i)$

而这里有三个数组，按照同样的思路，知道了前两个数组的和，第三个数组的和也确定了，即设$dp[i][j][k]$表示考虑了前 $i$个数，第一个数组和为 $j$，第二个数组和为$k$的最小移动代价，转移仍然是对于一个数，考虑移动到哪个数组，或者不移动即可。这样的时间复杂度为$O(n (\sum b_i) ^ 2)$

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int inf = 1e9 + 7;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    array<vector<int>, 3> p{};
    int sum = 0;
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        --a;
        p[a].push_back(b);
        sum += b;
    }
    if (sum % 3 != 0)
        cout << -1 << '\n';
    else {
        vector<vector<int>> dp(sum + 1, vector<int>(sum + 1, inf));
        dp[accumulate(p[0].begin(), p[0].end(), 0)]
          [accumulate(p[1].begin(), p[1].end(), 0)] = 0;
        for (auto& i : p[0]) {
            auto dp2 = dp;
            for (int j = 0; j <= sum; j++) {
                for (int k = 0; k <= sum; k++) {
                    if (j >= i)
                        dp2[j - i][k] = min(dp2[j - i][k], dp[j][k] + 1);
                    if (j >= i && k + i <= sum)
                        dp2[j - i][k + i] =
                            min(dp2[j - i][k + i], dp[j][k] + 1);
                }
            }
            dp.swap(dp2);
        }
        for (auto& i : p[1]) {
            auto dp2 = dp;
            for (int j = 0; j <= sum; j++) {
                for (int k = 0; k <= sum; k++) {
                    if (k >= i)
                        dp2[j][k - i] = min(dp2[j][k - i], dp[j][k] + 1);
                    if (k >= i && j + i <= sum)
                        dp2[j + i][k - i] =
                            min(dp2[j + i][k - i], dp[j][k] + 1);
                }
            }
            dp.swap(dp2);
        }
        for (auto& i : p[2]) {
            auto dp2 = dp;
            for (int j = 0; j <= sum; j++) {
                for (int k = 0; k <= sum; k++) {
                    if (k + i <= sum)
                        dp2[j][k + i] = min(dp2[j][k + i], dp[j][k] + 1);
                    if (j + i <= sum)
                        dp2[j + i][k] = min(dp2[j + i][k], dp[j][k] + 1);
                }
            }
            dp.swap(dp2);
        }
        int target = sum / 3;
        if (dp[target][target] == inf) {
            dp[target][target] = -1;
        }
        cout << dp[target][target] << '\n';
    }
 
    return 0;
}
 

---

F - Road Blocked (abc375 F)

题目大意

给定一张无向图，维护以下两种操作：

• 1 x，删去第$x$条边
• 2 u v，问$u \to v$的最短路长度

其中操作 $1$最多 $300$次。

解题思路

加边往往比删边好做，注意到询问没有强制在线，因此可以倒着考虑操作，这样删边操作就变成加边操作了。

因为点数$\leq 300$，先用 $floyd$花 $O(n^3)$求出任意两点的最短路，这样操作 $2$就可以 $O(1)$回答，然后考虑操作 $1$加边后，怎么更新这个两点的最短路。

考虑加的边 $u \to v$对任意两点 $x \to y$ 的最短路的影响，其实就两种情况：

• $x \to y$的最短路不经过 $u \to v$
• $x \to y$的最短路经过 $u \to v$

在加边之前，$dis[x][y]$的值就属于第一种情况，现在加边后， $dis[x][y]$就是这两种情况的最小值，因此$dis[x][y]$只要和第二种情况取个最小值，这样$dis[x][y]$就变成 加上边 $u \to v$后的值了。

而第二种情况的距离即为 $dis[x][u] + u \to v + dis[v][y]$或 $dis[x][v] + v \to u + dis[u][y]$。

加一边，更新一次的复杂度为 $O(n^2)$，因为操作 $1$不超过 $300$，因此总的时间复杂度为 $O(n^3)$。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const LL inf = 1e18;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m, q;
    cin >> n >> m >> q;
    vector<vector<LL>> dis(n, vector<LL>(n, inf));
    vector<array<int, 3>> edges(m);
    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        dis[u][v] = dis[v][u] = min(dis[u][v], (LL)w);
        edges[i] = {u, v, w};
    }
    for (int i = 0; i < n; ++i)
        dis[i][i] = 0;
    vector<array<int, 3>> query(q);
    for (auto& [op, x, y] : query) {
        cin >> op >> x;
        if (op == 1) {
            --x;
            auto [u, v, w] = edges[x];
            dis[u][v] = dis[v][u] = inf;
        } else {
            cin >> y;
            --x, --y;
        }
    }
    for (int k = 0; k < n; ++k)
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
    vector<LL> ans;
    for (int i = q - 1; i >= 0; --i) {
        auto [op, x, y] = query[i];
        if (op == 1) {
            auto [u, v, w] = edges[x];
            dis[u][v] = dis[v][u] = min(dis[u][v], (LL)w);
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j) {
                    dis[i][j] =
                        min(dis[i][j], dis[i][u] + dis[u][v] + dis[v][j]);
                    dis[i][j] =
                        min(dis[i][j], dis[i][v] + dis[v][u] + dis[u][j]);
                }
        } else {
            ans.push_back((dis[x][y] == inf ? -1 : dis[x][y]));
        }
    }
    reverse(ans.begin(), ans.end());
    for (auto x : ans)
        cout << x << '\n';
 
    return 0;
}
 

---

G - Road Blocked 2 (abc375 G)

题目大意

给定一张无向图，对于每一条边，回答以下询问：

• 删去该边后，$1 \to n$的最短路长度是否发生变化。

解题思路

题意就是问一条边是不是最短路的必经之边，换句话说就是一条边是否被所有最短路径经过。

由于$1 \to n$可能有多条最短路，我们先求出每条边，是否被一条最短路经过。

如果一条边 $u \to v$满足： $1 \to n = 1 \to u \to v \to n$或者 $1 \to n = 1 \to v \to u \to n$，这说明该边被一条最短路径经过。

但怎么说该边被所有的最短路径经过呢？

如果$1 \to n$的最短路径有 $z$条，而 $1 \to u$的最短路径有 $x$条， $v \to n$的最短路径有 $y$条，由乘法原理，$1 \to n$且经过 $u \to v$的路径就有 $xy$条，而如果有$z = xy$，那这就说明该边是必经边。

因此分别从点$1$和点 $n$进行 $dijkstra$，求出 $dis_1[i],dis_n[i]$和 $cnt_1[i],cnt_n[i]$ 表示$1 \to i$的最短路径长度和数量， $n \to i$的最短路径长度和数量，对于任意一条边$u \to v, w$，如果满足二者任意其一：

• $dis_1[u] + w + dis_n[v] == dis_1[n]$ 且$cnt_1[u] \times cnt_n[v] == cnt_1[n]$
• $dis_1[v] + w + dis_n[u] == dis_1[n]$ 且$cnt_1[v] \times cnt_n[u] == cnt_1[n]$

则该边是最短路必经边。

其实根据一条边是否被最短路经过，建立一张最短路图，这些必经边就是所谓的割边，即删去该边后， $1 \to n$不连通。

注意 $cnt$可能会非常大，甚至会超过 $int128$， 而此处我们只需判断乘积是否相等，可以取模。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const LL inf = 1e18;
const int mo = 1e9 + 7;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<vector<array<int, 2>>> edge(n);
    vector<array<int, 3>> e(m);
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        edge[u].push_back({v, w});
        edge[v].push_back({u, w});
        e[i] = {u, v, w};
    }
    auto dijkstra = [&](int s) {
        vector<LL> dis(n, inf);
        vector<LL> cnt(n, 0);
        dis[s] = 0;
        cnt[s] = 1;
        priority_queue<array<LL, 2>, vector<array<LL, 2>>,
                       greater<array<LL, 2>>>
            team;
        team.push({0, s});
        while (!team.empty()) {
            auto [d, u] = team.top();
            team.pop();
            if (dis[u] < d)
                continue;
            for (auto [v, w] : edge[u]) {
                if (dis[v] > dis[u] + w) {
                    dis[v] = dis[u] + w;
                    team.push({dis[v], v});
                    cnt[v] = cnt[u];
                } else if (dis[v] == dis[u] + w) {
                    cnt[v] += cnt[u];
                    if (cnt[v] >= mo)
                        cnt[v] -= mo;
                }
            }
        }
        return make_pair(dis, cnt);
    };
    auto [dis1, cnt1] = dijkstra(0);
    auto [dis2, cnt2] = dijkstra(n - 1);
    vector<int> ans(m, 0);
    for (int i = 0; i < m; ++i) {
        auto& [u, v, w] = e[i];
        if (dis1[u] + w + dis2[v] == dis1[n - 1] &&
                cnt1[u] * cnt2[v] % mo == cnt1[n - 1] ||
            dis1[v] + w + dis2[u] == dis1[n - 1] &&
                cnt1[v] * cnt2[u] % mo == cnt1[n - 1]) {
            cout << "Yes" << '\n';
        } else {
            cout << "No" << '\n';
        }
    }
 
    return 0;
}
 

---