AtCoder Beginner Contest 371

A - Jiro (abc371 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);
    string a, b, c;
    cin >> a >> b >> c;
    array<int, 3> id{};
    iota(id.begin(), id.end(), 0);
    map<pair<int, int>, int> mp;
    mp[{0, 1}] = a[0] == '>';
    mp[{1, 0}] = a[0] == '<';
    mp[{0, 2}] = b[0] == '>';
    mp[{2, 0}] = b[0] == '<';
    mp[{1, 2}] = c[0] == '>';
    mp[{2, 1}] = c[0] == '<';
    sort(id.begin(), id.end(), [&](int x, int y) { return mp[{x, y}]; });
    string ans = "ABC";
    cout << ans[id[1]] << '\n';
 
    return 0;
}
 

---

B - Taro (abc371 B)

题目大意

$n$个家庭，依次出生 $m$个孩子，每个家庭的第一个出生的男婴儿会授予名字 taro。

依次回答每个孩子的名字是不是taro。

解题思路

维护每个家庭是否有男婴儿出生，然后依次判断每个孩子是不是男的，且是第一个男的即可。

神奇的代码

#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, m;
    cin >> n >> m;
    vector<int> tora(n, 0);
    while (m--) {
        int f;
        string s;
        cin >> f >> s;
        --f;
        if (s[0] == 'F' || tora[f]) {
            cout << "No" << '\n';
        } else {
            tora[f] = 1;
            cout << "Yes" << '\n';
        }
    }
 
    return 0;
}
 

---

C - Make Isomorphic (abc371 C)

题目大意

给定两张无向图$G,H$。

给定一个操作代价，在图$H$中给$(i,j)$连一条边或删一条边的花费 $a_{ij}$。

问最小的代价，使得两张图同构。

解题思路

同构即存在一种点标号的映射关系，使得映射后两张图一模一样（包括点标号和对应的边）。

由于点数只有$8$，我们先花 $O(8!)$枚举这个映射（即一个排列），然后看这个映射关系下，使得两张图相等所需要的代价。

计算代价即花$O(n^2)$的时间，枚举所有的边$(i,j), i < j$，如果 $G$存在该边但$H$不存在或$G$不存在但 $H$存在，进行一次操作。 所有的操作代价累加即为该映射关系的操作代价。

所有的映射关系的代价的最小值即为答案。

时间复杂度为$O(n!n^2)$。

神奇的代码

#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;
    array<int, 2> m{};
    array<vector<vector<int>>, 2> edge{vector<vector<int>>(n, vector<int>(n)),
                                       vector<vector<int>>(n, vector<int>(n))};
    for (int k = 0; k < 2; ++k) {
        cin >> m[k];
        for (int i = 0; i < m[k]; ++i) {
            int u, v;
            cin >> u >> v;
            --u, --v;
            edge[k][u][v] = edge[k][v][u] = 1;
        }
    }
    vector<vector<int>> a(n, vector<int>(n, 0));
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j) {
            cin >> a[i][j];
            a[j][i] = a[i][j];
        }
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    int ans = 1e9 + 7;
    auto solve = [&](vector<int> id) {
        int res = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (edge[0][id[i]][id[j]] != edge[1][i][j]) {
                    res += a[i][j];
                }
            }
        }
        return res;
    };
    do {
        ans = min(ans, solve(id));
    } while (next_permutation(id.begin(), id.end()));
 
    cout << ans << '\n';
 
    return 0;
}
 

---

D - 1D Country (abc371 D)

题目大意

一维数轴，给定$n$个村落的位置和人口。

$q$个询问，每个询问给定 $l,r$，问位于$l,r$之间的村落人口数量。

解题思路

题意给的村落位置本身有序。

直接维护关于村落的人口前缀和。

对于每个询问，二分找到位于$l,r$区间的村落的左右端点，然后通过前缀和求得这期间的人口数量。

时间复杂度是$O(q\log 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);
    int n;
    cin >> n;
    vector<int> x(n);
    for (auto& i : x)
        cin >> i;
    vector<LL> p(n);
    for (auto& i : p)
        cin >> i;
    vector<LL> presum(n);
    partial_sum(p.begin(), p.end(), presum.begin());
    auto get_sum = [&](int l, int r) {
        if (l > r)
            return 0ll;
        return presum[r] - (l ? presum[l - 1] : 0);
    };
    int q;
    cin >> q;
    while (q--) {
        int l, r;
        cin >> l >> r;
        auto L = lower_bound(x.begin(), x.end(), l) - x.begin();
        auto R = upper_bound(x.begin(), x.end(), r) - x.begin();
        cout << get_sum(L, R - 1) << '\n';
    }
 
    return 0;
}
 

