oj.uz

Submission #389845

# Submission time Handle Problem Language Result Execution time Memory
389845 2021-04-14T15:54:47 Z osaaateiasavtnl Fish (IOI08_fish) C++14
100 / 100
 1387 ms 65536 KB 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <fstream>
using namespace std;
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define x first
#define y second
#define Time (double)clock()/CLOCKS_PER_SEC
#define debug(x) std::cerr << #x << ": " << x << '\n';
#define FOR(i, n) for (int i = 0; i < n; ++i)
#define FORN(i, n) for (int i = 1; i <= n; ++i)
#define pb push_back
#define trav(a, x) for (auto& a : x)
using vi = vector<int>;
template <typename T>
std::istream& operator >>(std::istream& input, std::vector<T>& data)
{
    for (T& x : data)
        input >> x;
    return input;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const pair <T, T> & data)
{
    output << "(" << data.x << "," << data.y << ")";
    return output;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const std::vector<T>& data)
{
    for (const T& x : data)
        output << x << " ";
    return output;
}
ll div_up(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll div_down(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down 
ll math_mod(ll a, ll b) { return a - b * div_down(a, b); }
#define tcT template<class T
#define tcTU tcT, class U
tcT> using V = vector<T>; 
tcT> void re(V<T>& x) { 
    trav(a, x)
        cin >> a;
}
tcT> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; 
} // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; 
}
ll gcd(ll a, ll b) {
    while (b) {
        tie(a, b) = mp(b, a % b);
    }
    return a;
}
 
const int N = 5e5+7;
int n, k, MOD;
int tree[N << 2];
void setpoint(int v, int l, int r, int i, int x) {
    if (l == r) {
        tree[v] = x;
        return;
    }
    int m = (l + r) / 2;
    if (i <= m) {
        setpoint(v * 2 + 1, l, m, i, x);
    }
    else {
        setpoint(v * 2 + 2, m + 1, r, i, x);
    }
    tree[v] = tree[v * 2 + 1] * tree[v * 2 + 2] % MOD;
}
int get(int v, int tl, int tr, int l, int r) {
    if (tr < l || r < tl)
        return 1;
    if (l <= tl && tr <= r)
        return tree[v];
    int m = (tl + tr) / 2;
    return get(v * 2 + 1, tl, m, l, r) * get(v * 2 + 2, m + 1, tr, l, r) % MOD;
}

vi who[N];
int pos[N];
void setpoint(int c, int x) {
    x %= MOD;
    setpoint(0, 0, k - 1, pos[c], x);
}
int get(int l, int r) {
    return get(0, 0, k - 1, l, r);
}

struct Event {
    int x;
    bool t;
    int c;
};

signed main() {
    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    #else
    #define endl '\n'
    ios_base::sync_with_stdio(0); cin.tie(0);
    #endif
    cin >> n >> k >> MOD;
 
    FOR (i, (N << 2)) {
        tree[i] = 1;    
    }

    const int INF = 2e9;
    vi r(k + 1, -INF);

    auto comp = [&] (const Event a, const Event b) {
        return a.x < b.x || (a.x == b.x && a.t < b.t) || (a.x == b.x && a.t == b.t && a.c < b.c);
    };

    V <Event> sc;
    FOR (i, n) {
        int sz, c;
        cin >> sz >> c;
        sc.app({2 * sz, 0, c});
        ckmax(r[c], sz);
        who[c].app(sz);
    }
    FORN (i, k) {
        sc.app({r[i], 1, i});
    }
    sort(all(sc), comp);

    V <ii> ord;
    vi rs;
    FORN (c, k) {
        ord.app(mp(r[c], c));
        rs.app(r[c]);
    }
    sort(all(ord)); sort(all(rs));
    FOR (i, ord.size()) {
        pos[ord[i].y] = i;
    }

    vi used(k + 1), cur(k + 1);
    int ans = 0;
    trav (e, sc) {
        int col = e.c;
        if (e.t == 0) {
            cur[col]++;
            if (used[col]) {
                setpoint(col, cur[col] + 1);
            }
        }
        else {
            used[col] = 1;
            setpoint(col, cur[col] + 1);
            ans += tree[0];
            ans %= MOD;
        }
    }

    trav (e, cur) {
        e = 0;
    }

    FOR (i, (N << 2)) {
        tree[i] = 1;    
    }

    FORN (c, k) {
        sort(all(who[c]));
    }

    trav (e, sc) {
        int col = e.c;
        if (e.t == 0) {
            cur[col]++;
            setpoint(col, cur[col] + 1);
        }
        else {
            int eat = 0;
            while (2 * who[col][eat] <= r[col]) {
                eat++;
            }
            int alive = who[col][eat];

            setpoint(col, cur[col] + 1);

            int right = lower_bound(all(rs), alive * 2) - rs.begin() - 1;

            ll L = get(0, pos[col] - 1);
            ll R = get(pos[col] + 1, right);
            ans += L * (R + MOD - 1);
            ans %= MOD;
        }
    }

    cout << ans << endl;
}

Compilation message

fish.cpp: In function 'int main()':
fish.cpp:32:37: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   32 | #define FOR(i, n) for (int i = 0; i < n; ++i)
......
  162 |     FOR (i, ord.size()) {
      |          ~~~~~~~~~~~~~               
fish.cpp:162:5: note: in expansion of macro 'FOR'
  162 |     FOR (i, ord.size()) {
      |     ^~~

Subtask #1
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 14 ms 19788 KB Output is correct

Subtask #2
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 14 ms 19788 KB Output is correct

Subtask #3
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 14 ms 19788 KB Output is correct

Subtask #4
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 13 ms 19880 KB Output is correct

Subtask #5
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 13 ms 19796 KB Output is correct
2 Correct 14 ms 19916 KB Output is correct

Subtask #6
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 15 ms 19928 KB Output is correct
2 Correct 257 ms 28252 KB Output is correct

Subtask #7
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 14 ms 19916 KB Output is correct

Subtask #8
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 16 ms 19916 KB Output is correct

Subtask #9
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 119 ms 23600 KB Output is correct
2 Correct 145 ms 24672 KB Output is correct

Subtask #10
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 17 ms 20044 KB Output is correct
2 Correct 19 ms 20044 KB Output is correct
3 Correct 19 ms 20044 KB Output is correct

Subtask #11
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 199 ms 27756 KB Output is correct
2 Correct 338 ms 28240 KB Output is correct
3 Correct 351 ms 29420 KB Output is correct

Subtask #12
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 237 ms 29028 KB Output is correct
2 Correct 351 ms 28964 KB Output is correct

Subtask #13
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 220 ms 27968 KB Output is correct
2 Correct 370 ms 28988 KB Output is correct

Subtask #14
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 337 ms 28560 KB Output is correct

Subtask #15
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 426 ms 30020 KB Output is correct

Subtask #16
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 393 ms 29416 KB Output is correct
2 Correct 665 ms 37560 KB Output is correct

Subtask #17
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 734 ms 37912 KB Output is correct
2 Correct 571 ms 39656 KB Output is correct

Subtask #18
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 565 ms 39100 KB Output is correct
2 Correct 675 ms 45216 KB Output is correct
3 Correct 725 ms 48216 KB Output is correct
4 Correct 712 ms 45160 KB Output is correct

Subtask #19
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 893 ms 40536 KB Output is correct
2 Correct 1293 ms 65536 KB Output is correct
3 Correct 1387 ms 65536 KB Output is correct
4 Correct 1332 ms 63048 KB Output is correct