Submission #836305

#	Time	Username	Problem	Language	Result	Execution time	Memory
836305		green_gold_dog	Fire (JOI20_ho_t5)	C++17	0 / 100	422 ms	189388 KiB

ho_t5

//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,sse,sse2,sse3,ssse3,sse4,abm,popcnt,mmx")
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;
typedef long double ldb;
typedef complex<double> cd;

constexpr ll INF64 = 9'000'000'000'000'000'000, INF32 = 2'000'000'000, MOD = 1'000'000'007;
constexpr db PI = acos(-1);
constexpr bool IS_FILE = false, IS_TEST_CASES = false;

random_device rd;
mt19937 rnd32(rd());
mt19937_64 rnd64(rd());

template<typename T>
bool assign_max(T& a, T b) {
        if (b > a) {
                a = b;
                return true;
        }
        return false;
}

template<typename T>
bool assign_min(T& a, T b) {
        if (b < a) {
                a = b;
                return true;
        }
        return false;
}

template<typename T>
T square(T a) {
        return a * a;
}

template<>
struct std::hash<pair<ll, ll>> {
        ll operator() (pair<ll, ll> p) const {
                return ((__int128)p.first * MOD + p.second) % INF64;
        }
};

struct sparce_table {
        vector<vector<pair<ll, ll>>> arr;
        vector<ll> lg;
        sparce_table(vector<ll> a) {
                lg.push_back(0);
                while (lg.size() <= a.size()) {
                        lg.push_back(lg.back());
                        if ((1 << (lg.back() + 1)) == lg.size() - 1) {
                                lg.back()++;
                        }
                }
                arr.resize(lg.back() + 1, vector<pair<ll, ll>>(a.size()));
                for (ll i = 0; i < a.size(); i++) {
                        arr[0][i] = make_pair(a[i], i);
                }
                for (ll i = 1; i <= lg.back(); i++) {
                        for (ll j = 0; j + (1 << (i - 1)) < a.size(); j++) {
                                arr[i][j] = max(arr[i - 1][j], arr[i - 1][j + (1 << (i - 1))]);
                        }
                }
        }
        pair<ll, ll> get(ll l, ll r) {
                return max(arr[lg[r - l]][l], arr[lg[r - l]][r - (1 << lg[r - l])]);
        }
};

struct BIT {
        vector<ll> tree;
        BIT(ll n) {
                tree.resize(n + 1, 0);
        }
        void add(ll x, ll y) {
                x++;
                for (ll i = x; i < tree.size(); i += i & -i) {
                        tree[i] += y;
                }
        }
        ll get(ll x) {
                ll ans = 0;
                for (ll i = x; i > 0; i -= i & -i) {
                        ans += tree[i];
                }
                return ans;
        }
        ll get(ll l, ll r) {
                return get(r) - get(l);
        }
};

void solve() {
        ll n, q;
        cin >> n >> q;
        vector<ll> arr(n);
        for (ll i = 0; i < n; i++) {
                cin >> arr[i];
        }
        sparce_table st(arr);
        BIT b(n), a(n);
        for (ll i = 0; i < n; i++) {
                b.add(i, arr[i]);
        }
        vector<vector<pair<ll, ll>>> s(n + 1);
        for (ll i = 0; i < n; i++) {
                s[0].emplace_back(i, arr[i]);
                ll l = i, r = n;
                while (r - l > 1) {
                        ll mid = (l + r) / 2;
                        if (st.get(i, mid + 1).second == i) {
                                l = mid;
                        } else {
                                r = mid;
                        }
                }
                s[l - i].emplace_back(i, -arr[i]);
                if (st.get(0, i + 1).second != i) {
                        ll nl = 0, nr = i;
                        while (nr - nl > 1) {
                                ll mid = (nl + nr) / 2;
                                if (st.get(mid, i + 1).second == i) {
                                        nr = mid;
                                } else {
                                        nl = mid;
                                }
                        }
                        s[i - nr].emplace_back(i, -arr[i]);
                        s[l - nl].emplace_back(i, arr[i]);
                }
        }
        vector<vector<tuple<ll, ll, ll>>> qs(n + 1);
        for (ll i = 0; i < q; i++) {
                ll t, l, r;
                cin >> t >> l >> r;
                l--;
                qs[t].emplace_back(l, r, i);
        }
        sort(qs.begin(), qs.end());
        vector<ll> ans(n);
        for (ll i = 0; i <= n; i++) {
                for (auto[j, k] : s[i]) {
                        b.add(j, -k*i);
                        a.add(j, k);
                }
                for (auto[l, r, j] : qs[i]) {
                        ll nr = st.get(max(0ll, r - i - 1), r).second;
                        ll sl = -1, sr = r - 1;
                        while (sr - sl > 1) {
                                ll mid = (sl + sr) / 2;
                                if (st.get(max(0ll, mid - i), mid + 1).second == nr) {
                                        sr = mid;
                                } else {
                                        sl = mid;
                                }
                        }
                        ll nl = st.get(max(0ll, l - i), l + 1).second;
                        ans[j] = b.get(nl, nr) + a.get(nl, nr) * i + arr[nr] * (r - sr) - arr[nl] * (l - nl);
                }
        }
        for (auto i : ans) {
                cout << i << '\n';
        }
}

int main() {
        if (IS_FILE) {
                freopen("", "r", stdin);
                freopen("", "w", stdout);
        }
        ios_base::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        ll t = 1;
        if (IS_TEST_CASES) {
                cin >> t;
        }
        for (ll i = 0; i < t; i++) {
                solve();
        }
}

Compilation message (stderr)

ho_t5.cpp: In constructor 'sparce_table::sparce_table(std::vector<long long int>)':
ho_t5.cpp:57:52: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   57 |                         if ((1 << (lg.back() + 1)) == lg.size() - 1) {
      |                             ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~
ho_t5.cpp:62:34: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   62 |                 for (ll i = 0; i < a.size(); i++) {
      |                                ~~^~~~~~~~~~
ho_t5.cpp:66:59: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   66 |                         for (ll j = 0; j + (1 << (i - 1)) < a.size(); j++) {
      |                                        ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~
ho_t5.cpp: In member function 'void BIT::add(ll, ll)':
ho_t5.cpp:83:34: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   83 |                 for (ll i = x; i < tree.size(); i += i & -i) {
      |                                ~~^~~~~~~~~~~~~
ho_t5.cpp: In function 'int main()':
ho_t5.cpp:174:24: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  174 |                 freopen("", "r", stdin);
      |                 ~~~~~~~^~~~~~~~~~~~~~~~
ho_t5.cpp:175:24: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  175 |                 freopen("", "w", stdout);
      |                 ~~~~~~~^~~~~~~~~~~~~~~~~

• Subtask 1: 0 / 1
• Subtask 2: 0 / 6
• Subtask 3: 0 / 7
• Subtask 4: 0 / 6
• Subtask 5: 0 / 80