---

E - I Hate Sigma Problems (abc371 E)

题目大意

给定$n$个数 $a$，定义 $f(l,r)$表示区间 $[l,r]$的数的种类。

求 $\sum_{i=1}^{n}\sum_{j=i}^{n} f(i,j)$

解题思路

考虑枚举$j$的话会发现不太可行，考虑直接的一个排列 $1,2,3,4,5...$，对于每个 $j$，每个$i$都对应了一个不同的$f(i,j)$ ，感觉无法合并。

考虑答案的来源，即贡献的来源，是每一个数。比如$2,3,2,5$， $f(2,3) = 2 = 1 + 1$， $3,2$分别对答案有 $1$的贡献。而 $f(1,3) = 2 = 1 + 1$，这里同样是 $3,2$对答案有 $1$的贡献，但这里有两个 $2$，只有其中的一个才有 $1$的贡献，我们可以规定最右边的 $2$有 $1$的贡献。

我们的视角从 求$f(l,r)$的值 变成了求 每一个数 $a_i$ 在多少个区间 $(l,r)$有 $1$的贡献。

很显然，这个$l$的取值是 $[1,l]$， 而$r$的取值要满足 $[i,r]$没有另一个 $a_i$，即计 $nxt_i$表示下一个 $a_i$的位置，那么 $r$的取值就是 $[i,nxt_i)$。因此对于一个$a_i$，它有贡献的区间数量即为 $i \times (nxt_i - i)$ 。所有的$a_i$累加即为答案。

而 $nxt_i$的求法就倒序扫一遍，维护 $last_i$表示上一个数 $i$出现的位置即可。

