AtCoder Beginner Contest 353

pystraf

已于 2024-05-19 21:08:43 修改

阅读量279

点赞数 3

分类专栏： AtCoder 文章标签：算法数据结构 c++ AtCoder

于 2024-05-12 21:53:08 首次发布

本文链接：https://blog.csdn.net/sblsf/article/details/138766791

版权

AtCoder 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

前面两道阅读理解直接跳过。

C - Sigma Problem

大意

有一函数 $f(x,y)=(x+y) \mod10^8$ 。

给定长度为 $n$ 的序列 $a$ ，求 $\sum_{i=1}^{n-1}\sum_{j=i+1}^n f(a_i,a_j)$ 。

思路

我们将 $f$ 变一下：

$f(x, y) = \begin{cases} x + y, & \text{if $x + y < 10^8$ } \\ x + y - 10^8, & \text{otherwise} \end{cases}$

那么可以先算出 $\sum_{i=1}^{n-1}\sum_{j=i+1}^n a_i + a_j$ ，再减去满足以下条件的数对 $(i,j)$ 个数 $\times 10^8$ ：

$1\le i \le j \le n$
$a_i+a_j\ge 10^8$

考虑求前式，由于每项都相加 $n-1$ 次，所以可以改写为 $(n-1)\sum_{i=1}^{n}a_i$ ，用 $O(n)$ 求。

接下来，求 $a_i+a_j \ge 10^8$ 的整数对 $(i,j)$ 的个数。

将 $a$ 从小到大排序，我们可以发现，随着 $i$ 的增大，满足 $a_i+a_j \ge 10^8$ 的 $j$ 最小值是单调递减的，可以用双指针（放缩法）求得。注意在 $a_i=5\times 10^7$ 的情况下不能重复计算。

代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int mod = 1e8;
#define int long long

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;

    vector<int> a(n);
    for (auto &i: a) cin >> i;
    sort(a.begin(), a.end());

    int ans = 0, cnt = 0, r = n;
    for (int i = 0; i < n; i++){
        ans += a[i] * (n - 1);
        r = max(r, i + 1);
        while(r - 1 > i && a[r - 1] + a[i] >= mod) r--;
        cnt += n - r;
    }
    ans -= cnt * mod;
    cout << ans << endl;
    
    return 0;
}

D - Another Sigma Problem

大意

定义 $f(x,y)$ 表示把 $y$ 直接拼接到 $x$ 后面所形成的整数。

给定长度为 $n$ 的序列 $a$ ，求 $\sum_{i=1}^{n-1}\sum_{j=i+1}^n f(a_i,a_j)$ 。

思路

设 $\operatorname{len}(x)$ 为 $x$ 的位数，则可以式子变形为 $f(x,y)=x\times 10^{\operatorname{len}(y)} + y$ .

将每个数 $a_i$ 的贡献拆成两个部分计算： $f(*,a_i)$ ， $f(a_i,*)$ 。

前者很容易，因为 $a_i$ 被原封不动地加了 $n-1$ 次，因此对答案的贡献为 $(i-1)a_i$ 。

接着考虑后者，可以使用后缀和，设 $d_x$ 表示 $a_i \to a_n$ 中 $x$ 位数的个数，那么对答案的贡献为 $\sum_{k=1}^{10}d_k\times 10^k \times a_i$ 。

代码

#include <iostream>
#include <vector>
#include <string>
#include "atcoder/modint"
using namespace std;

typedef atcoder::modint998244353 Z;

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;

    vector<int> a(n), d(11);
    
    auto len = [&](int x){
        return to_string(x).size();
    };

    for(auto &i: a){
        cin >> i;
        d[len(i)]++;
    }

    Z ans = 0;
    vector<Z> xp(11, 1);
    for(int i = 1; i <= 10; i++) xp[i] = xp[i - 1] * 10;

    for(int i = 0; i < n; i++){
        ans += Z(a[i]) * i;
        d[len(a[i])]--;
        for(int j = 1; j <= 10; j++) ans += xp[j] * a[i] * d[j];
    }
    cout << ans.val() << endl;
    return 0;
}

E - Yet Another Sigma Problem

大意

定义 $f(x,y)$ 表示字符串 $x$ 和字符串 $y$ 的最长公共前缀的长度。

