Submission #1271248

#	Time	Username	Problem	Language	Result	Execution time	Memory
1271248		thieunguyenhuy	Sterilizing Spray (JOI15_sterilizing)	C++20	0 / 100	5095 ms	1136 KiB

sterilizing

#include <bits/stdc++.h>
using namespace std;

#define POPCOUNT(n) (__builtin_popcountll((n)))
#define CLZ(n) (__builtin_clzll((n)))
#define CTZ(n) (__builtin_ctzll((n)))
#define LOG(n) (63 - __builtin_clzll((n)))
#define BIT(n, i) (((n) >> (i)) & 1ll)
#define MASK(i) (1ll << (i))
#define FLIP(n, i) ((n) ^ (1ll << (i)))
#define ON(n, i) ((n) | MASK(i))
#define OFF(n, i) ((n) & ~MASK(i))

#define Int __int128
#define fi first
#define se second

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef pair<long long, int> pli;
typedef pair<int, long long> pil;
typedef vector<pair<int, int>> vii;
typedef vector<pair<long long, long long>> vll;
typedef vector<pair<long long, int>> vli;
typedef vector<pair<int, long long>> vil;

template <class T1, class T2> bool maximize(T1 &x, T2 y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}
template <class T1, class T2> bool minimize(T1 &x, T2 y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}

template <class T> void remove_duplicate(vector<T> &ve) {
    sort (ve.begin(), ve.end());
    ve.resize(unique(ve.begin(), ve.end()) - ve.begin());
}

mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
long long random(long long l, long long r) {
    return uniform_int_distribution<long long>(l, r)(rng);
}
unsigned long long random(unsigned long long l, unsigned long long r) {
    return uniform_int_distribution<unsigned long long>(l, r)(rng);
}
template <class T> T random(T r) {
    return rng() % r;
}

const int N = 1e5 + 5, SQR = 369, NUM_BLOCKS = N / SQR + 5, LG = 33;
const int MOD = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e18;

int n, q, k;
int c[N], blockId[N];
int cnt[NUM_BLOCKS];
ll sum[NUM_BLOCKS][LG];

void freeBlock(int id) {
    minimize(cnt[id], LG);
    for (int i = 0; i < LG; ++i) sum[id][i] = 0;
    for (int i = id * SQR; i < min(n, (id + 1) * SQR); ++i) {
        for (int _ = 0; _ < cnt[id]; ++_) c[i] /= k;
        for (int j = 0, tmp = c[i]; j < LG; ++j) sum[id][j] += tmp, tmp /= k;
    }
    cnt[id] = 0;
}

void update_single(int p, int val) {
    int id = blockId[p];
    for (int j = 0, tmp = c[p]; j < LG; ++j) sum[id][j] -= tmp, tmp /= k;
    c[p] = val;
    for (int j = 0, tmp = c[p]; j < LG; ++j) sum[id][j] += tmp, tmp /= k; 
}

void update(int l, int r) {
    int blockL = (l + SQR - 1) / SQR, blockR = blockId[r];

    if (blockL >= blockR) {
        freeBlock(blockR);
        for (int i = l; i <= r; ++i) update_single(i, c[i] / k);
        return;
    }

    for (int i = blockL; i < blockR; ++i) ++cnt[i];

    freeBlock(blockId[l]), freeBlock(blockR);
    for (int i = l; i < blockL * SQR; ++i) update_single(i, c[i] / k);
    for (int i = blockR * SQR; i <= r; ++i) update_single(i, c[i] / k);
}

ll get(int l, int r) {
    int blockL = (l + SQR - 1) / SQR, blockR = blockId[r];
    ll ans = 0;

    if (blockL >= blockR) {
        freeBlock(blockR);
        for (int i = l; i <= r; ++i) ans += c[i];
        return ans;
    }

    for (int i = blockL; i < blockR; ++i) {
        if (cnt[i] < LG) ans += sum[i][cnt[i]];
    }

    freeBlock(blockId[l]), freeBlock(blockR);
    for (int i = l; i < blockL * SQR; ++i) ans += c[i];
    for (int i = blockR * SQR; i <= r; ++i) ans += c[i];
    return ans;
}

namespace sub3 {
    struct SegmentTree {
        vector<ll> nodes;
        int n;
    
        SegmentTree() {}
    
        void resize(int _n) {
            n = _n; nodes.assign(2 * n + 5, 0);
        }
    
        void update(int p, int val) {
            for (nodes[p += n] = val; p >>= 1;)
                nodes[p] = nodes[p << 1] + nodes[p << 1 | 1];
        }
    
        ll get(int l, int r) {
            ll ansL = 0, ansR = 0;
            for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
                if (l & 1) ansL = ansL + nodes[l++];
                if (r & 1) ansR = nodes[--r] + ansR;
            }
            return ansL + ansR;
        }
    } mytree;

    void solve() {
        mytree.resize(n);
        for (int i = 1; i <= n; ++i) mytree.update(i, c[i - 1]);

        for (int i = 1; i <= q; ++i) {
            int type, x, y; cin >> type >> x >> y;
            if (type == 1) mytree.update(x, y);
            if (type == 3) cout << mytree.get(x, y) << '\n';
        }
    }
}

signed main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    #ifdef hwe
        freopen("D:/Code/Contests/input.inp", "r", stdin);
        freopen("D:/Code/Contests/output.out", "w", stdout);
    #else
        #define taskname ""
        if (fopen(taskname".inp", "r")) {
            freopen(taskname".inp", "r", stdin);
            freopen(taskname".out", "w", stdout);
        }
    #endif

    cin >> n >> q >> k;

    for (int i = 0; i < n; ++i) {
        int x; cin >> x;
        blockId[i] = i / SQR;
        update_single(i, x);
    }

    // if (k == 1) return sub3::solve(), 0;

    // cerr << get(0, n - 1) << '\n';

    for (int i = 1; i <= q; ++i) {
        int type, x, y; cin >> type >> x >> y;
        if (type == 1) {
            --x; freeBlock(blockId[x]);
            update_single(x, y);
        }
        if (type == 2) {
            --x, --y;
            update(x, y);
        }
        if (type == 3) {
            --x, --y;
            cout << get(x, y) << '\n';
        }
    }

    return 0;
}

Compilation message (stderr)

sterilizing.cpp: In function 'int main()':
sterilizing.cpp:171:20: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  171 |             freopen(taskname".inp", "r", stdin);
      |             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
sterilizing.cpp:172:20: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  172 |             freopen(taskname".out", "w", stdout);
      |             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~

• Subtask 1: 0 / 5
• Subtask 2: 0 / 10
• Subtask 3: 0 / 10
• Subtask 4: 0 / 75