Submission #1042693

#	Time	Username	Problem	Language	Result	Execution time	Memory
1042693		ilovveyyou	Money (IZhO17_money)	C++14	0 / 100	1 ms	4700 KiB

money

#include <bits/stdc++.h>

using namespace std;

#define fi first
#define se second
#define ll long long
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mp(x, y) make_pair(x, y)
#define sz(v) ((int) (v).size())
#define all(v) (v).begin(), (v).end()
#define MASK(i) (1LL << (i))
#define BIT(x, y) (((x) >> (y)) & 1)
#define clz __builtin_clzll
#define ctz __builtin_ctzll
#define popcount __builtin_popcount
#define lg(x) (63 - clz(x))

template <class X, class Y>
    inline bool maximize(X &x, Y y) {
        return (x < y ? x = y, true : false);
    }
template <class X, class Y>
    inline bool minimize(X &x, Y y) {
        return (x > y ? x = y, true : false);
    }
template <class X>
    inline void compress(vector<X> &a) {
        sort(all(a)); a.resize(unique(all(a)) - a.begin());
    }

const ll oo = (ll) 1e18, inf = (ll) 1e9, mod = (ll) 1e9 + 7;
const int mxn = (int) 1e6 + 5, S = (int) 450, S2 = (int) 450, lg = (int) 18;

void add(ll &x, ll y) {
    x += y;
    if (x >= mod) x -= mod;
}

void sub(ll &x, ll y) {
    x -= y;
    if (x < 0) x += mod;
}

int n;
int a[mxn];

namespace one {
    bool one() {
        return n <= 1e3;
    }

    const int mxn = (int) 1e3 + 5;
    int f[mxn];
    vector<int> cur[mxn];

    void solve() {
        memset(f, 0x3f, sizeof f);
        f[0] = 0;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= i; ++j)
                cur[i].push_back(a[j]);
            compress(cur[i]);
        }
        for (int i = 1; i <= n; ++i) {
            f[i] = f[i-1] + 1;
            for (int j = i-1; j >= 1; --j) {
                if (a[j] > a[j+1]) break;
                if (a[i] == a[j]) {
                    minimize(f[i], f[j-1] + 1);
                    continue;
                }
                int cnt = upper_bound(all(cur[j-1]), a[i] - 1) - lower_bound(all(cur[j-1]), a[j] + 1);
                if (cnt != 0) break;
                minimize(f[i], f[j-1] + 1);
            }
        }
        cout << f[n];

        return;
    }
}

namespace two {

    bool two() {
        return true;
    }

    struct PerSeg {

        struct node {
            int s;
            int l, r;
            node() {
                s = 0;
                l = r = -1;
            }
        };
        int n;
        vector<node> st;
        vector<int> v;

        PerSeg(int n) : n(n) {
            create_node();

            v = {0};
            build(v[0], 1, n);
        }

        void create_node() {
            st.push_back(node());
        }

        void build(int i, int l, int r) {
            if (l == r) return;
            int m = (l + r) >> 1;

            if (st[i].l == -1) {
                create_node();
                st[i].l = sz(st) - 1;
            }
            if (st[i].r == -1) {
                create_node();
                st[i].r = sz(st) - 1;
            }

            build(st[i].l, l, m);
            build(st[i].r, m+1, r);
            return;
        }

        void upd(int p, int cur, int l, int r, int pos, int x) {
            if (l > pos || r < pos) return;
            if (l == r) {
                st[cur].s = st[p].s + x;
                return;
            }
            int m = (l + r) >> 1;
            if (pos > m) {
                st[cur].l = st[p].l;

                if (st[cur].r == -1) {
                    create_node();
                    st[cur].r = sz(st) - 1;
                }
                upd(st[p].r, st[cur].r, m+1, r, pos, x);

                st[cur].l = st[ st[p].l ].s + st[ st[cur].r ].s;
            }
            else {
                st[cur].r = st[p].r;
                if (st[cur].l == -1) {
                    create_node();
                    st[cur].l = sz(st) - 1;
                }
                upd(st[p].l, st[cur].l, l, m, pos, x);

                st[cur].l = st[ st[cur].l ].s + st[ st[p].r ].s;
            }
        }

        int upd(int pos, int x) {
            create_node();
            int root = sz(st) - 1;
            upd(v.back(), root, 1, n, pos, x);
            v.push_back(root);
            return root;
        }

        int get(int cur, int l, int r, int u, int v) {
            // if (cur == -1) {
            //     create_node();
            //     cur = sz(st) - 1;
            // }
            if (l > v || r < u) return 0;
            if (l >= u && r <= v) return st[cur].s;
            int m = (l + r) >> 1;

            if (st[cur].l == -1) create_node(), st[cur].l = sz(st) - 1;
            if (st[cur].r == -1) create_node(), st[cur].r = sz(st) - 1;

            int L = get(st[cur].l, l, m, u, v);
            int R = get(st[cur].r, m + 1, r, u, v);
            return L + R;
        }

        int get(int ver, int u, int v) {
            if (u > v) return 0;
            return get(ver, 1, n, u, v);
        }

    };

    int f[mxn];

    void solve() {
        int mx = a[max_element(a + 1, a + 1 + n) - a];

        PerSeg ps(mx);
        vector<int> events(n + 1, 0);
        for (int i = 1; i <= n; ++i) {
            events[i] = ps.upd(a[i], 1);
        }

        memset(f, 0x3f, sizeof f);

        f[0] = 0;
        for (int i = 1, p; i <= n; ++i) {
            f[i] = f[i-1] + 1; 
            for (int j = i-1; j >= 1; --j) {
                if (a[j] > a[j+1]) break;
                // cout << j-1 << ' ' << ps.get(events[j-1], a[j] + 1, a[i] - 1) << '\n';
                if (ps.get(events[j-1], a[j] + 1, a[i] - 1) == 0) {
                    p = j;
                    minimize(f[i], f[j-1] + 1);
                }
            }
            minimize(f[i], f[p-1] + 1);
        }

        cout << f[n];

        return;
    }
}

void solve() {

    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> a[i];

    {
        // if (one::one()) return one::solve();
        if (two::two()) return two::solve();
    }

    return;
}


int main() {

    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    #define TASK "task"
    if (fopen(TASK".inp", "r")) {
        freopen(TASK".inp", "r", stdin);
        freopen(TASK".out", "w", stdout);
    }

    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}

Compilation message (stderr)

money.cpp: In function 'int main()':
money.cpp:251:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  251 |         freopen(TASK".inp", "r", stdin);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
money.cpp:252:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  252 |         freopen(TASK".out", "w", stdout);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
money.cpp: In function 'void two::solve()':
money.cpp:220:31: warning: 'p' may be used uninitialized in this function [-Wmaybe-uninitialized]
  220 |             minimize(f[i], f[p-1] + 1);
      |                              ~^~

• Subtask 1: 0 / 9
• Subtask 2: 0 / 16
• Subtask 3: 0 / 20
• Subtask 4: 0 / 55