至今头条

AtCoder Beginner Contest 365

2024-08-04 00:01 由 ~Lanly~ 发表于 #其他

A - Leap Year (abc365 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 a;
    cin >> a;
    int day = 365;
    if (a % 400 == 0 || (a % 4 == 0 && a % 100 != 0)) {
        day = 366;
    }
    cout << day << '\n';

    return 0;
}

B - Second Best (abc365 B)

题目大意

给定\(n\)个不同的数，问第二大的数的下标。

解题思路

对这\(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& x : a)
        cin >> x;
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    sort(id.begin(), id.end(), [&](int i, int j) { return a[i] < a[j]; });
    cout << id[n - 2] + 1 << '\n';

    return 0;
}

C - Transportation Expenses (abc365 C)

题目大意

给定\(n\)个人的交通费用\(a_i\)，确定最大补贴额度 \(x\)，使得给每个人的补贴为 \(\min(x, a_i)\)， 总补贴额度不超过\(m\)。

解题思路

很显然，\(x\)越高，总补贴额度越高，\(x\)越低 ，则补贴额度就越低，两者呈单调性。

因此可以二分\(x\)，然后计算补贴额度。计算补贴额度就直接\(for\)循环，求一遍 \(\sum \min(x, 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;
    LL m;
    cin >> n >> m;
    vector<LL> a(n);
    for (auto& i : a)
        cin >> i;
    LL l = 0, r = m + 1;
    if (accumulate(a.begin(), a.end(), 0LL) <= m) {
        cout << "infinite" << '\n';
    } else {
        auto check = [&](LL x) {
            LL sum = 0;
            for (auto i : a)
                sum += min(i, x);
            return sum <= m;
        };
        while (l + 1 < r) {
            LL mid = (l + r) / 2;
            if (check(mid))
                l = mid;
            else
                r = mid;
        }
        cout << l << '\n';
    }

    return 0;
}

以下代码不是二分，先假定\(x\)的取值是 \(a_i\)之中，对 \(a_i\)从小到大遍历，找到最大的，总补贴度不超过 \(m\)的 \(a_i\)，但真正的\(x\)不一定在 \(a_i\)之中，因为此时还有一些多余的钱，还可以分给每个人，只是达不到\(a_{i+1}\)，因此剩余钱再均分给剩余人，得到真正的 \(x\)。

神奇的代码 
#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;
    LL m;
    cin >> n >> m;
    vector<int> a(n);
    for (auto& x : a)
        cin >> x;
    sort(a.begin(), a.end());
    LL tot = accumulate(a.begin(), a.end(), 0LL);
    if (tot <= m) {
        cout << "infinite" << '\n';
    } else {
        int id = -1;
        LL remain = 0;
        LL presum = 0;
        for (int i = 0; i < n; ++i) {
            LL sum = presum + 1ll * a[i] * (n - i);
            if (sum <= m) {
                id = i;
                remain = m - sum;
            }
            presum += a[i];
        }
        LL ans = m / n;
        if (id != -1) {
            ans = a[id] + remain / (n - id - 1);
        }
        cout << ans << '\n';
    }

    return 0;
}

D - AtCoder Janken 3 (abc365 D)

题目大意

剪刀石头布。

给定青木\(n\)局的操作，要求确定高桥对应的操作，要求：

  • 每一局高桥要么赢，要么平手。
  • 高桥不能连续两局出同样的手势。

最大化高桥赢的局数。

解题思路

考虑某一局高桥能做出的手势，取决于两个

  • 青木此局的手势，决定了高桥不能输
  • 高桥上一局的手势，确保不会连续两局出同样的手势

由此，为了能够作出决策，我们仅需知道第\(i\)局和上一局出的手势 \(j\)即可。

设 \(dp[i][j]\)表示考虑前 \(i\)局， 第\(i\)局高桥的手势是 \(j\)，高桥赢的局数的最大值。

转移则考虑高桥当前是赢还是平手（手势不与上一局相同 ），从\(dp[i-1][*]\)转移过来即可。

神奇的代码 
#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;
    string s;
    cin >> n >> s;
    map<char, int> tr{{'R', 0},
                      {'P', 1},
                      {'S', 2}};
    string t = "PSR";
    array<int, 3> dp{0, 0, 0};
    for (auto& c : s) {
        array<int, 3> dp2{-inf, -inf, -inf};
        int pid = tr[c];
        char hashi = t[pid];
        int id = tr[hashi];
        for (int i = 0; i < 3; i++) {
            if (i != id)
                dp2[id] = max(dp2[id], dp[i] + 1);
            if (i != pid)
                dp2[pid] = max(dp2[pid], dp[i]);
        }
        dp2.swap(dp);
    }
    int ans = *max_element(dp.begin(), dp.end());
    cout << ans << '\n';

    return 0;
}

E - Xor Sigma Problem (abc365 E)

题目大意

给定\(n\)个数 \(a_i\)，求\(\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} a_i \oplus a_{i+1} \oplus ... \oplus a_j\)

\(\oplus\)是异或操作。

解题思路