即答案就是 $\sum_{i=1}^{n} i(nxt_i - i)$，时间复杂度是$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);
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& i : a) {
        cin >> i;
        --i;
    }
    vector<int> r(n);
    vector<int> pos(n, n);
    for (int i = n - 1; i >= 0; --i) {
        r[i] = pos[a[i]];
        pos[a[i]] = i;
    }
    fill(pos.begin(), pos.end(), 0);
    LL ans = 0;
    for (int i = 0; i < n; ++i) {
        int lcnt = i + 1;
        int rcnt = r[i] - i;
        ans += 1ll * lcnt * rcnt;
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

F - Takahashi in Narrow Road (abc371 F)

题目大意

一维数轴，$n$个人，依次完成以下 $q$个目标。

对于第 $i$个目标，让第 $t_i$个人移动到 $q_i$位置。

每次操作，可以让一个人向左右移动一格，如果目标位置有人则不能移动，得让对方先移动。

求完成所有目标所需要的最小操作次数。

解题思路

直接模拟整个过程即可。

考虑一个人的移动，移动过程中会推着其他人一起移动，我们就将这些人合并成一个块一起移动。

而这个人一开始移动时，它可能会从块里分离出来，那我们就从这个块里分离出来，然后移动。

每次移动当然不是一格一格移动，而是直接移动到终点，或者中间碰到了别人，合并成一个新的块。

这样做，考虑其复杂度，每次操作只会新增一个块，然后会合并若干个块。整个过程只会产生$O(q)$个块，每个块只会合并一次，单次移动的复杂度是 $O(\log n)$的话，整个模拟过程的时间复杂度就是 $O((n+q)\log n)$。

如何模拟一堆堆的块呢？其实就是一棵珂朵莉树，其实就是一个$set$维护 每个块的信息，能分离一个块，移动块时找到下一个块的位置，判断能否合并即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
struct Block {
    int l, r, id; // pos -> [l,r] people -> [id, id + r - l + 1]
    bool operator<(const Block& b) const { return id < b.id; }
    inline int cnt() const { return r - l + 1; }
    inline int lid() const { return id; }
    inline int rid() const { return id + cnt() - 1; }
    bool intersect(const Block& b, int is_right) const {
        if (is_right)
            return r >= b.l;
        else
            return l <= b.r;
    }
    pair<Block, Block> cut(int t) const {
        int cnt = t - id;
        return {{l, l + cnt - 1, id}, {l + cnt, r, id + cnt}};
    }
    Block shift(int dis) const {
        auto ret = *this;
        ret.l += dis;
        ret.r += dis;
        return ret;
    }
    Block merge(const Block& b) const {
        assert(r + 1 == b.l || b.r + 1 == l);
        return {min(l, b.l), max(r, b.r), min(id, b.id)};
    }
};
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    set<Block> p;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        p.insert({x, x, i});
    }
    auto get_block = [&](int t) {
        auto it = prev(p.upper_bound({0, 0, t}));
        return it;
    };
    auto get_pos = [&](int t) {
        auto it = get_block(t);
        int ret = it->l + t - it->id;
        return ret;
    };
    auto shift_block = [&](int t, int g) {
        auto it = *get_block(t);
        auto dis = g - get_pos(t);
        it.l += dis;
        it.r += dis;
        return it;
    };
    auto solve = [&](int t, int g) {
        LL sum = 0;
        while (true) {
            int pos = get_pos(t);
            if (pos == g)
                break;
            auto it = get_block(t);
            if (pos < g) {
                if (it->lid() != t) {
                    auto [lblock, rblock] = it->cut(t);
                    p.erase(it);
                    p.insert(lblock);
                    p.insert(rblock);
                } else {
                    auto sit = shift_block(t, g);
                    auto nit = next(it);
                    if (nit == p.end() || !sit.intersect(*nit, true)) {
                        sum += 1ll * it->cnt() * (g - pos);
                        p.erase(it);
                        p.insert(sit);
                    } else {
                        auto shift = nit->l - it->r - 1;
                        sum += 1ll * sit.cnt() * shift;
                        sit = it->shift(shift);
                        auto nblock = sit.merge(*nit);
                        auto tmp = *nit;
                        p.erase(it);
                        p.erase(tmp);
                        p.insert(nblock);
                    }
                }
            } else {
                if (it->rid() != t) {
                    auto [lblock, rblock] = it->cut(t + 1);
                    p.erase(it);
                    p.insert(lblock);
                    p.insert(rblock);
                } else {
                    auto sit = shift_block(t, g);
                    if (it == p.begin() || !sit.intersect(*prev(it), false)) {
                        sum += 1ll * sit.cnt() * (pos - g);
                        p.erase(it);
                        p.insert(sit);
                    } else {
                        auto pit = prev(it);
                        auto shift = it->l - pit->r - 1;
                        sum += 1ll * sit.cnt() * shift;
                        sit = it->shift(-shift);
                        auto nblock = sit.merge(*pit);
                        auto tmp = *pit;
                        p.erase(it);
                        p.erase(tmp);
                        p.insert(nblock);
                    }
                }
            }
        }
        return sum;
    };
    int q;
    cin >> q;
    LL ans = 0;
    while (q--) {
        int t, g;
        cin >> t >> g;
        --t;
        LL ret = solve(t, g);
        ans += ret;
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

G - Lexicographically Smallest Permutation (abc371 G)

题目大意

给定两个排列$p,a$。

可进行一种操作任意次，即令 $a_i = a_{p_i}$。

问得到的 $a$的字典序的最小值。

解题思路

替换操作可以看成是有若干个环的图，有连边$i \to p_i$。

问题就是求一个 $x$，使得每个点往前走 $x$步，得到的新的数组的字典序最小。

由字典序的比较顺序，首先是让第一个数最小。

那就找第一个数所在的环，遍历一遍，找到数最小的位置，得到一个偏移量 $b$。记该环的大小为$a$。

这样，只要我们最后的偏移量 $x$满足 $x \equiv b (\mod a)$，这样第一个位置就是最小的情况。

然后考虑下一个数所在的环（如果和$1$在同一个环，就忽略，继续找下一个不在之前考虑的环），在该环中，我们同样要找最小的值，但和之前直接遍历环的每个元素不同，由于之前有个限制$x \equiv b (\mod a)$，因此在该环里，我们只能看第$x$个点，第 $x + a$个点，第 $x + 2a$个点，...，这哪个点权最小（要保持不破坏之前考虑的环的偏移量）。

假设在有限个点，我们找到数最小的位置 $B$，即该环的大小为 $A$，那就是说，我们最终的偏移量 $x$要满足两个同余等式： $x \equiv b (\mod a)$和$x \equiv B (\mod A)$，通过扩展中国剩余定理可以将其合并成一个等价的同余式$x \equiv b_0 (\mod a_0)$。

然后就继续遍历剩下的环，不断合并同余式，最后偏移量就是$b_0 \% a_0$。

据官方题解，$a,b$的值会超$2^{2367}$，因此下面的$c++$代码尽管开了 __in128仍会爆。

c++代码

#include <bits/stdc++.h>
using namespace std;
using LL = __int128;
 
LL x, y, d;
 
void exgcd(LL& x, LL& y, LL a, LL b) {
    if (!b)
        d = a, x = 1, y = 0;
    else
        exgcd(y, x, b, a % b), y -= a / b * x;
}
 
LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; }
 
