1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Codeforces Template Version 0.1
template <typename... Args>
tuple<Args...> read() {
    tuple<Args...> values;
    apply([&](auto&... args) {
        (cin >> ... >> args);
    },values);
    return values;
}

template <typename T>
vector<T> read_vec(size_t n, bool index_from_one = false) {
    vector<T> vec(n + index_from_one);
    for (auto i = index_from_one * 1; i < n + index_from_one; i ++)
        cin >> vec[i];
    return vec;
}

template <typename T>
set<T> read_set(size_t n) {
    set<T> values;
    for (int i = 0; i < n; i ++) {
        T value;
        cin >> value;
        values.insert(value);
    }
    return values;
}

using i64 = long long;
constexpr i64 zero = 0ll;
constexpr i64 inf = 1e18; 
// Template End

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

void solve() {
    auto [n] = read<int>();
    auto a = read_vec<int>(n, true);
    auto b = read_vec<int>(n);
    b.emplace_back(0);

    cout << accumulate(
        ranges::views::zip(a, b).begin() + 1,
        ranges::views::zip(a, b).end(),
        0,
        [&](int acc, const auto& pair) {
            auto [x, y] = pair;
            return acc + max(x - y, 0);
        }
    ) << "\n";
}

1
2
3
4
5
6

void solve() {
    auto [n, a, b, c] = read<int, int, int, int>();
    auto sum = a + b + c;
    auto mod = n % sum;
    cout << (n / sum) * 3 + !!mod * (mod > a + b ? 3 : mod > a ? 2 : 1) << "\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

void solve() {
    auto [n, m, k] = read<int, int, int>();
    auto a = read_vec<int>(m);
    set<int> bzd;
    auto q = read_set<int>(k);
    int cnt = 0, unknown = -1;
    for (int i = 1; i <= n; i ++) {
        if (!q.count(i)) {
            cnt ++;
            unknown = i;
        }
    }
    for (auto &x : a) {
        if (!cnt or cnt == 1 and x == unknown)
            cout << 1;
        else
            cout << 0;
    }
    cout << "\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void solve() {
    auto [n, x, y] = read<int, i64, i64>();
    auto a = read_vec<int>(n);
    i64 sum = accumulate(a.begin(), a.end(), zero);
    auto count = [&a](i64 l, i64 r) {
        i64 cnt = 0;
        for (int i = 0; i < a.size(); i ++) {
            cnt += upper_bound(a.begin() + i + 1, a.end(), r - a[i]) - lower_bound(a.begin() + i + 1, a.end(), l - a[i]);
        }
        return cnt;
    };
    cout << count(max(zero, sum - y), sum - x) << "\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

void solve() {
    auto [n, k] = read<int, int>();
    auto a = read_vec<int>(n);
    auto b = read_vec<int>(n);
    ranges::sort(a); ranges::sort(b);
    auto price = vector<int>();
    ranges::set_union(a, b, back_inserter(price));
    
    auto ans = zero;
    for (auto p : price) {
        auto count = [&](auto &vec, auto p) {
            return distance(ranges::lower_bound(vec, p), vec.end());
        };
        i64 buyers = count(b, p); 
        i64 positive = count(a, p); 

        if (buyers - positive <= k)
            ans = max(ans, p * buyers);
    }
    cout << ans << "\n";
}