朴素做法显而易见的\(O(n^2)\)。

由于异或操作下，二进制下每一位是相互独立的，因此我们可以考虑每一位的贡献。即考虑\(2^0,2^1,2^2,...,2^31\)在这 \(O(n^2)\)个异或表达式结果中出现的次数。

\(\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} a_i \oplus a_{i+1} \oplus ... \oplus a_j = \sum_{i=0}^{31} 2^i cnt_i\)

考虑如何求\(cnt_i\)。

单独考虑每个数二进制下的第\(k\)位，如果 \(2^k\)在一个\(a_i \oplus ... \oplus a_j\)出现过，则这说明这些数的二进制下，第\(k\)位是 \(1\)的次数是奇数。

因此对于 \(k\)，我们求 \(odd_i\)表示 \(a_i\)在二进制下的第 \(k\)位是不是 \(1\)。然后考虑有多少个区间\(odd\)和是奇数。

区间异或和区间加法一样，可以表示成两个前缀和相减。因此求\(odd_i\)的前缀和 \(presum_i = odd_1 \oplus odd_2 \oplus ... \oplus odd_i\) ，则\(odd_i \oplus odd_{i+1} \oplus ... \oplus odd_j = presum_j \oplus presum_{i-1}\)。

因此我们要求有多少对 \((i,j)\)，满足 \(presum_{j} \oplus presum_{i-1} = 1\)，我们可以枚举\(j\)，然后对应的 \(i\)的数量。

  • 如果 \(presum_j = 1\)，则 \(presum_{i-1} = 0\)
  • 如果 \(presum_j = 0\)，则 \(presum_{i-1} = 1\)
    因此我们只需在从小到大枚举\(j\)时， 实时维护\(presum_i = 0\)和 \(presum_i = 1\)的数量， 然后根据\(presum_j\)的取值，就知道对应的 \(i\)的数量。

得到\((i,j)\)对数\(cnt_k\)后，就得到对于当前的 \(k\)，其对答案的贡献就是 \(2^k cnt_k\)。对所有的 \(k\)累计求和即为答案。

注意上述的求法包括了 \(j = i\)的情况，而题意是 \(j > 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;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a)
        cin >> x;
    LL ans = 0;
    auto solve = [&](int bit) {
        vector<int> odd(n);
        for (int i = 0; i < n; ++i) {
            odd[i] = (a[i] >> bit) & 1;
        }
        for (int i = 1; i < n; ++i) {
            odd[i] = odd[i] ^ odd[i - 1];
        }
        map<int, int> cnt;
        cnt[0] = 1;
        LL sum = 0;
        for (int i = 0; i < n; ++i) {
            sum += cnt[odd[i] ^ 1];
            cnt[odd[i]]++;
        }
        return sum;
    };
    for (int i = 0; i < 32; ++i) {
        ans += (1ll << i) * solve(i);
    }
    ans -= accumulate(a.begin(), a.end(), 0ll);
    cout << ans << '\n';

    return 0;
}

F - Takahashi on Grid (abc365 F)

题目大意

二维网格，\(n \times m\)，每一列有一个连续的空间是空地。每一列的空地必定相交。

回答\(q\)个问题。

每个问题，给定起点终点，每次可以上下左右走一格，问移动的最小步数。

解题思路

显而易见的朴素做法的时间复杂度为\(O(nq)\)，即对于每个询问，从\(sx \to sx+1 \to sx+2 \to ... \to tx\)，一列一列移动。

考虑移动过程，其实就两个阶段：

  • 第一阶段，能够直接平行移动，即 \((x, y) \to (x, y + 1)\)
  • 第二阶段，不能平行移动了，得上下移动，这时一定有\((x, y) \to (l[x+1], y)\) 或\((r[x+1], y)\)。即抵达下一列的上下两个端点，然后往右边继续移动。

然后这两阶段不断重复。

对于第一阶段，可以通过预处理，在 \(O(\log n)\)的时间内找到平行移动到最右边的边界，即此时会有 \(y < l[x + 1]\)或 \(y > r[x + 1]\) ，因此用\(st\)表预处理 \(lmax[i,j]\)表示列 \([i,j]\)的 \(l\)的最大值， \(rmin[i,j]\)表示列 \([i,j]\)的\(r\)的最小值 ，通过二分可以找到这个平行移动的边界列。

然后是第二阶段，注意到第二阶段的开始起点只有\(2n\)个：每列要么是从上端点开始，要么从下端点开始。因此我们可以预处理出，从每个这样的起点出发，到达每一列的代价之类的东西。

具体是怎样的东西呢？注意到从这些端点出发，其实后续的路线就是固定了，所以可以用倍增的方法，预处理出从每个端点出发，走\(2^i\)步后，抵达到哪个列的上端点或下端点，代价是多少。

这里的一步指的是必须变动\(y\)的，即经过一次第二阶段，即，如果从\((x,y)\)能平行移动则一直平行移动，直到要上下移动才能抵达下一列\(s\)，这样就称之为一步，从\(x \to s\)， \(y \to l[s]\)或 \(y \to r[s]\)。