LL lcm(LL a, LL b) { return a / gcd(a, b) * b; }
 
LL a, b, A, B;
 
void merge() {
    exgcd(x, y, a, A);
    LL c = B - b;
    assert(c % d == 0);
    x = x * c / d % (A / d);
    if (x < 0)
        x += A / d;
    LL mod = lcm(a, A);
    b = (a * x + b) % mod;
    if (b < 0)
        b += mod;
    a = mod;
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<int> p(n), v(n);
    for (auto& i : p) {
        cin >> i;
        --i;
    }
    for (auto& i : v)
        cin >> i;
    vector<vector<int>> cir;
    vector<int> vis(n);
    for (int i = 0; i < n; ++i) {
        if (vis[i])
            continue;
        vector<int> h{i};
        for (int j = p[i]; j != i; j = p[j]) {
            vis[j] = 1;
            h.push_back(j);
        }
        cir.push_back(h);
    }
    a = 1;
    b = 0;
    for (int i = 0; i < cir.size(); ++i) {
        auto& h = cir[i];
        int id = b % h.size();
        vector<int> used(h.size(), 0);
        for (int i = id;; i = (i + a) % h.size()) {
            if (used[i])
                break;
            used[i] = 1;
            if (v[h[i]] < v[h[id]])
                id = i;
        }
        A = h.size();
        B = id;
        if (i > 0)
            merge();
        else
            a = A, b = B;
    }
    LL step = b % a;
    vector<int> ans(n);
    for (auto& h : cir) {
        for (int i = 0, j = step % h.size(); i < h.size();
             i++, j = (j + 1) % h.size()) {
            ans[h[i]] = v[h[j]];
        }
    }
    for (int i = 0; i < n; ++i) {
        cout << ans[i] << " \n"[i == n - 1];
    }
 
    return 0;
}
 

怎么办呢，用chatgpt改成pythonb吧jls的代码貌似没用高精，研究研究

python代码

# 扩展欧几里得算法
def exgcd(a, b):
    if b == 0:
        return a, 1, 0
    d, x1, y1 = exgcd(b, a % b)
    x = y1
    y = x1 - (a // b) * y1
    return d, x, y
 
# 求最大公约数
def gcd(a, b):
    return a if b == 0 else gcd(b, a % b)
 
# 求最小公倍数
def lcm(a, b):
    return a // gcd(a, b) * b
 
# 初始化全局变量
x, y, d = 0, 0, 0
a, b, A, B = 0, 0, 0, 0
 
# 合并两个同余方程
def merge():
    global a, b, A, B, x, y, d
    d, x, y = exgcd(a, A)
    c = B - b
    assert c % d == 0
    x = (x * (c // d)) % (A // d)
    if x < 0:
        x += A // d
    mod = lcm(a, A)
    b = (a * x + b) % mod
    if b < 0:
        b += mod
    a = mod
 
def main():
    n = int(input())
    p = [int(i) - 1 for i in input().split()]
    v = list(map(int, input().split()))
 
    # 寻找环
    cir = []
    vis = [0] * n
    for i in range(n):
        if vis[i]:
            continue
        h = [i]
        vis[i] = 1
        j = p[i]
        while j != i:
            vis[j] = 1
            h.append(j)
            j = p[j]
        cir.append(h)
 
    global a, b, A, B
    a, b = 1, 0
    for i, h in enumerate(cir):
        id = b % len(h)
        used = [0] * len(h)
        j = id
        while not used[j]:
            used[j] = 1
            if v[h[j]] < v[h[id]]:
                id = j
            j = (j + a) % len(h)
        A = len(h)
        B = id
        if i > 0:
            merge()
        else:
            a, b = A, B
 
    step = b % a
    ans = [0] * n
    for h in cir:
        for i in range(len(h)):
            j = (step + i) % len(h)
            ans[h[i]] = v[h[j]]
 
    print(" ".join(map(str, ans)))
 
if __name__ == "__main__":
    main()
 
 

---