给定 $n$ 个字符串 $s=(s_1,s_2,\cdots,s_n)$ ，求 $\sum_{i=1}^{n-1}\sum_{j=i+1}^n f(s_i,s_j)$ 。

思路

看到LCP想Trie树，因为它会把所有具有相同前缀的字符串合并。

我们依次将每个字符串插入Trie树，每个节点都保留了以它所代表的字符串为前缀的字符串的数量信息。

因此在到达每个节点后，答案都加上 $cnt_p$ 。

最后输出答案即可。

代码

#include <iostream>
#include <array>
#include <vector>
using namespace std;

#define int long long

struct trie {
    using M = array<int, 26>;
    vector<M> son;
    M init;
    int size, ans;
    vector<int> cnt;

    trie() = default;
    trie(int len) {
        son.reserve(len + 1);
        cnt.reserve(len + 1);
        init.fill(-1);
        size = ans = 0;
        newnode();
    }

    int newnode() {
        son.push_back(init);
        cnt.push_back(0);
        return size++;
    }

    void insert(string &s) {
        int p = 0;
        for(int i = 0; i < s.size(); i++) {
            int u = s[i] - 'a';
            int &nx = son[p][u];
            if(nx == -1) nx = newnode();
            p = nx;
            ans += cnt[p]++;
        }
    }

};

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;
    trie T(3e5);
    for(int i = 0; i < n; i++) {
        string s;
        cin >> s;
        T.insert(s);
    }
    cout << T.ans << endl;
    return 0;
}

F - Tile Distance

大意

给定 $k$ ，其定义了一个网格：

其中 $S$ 表示 $1 \times 1$ 的小格子， $L$ 表示 $k \times k$ 的大格子。

从一个格子走到另一个格子的代价是 $1$ 。

给定起点 $(sx,sy)$ 和终点 $(tx,ty)$ ，问从起点到终点的最小代价。

思路

显然，最多只能走 $|sx-tx|+|sy-ty|$ 步，易知这是 $k=1$ 时的答案。

接下来看 $k \ge 2$ 的情况。

我们可以知道，如果想要更优的方案，那么需要穿过大格子，否则代价就是上限。

考虑对实现答案的移动中到达的第一对大格子和最后一对大格子进行枚举。

可能到达的第一对大格子为：

如果起点处于大格子，那么就是它。
否则，四周的大格子都有可能。

最后一对同理。

我们分别计算出起终点绕到上述大格子的距离。

剩下的，只需求得在大格子上移动的费用即可。

这就完了吗？并没有。

我们看 $k=2$ 的情况，发现有时不用绕，直接穿过反而代价更小。

特判一下即可。

代码

#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
typedef unsigned long long ULL;
typedef tuple<ULL, ULL, ULL> P;

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    ULL k, sx, sy, tx, ty;
    cin >> k >> sx >> sy >> tx >> ty;

    sx += k, sy += k;
    tx += k, ty += k;

    auto diff = [&](ULL p, ULL q) -> ULL{
        return max(p, q) - min(p, q);
    };

    auto getpos = [&](ULL x, ULL y) -> vector<P> {
        vector<P> pos;
        if(((x / k) ^ (y / k)) & 1)
            pos.emplace_back(x / k, y / k, 0);
        else{
            pos.emplace_back(x / k - 1, y / k, 1 + x % k); // 左
            pos.emplace_back(x / k + 1, y / k, k - x % k); // 右
            pos.emplace_back(x / k, y / k - 1, 1 + y % k); // 下
            pos.emplace_back(x / k, y / k + 1, k - y % k); // 上
        }
        return pos;
    };

    ULL ans = diff(sx, tx) + diff(sy, ty);

    if(1 < k){
        vector<P> start = getpos(sx, sy);
        vector<P> goal = getpos(tx, ty);
        if(k == 2){
            for(auto& [x, y, d1] : start)
                for(auto& [z, w, d2] : goal){
                    ULL x_diff = diff(x, z);
                    ULL y_diff = diff(y, w);
                    ans = min(ans, d1 + d2 + x_diff + y_diff + diff(x_diff, y_diff) / 2);
                }
        }else{
            for(auto& [x, y, d1] : start)
                for(auto& [z, w, d2] : goal)
                    ans = min(ans, d1 + d2 + diff(x + y, z + w) + diff(x + w, z + y));
        }
    }
    cout << ans << endl;
    return 0;
}