定义了一步后，就可以预处理倍增数组\(run[i][x][0/1]\)表示从 第 \(x\)行的上/下端点，走 \(i\)步后抵达的 (列，上/下端点，移动次数)这么个三元组。

然后对于每个询问，通过二分求出第一阶段移动的移动次数，此时抵达到第二阶段的一个起点，再通过倍增数组得到移动到 \((tx, ty)\)的移动次数。这里可能不能直接到\((tx, ty)\)，可能最后再通过第一阶段的平行移动到 \(tx\)，再上下移动到 \(ty\)，加个判断即可。

神奇的代码 
#include <bits/stdc++.h>
using namespace std;
using LL = long long;

// usage:
//   auto fun = [&](int i, int j) { return min(i, j); };
//   SparseTable<int, decltype(fun)> st(a, fun);
// or:
//   SparseTable<int> st(a, [&](int i, int j) { return min(i, j); });
template <typename T, class F = function<T(const T&, const T&)>>
class SparseTable {
  public:
    int n;
    vector<vector<T>> mat;
    F func;

    SparseTable(const vector<T>& a, const F& f) : func(f) {
        n = static_cast<int>(a.size());
        int max_log = 32 - __builtin_clz(n);
        mat.resize(max_log);
        mat[0] = a;
        for (int j = 1; j < max_log; j++) {
            mat[j].resize(n - (1 << j) + 1);
            for (int i = 0; i <= n - (1 << j); i++) {
                mat[j][i] = func(mat[j - 1][i], mat[j - 1][i + (1 << (j - 1))]);
            }
        }
    }

    T get(int from, int to) const { // [from, to]
        assert(0 <= from && from <= to && to <= n - 1);
        int lg = 32 - __builtin_clz(to - from + 1) - 1;
        return func(mat[lg][from], mat[lg][to - (1 << lg) + 1]);
    }
};

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<int> l(n), r(n);
    for (int i = 0; i < n; i++)
        cin >> l[i] >> r[i];
    vector<vector<vector<array<LL, 3>>>> run(
        31, vector<vector<array<LL, 3>>>(
                n, vector<array<LL, 3>>(2, array<LL, 3>{})));
    SparseTable<int> L(l, [&](int i, int j) { return max(i, j); });
    SparseTable<int> R(r, [&](int i, int j) { return min(i, j); });
    auto step = [&](int x, int y) {
        int l = x, r = n;
        while (l + 1 < r) {
            int m = (l + r) / 2;
            if (L.get(x, m) <= y && R.get(x, m) >= y) {
                l = m;
            } else {
                r = m;
            }
        }
        return l + 1;
    };
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < 2; ++j) {
            int x = i, y = (j ? r[i] : l[i]);
            int nxt = step(x, y);
            if (nxt == n) {
                run[0][i][j] = {n, 0, n - i};
            } else if (l[nxt] > y) {
                run[0][i][j] = {nxt, 0, l[nxt] - y + nxt - i};
            } else {
                run[0][i][j] = {nxt, 1, y - r[nxt] + nxt - i};
            }
        }
    }

    for (int i = 1; i <= 30; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < 2; ++k) {
                auto [nxt, d, cost] = run[i - 1][j][k];
                if (nxt == n) {
                    run[i][j][k] = {n, 0, cost};
                } else {
                    auto [nnxt, dd, ccost] = run[i - 1][nxt][d];
                    run[i][j][k] = {nnxt, dd, cost + ccost};
                }
            }
        }
    }

    auto solve = [&](int sx, int sy, int tx, int ty) -> LL {
        if (sx == tx) {
            return abs(ty - sy);
        }
        if (sx > tx) {
            swap(sx, tx);
            swap(sy, ty);
        }
        int nxt = step(sx, sy);
        if (nxt > tx) {
            return abs(ty - sy) + tx - sx;
        }
        int sign = (sy < l[nxt] ? 0 : 1);
        LL ret = nxt - sx + (sign ? sy - r[nxt] : l[nxt] - sy);
        sx = nxt;
        for (int i = 30; i >= 0; --i) {
            auto [nnxt, dd, ccost] = run[i][sx][sign];
            if (nnxt <= tx) {
                ret += ccost;
                sx = nnxt;
                sign = dd;
            }
        }
        ret += tx - sx + (sign ? abs(ty - r[sx]) : abs(l[sx] - ty));
        return ret;
    };

    int q;
    cin >> q;
    while (q--) {
        int sx, sy, tx, ty;
        cin >> sx >> sy >> tx >> ty;
        --sx, --tx;
        LL ans = solve(sx, sy, tx, ty);
        cout << ans << '\n';
    }

    return 0;
}

G - AtCoder Office (abc365 G)

题目大意

给定\(n\)个员工在公司的若干条时间段，回答 \(q\)个问题。

每个问题，询问两个员工 \(i,j\)同时在公司的时间。

解题思路

<++>

神奇的代码

热门相关：女配她逆袭了   隐婚101天：唐少宠妻成瘾   我真不是开玩笑   永恒王权   史上最强赘婿